From c343e95f8d5d1eabd293662af9a98300b8775b94 Mon Sep 17 00:00:00 2001 From: CJ Quines Date: Tue, 8 Jul 2025 17:20:22 -0700 Subject: [PATCH 1/2] feat: add preview actions --- .eslintignore | 4 +- .gitattributes | 1 + .github/workflows/build.yml | 26 +- .github/workflows/release.yml | 31 + .github/workflows/{lint.yml => test.yml} | 13 +- .gitignore | 104 - .gitlab-ci.yml | 1 - .husky/pre-commit | 6 - LICENSE | 1 - README.md | 253 +- action.yml | 7 +- build/action.yml | 107 + dist/build.js | 21892 +++++++ dist/index.js | 66522 +++++++++------------ dist/licenses.txt | 353 - dist/merge.js | 33660 +++++++++++ dist/preview.js | 33784 +++++++++++ examples/README.md | 35 + examples/github-action.yml | 27 - examples/gitlab-ci.yml | 29 - examples/pull_request.yml | 86 + examples/pull_request_mintlify.yml | 111 + examples/pull_request_readme.yml | 104 + examples/push.yml | 59 + examples/push_mintlify.yml | 84 + examples/push_readme.yml | 77 + merge/action.yml | 117 + package-lock.json | 3322 + package.json | 47 +- preview/action.yml | 127 + src/__snapshots__/comment.test.ts.snap | 70 + src/build.ts | 57 + src/comment.test.ts | 319 + src/comment.ts | 636 + src/config.ts | 42 + index.ts => src/index.ts | 0 src/markdown.ts | 97 + src/merge.ts | 130 + src/preview.ts | 314 + src/runBuilds.ts | 375 + tsconfig.json | 60 +- yarn.lock | 1014 - 42 files changed, 123949 insertions(+), 40155 deletions(-) create mode 100644 .gitattributes create mode 100644 .github/workflows/release.yml rename .github/workflows/{lint.yml => test.yml} (50%) delete mode 100755 .husky/pre-commit delete mode 100644 LICENSE create mode 100644 build/action.yml create mode 100644 dist/build.js delete mode 100644 dist/licenses.txt create mode 100644 dist/merge.js create mode 100644 dist/preview.js create mode 100644 examples/README.md delete mode 100644 examples/github-action.yml delete mode 100644 examples/gitlab-ci.yml create mode 100644 examples/pull_request.yml create mode 100644 examples/pull_request_mintlify.yml create mode 100644 examples/pull_request_readme.yml create mode 100644 examples/push.yml create mode 100644 examples/push_mintlify.yml create mode 100644 examples/push_readme.yml create mode 100644 merge/action.yml create mode 100644 package-lock.json create mode 100644 preview/action.yml create mode 100644 src/__snapshots__/comment.test.ts.snap create mode 100644 src/build.ts create mode 100644 src/comment.test.ts create mode 100644 src/comment.ts create mode 100644 src/config.ts rename index.ts => src/index.ts (100%) create mode 100644 src/markdown.ts create mode 100644 src/merge.ts create mode 100644 src/preview.ts create mode 100644 src/runBuilds.ts delete mode 100644 yarn.lock diff --git a/.eslintignore b/.eslintignore index 1f48ac45..1521c8b7 100644 --- a/.eslintignore +++ b/.eslintignore @@ -1,3 +1 @@ -/scratchpad/ -/test-sdks/ -/dist/ \ No newline at end of file +dist diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..e62788be --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +dist/** linguist-generated=true diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index f93196d1..43563b9d 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -3,14 +3,30 @@ name: build on: push jobs: - eslint: + build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 + with: + # use a token so we trigger release-please if needed + token: ${{ secrets.BOT_GITHUB_TOKEN }} - name: Setup Node uses: actions/setup-node@v4 with: - cache: "yarn" - node-version: "20" - - run: yarn install - - run: yarn run build + node-version: "22" + - name: Install dependencies + run: npm install + - name: Build TypeScript + run: npm run build + - name: Commit build changes + if: ${{ github.ref == 'refs/heads/main' }} + run: | + git config --local user.name "github-actions[bot]" + git config --local user.email "github-actions[bot]@users.noreply.github.com" + git add dist + if git diff --cached --quiet HEAD; then + echo "No changes to commit." + else + git commit -m "chore(build): Update dist" + git push + fi diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..0c8bc143 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,31 @@ +name: release + +on: + push: + branches: + - main + +jobs: + release: + runs-on: ubuntu-latest + + steps: + - uses: googleapis/release-please-action@v4 + id: release + with: + release-type: node + target-branch: ${{ github.ref_name }} + - uses: actions/checkout@v4 + - name: tag major and minor versions + if: ${{ steps.release.outputs.release_created }} + run: | + git config --local user.name "github-actions[bot]" + git config --local user.email "github-actions[bot]@users.noreply.github.com" + git tag -d v${{ steps.release.outputs.major }} || true + git tag -d v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }} || true + git push origin :v${{ steps.release.outputs.major }} || true + git push origin :v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }} || true + git tag -a v${{ steps.release.outputs.major }} -m "Release v${{ steps.release.outputs.major }}" + git tag -a v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }} -m "Release v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }}" + git push origin v${{ steps.release.outputs.major }} + git push origin v${{ steps.release.outputs.major }}.${{ steps.release.outputs.minor }} diff --git a/.github/workflows/lint.yml b/.github/workflows/test.yml similarity index 50% rename from .github/workflows/lint.yml rename to .github/workflows/test.yml index eb585e19..576a28db 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/test.yml @@ -1,16 +1,17 @@ -name: lint +name: test on: push jobs: - eslint: + test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Setup Node uses: actions/setup-node@v4 with: - cache: "yarn" - node-version: "20" - - run: yarn install - - run: yarn run lint + node-version: "22" + - name: Install dependencies + run: npm install + - name: Run tests + run: npm run test diff --git a/.gitignore b/.gitignore index d5f32a97..c2658d7d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,105 +1 @@ -# Logs -logs -*.log -npm-debug.log* -yarn-debug.log* -yarn-error.log* -lerna-debug.log* - -# Diagnostic reports (https://nodejs.org/api/report.html) -report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json - -# Runtime data -pids -*.pid -*.seed -*.pid.lock - -# Directory for instrumented libs generated by jscoverage/JSCover -lib-cov - -# Coverage directory used by tools like istanbul -coverage -*.lcov - -# nyc test coverage -.nyc_output - -# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) -.grunt - -# Bower dependency directory (https://bower.io/) -bower_components - -# node-waf configuration -.lock-wscript - -# Compiled binary addons (https://nodejs.org/api/addons.html) -build/Release - -# Dependency directories node_modules/ -jspm_packages/ - -# TypeScript v1 declaration files -typings/ - -# TypeScript cache -*.tsbuildinfo - -# Optional npm cache directory -.npm - -# Optional eslint cache -.eslintcache - -# Microbundle cache -.rpt2_cache/ -.rts2_cache_cjs/ -.rts2_cache_es/ -.rts2_cache_umd/ - -# Optional REPL history -.node_repl_history - -# Output of 'npm pack' -*.tgz - -# Yarn Integrity file -.yarn-integrity - -# dotenv environment variables file -.env -.env.test - -# parcel-bundler cache (https://parceljs.org/) -.cache - -# Next.js build output -.next - -# Nuxt.js build / generate output -.nuxt - -# Gatsby files -.cache/ -# Comment in the public line in if your project uses Gatsby and *not* Next.js -# https://nextjs.org/blog/next-9-1#public-directory-support -# public - -# vuepress build output -.vuepress/dist - -# Serverless directories -.serverless/ - -# FuseBox cache -.fusebox/ - -# DynamoDB Local files -.dynamodb/ - -# TernJS port file -.tern-port - -lithic* diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 969e5957..cfa23cf4 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -7,7 +7,6 @@ image: node:20-alpine - apk add --no-cache git - git clone https://github.com/stainless-api/upload-openapi-spec-action.git - cd upload-openapi-spec-action - - yarn install - node dist/index.js variables: INPUT_STAINLESS_API_KEY: $STAINLESS_API_KEY diff --git a/.husky/pre-commit b/.husky/pre-commit deleted file mode 100755 index c70f97ca..00000000 --- a/.husky/pre-commit +++ /dev/null @@ -1,6 +0,0 @@ -#!/usr/bin/env sh -. "$(dirname -- "$0")/_/husky.sh" - -yarn run build -git add dist/index.js -git add dist/licenses.txt diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 8a5d9973..00000000 --- a/LICENSE +++ /dev/null @@ -1 +0,0 @@ -Copyright Stainless 2022 \ No newline at end of file diff --git a/README.md b/README.md index 4ceb600d..3c2dab6a 100644 --- a/README.md +++ b/README.md @@ -1,196 +1,129 @@ -# Upload your OpenAPI spec to Stainless (GitHub Action & GitLab CI) +# Build Stainless SDKs from GitHub Actions -``` -stainless-api/upload-openapi-spec -``` - -[![lint](https://github.com/stainless-api/upload-openapi-spec-action/actions/workflows/lint.yml/badge.svg)](https://github.com/stainless-api/upload-openapi-spec-action/actions/workflows/lint.yml) -[![build](https://github.com/stainless-api/upload-openapi-spec-action/actions/workflows/build.yml/badge.svg)](https://github.com/stainless-api/upload-openapi-spec-action/actions/workflows/build.yml) - -A CI component for pushing your OpenAPI spec to [Stainless](https://stainless.com/) to trigger regeneration of your SDKs. Supports both GitHub Actions and GitLab CI. - -Note that there is currently a manual step in between this action and automatic creation of your PR's, -and more manual steps before they are merged and released. - -If your account is configured to do so, this action can also output a copy of your OpenAPI spec decorated with sample code snippets, -so that your API reference documentation can show examples of making each request with the user's chosen SDK -(e.g. show `client.items.list()` instead of `curl https://api.my-company.com/items`). +GitHub Actions for building [Stainless](https://stainless.com/) SDKs and +previewing changes to an SDK from a pull request. -## Example usage +## Usage -First, obtain an API Key from your Stainless dashboard. +Get an API key from your Stainless organization dashboard. In the GitHub +repository that stores your ground truth OpenAPI spec, add the key to the +[repository secrets](https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions#creating-secrets-for-a-repository) +with the name `STAINLESS_API_KEY`. You can do this with the GitHub CLI via: -### GitHub Actions - -For GitHub Actions, [add the API key to your repository secrets](https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions#creating-secrets-for-a-repository) as `STAINLESS_API_KEY`: - -``` +```bash gh secret set STAINLESS_API_KEY ``` -Then, in your repo that stores your ground truth OpenAPI spec, add a new workflow file, or add the action to an existing workflow: +In the same repository, add a new workflow file: -```yaml -name: Upload OpenAPI spec to Stainless +
+.github/workflows/stainless.yml + +```yml +name: Build SDKs for pull request on: - push: - branches: [main] - workflow_dispatch: + pull_request: + types: + - opened + - synchronize + - reopened + - closed + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number }} + cancel-in-progress: true + +env: + STAINLESS_ORG: YOUR_ORG + STAINLESS_PROJECT: YOUR_PROJECT + OAS_PATH: YOUR_OAS_PATH jobs: - stainless: + preview: + if: github.event.action != 'closed' runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write steps: - - uses: actions/checkout@v4 - - uses: stainless-api/upload-openapi-spec-action@main + - name: Checkout repository + uses: actions/checkout@v4 with: - stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} - input_path: "path/to/my-company-openapi.json" - project_name: "my-stainless-project" - commit_message: "feat(api): my cool feature" - guess_config: true -``` - -You can optionally add `config_path: 'path/to/my-company.stainless.yaml'` to the `with:` block if you'd like to send us updates to your Stainless config. - -### GitLab CI - -For GitLab CI, add the API key to your [GitLab CI/CD variables](https://docs.gitlab.com/ee/ci/variables/#add-a-cicd-variable-to-a-project) as `STAINLESS_API_KEY`. - -Then, add the following to your `.gitlab-ci.yml` file: - -```yaml -include: - - remote: "https://raw.githubusercontent.com/stainless-api/upload-openapi-spec-action/main/.gitlab-ci.yml" - -upload-openapi-spec: - extends: .upload-openapi-spec - variables: - STAINLESS_API_KEY: "$STAINLESS_API_KEY" - INPUT_PATH: "$CI_PROJECT_DIR/path/to/my-company-openapi.json" - PROJECT_NAME: "my-stainless-project" - COMMIT_MESSAGE: "feat(api): my cool feature" - GUESS_CONFIG: "true" - # CONFIG_PATH: '$CI_PROJECT_DIR/path/to/my-company.stainless.yaml' # Optional - # OUTPUT_PATH: '$CI_PROJECT_DIR/path/to/output.json' # Optional - # BRANCH: 'main' # Optional -``` - -You can identify your Stainless project name on the [Stainless dashboard](https://app.stainless.com/). - -### Optional parameters - -- `branch`: Specifies the branch to push files to. If you provide it, the project MUST have the [branches - feature](https://app.stainless.com/docs/guides/branches) enabled. By default, it is `main`. - -- `commit_message`: Specifies the commit message that we will use for the commits generated for your SDKs as a result - of the API change (and which will subsequently appear in the Changelog). If you provide it, it MUST follow the - [Conventional Commits format](https://www.conventionalcommits.org/en/v1.0.0/). If you do not provide it, we will use a - default message. - -- `guess_config`: When `true`, will update your Stainless config file based on the change you've made to your spec. This - does the same thing as selecting the "Generate missing endpoints" button in the Studio. By default, it is `false`. You - should not set this to `true` if you are passing a `config_path`. + fetch-depth: 2 -## Usage with ReadMe for docs with example snippets - -If you sync an OpenAPI file to your [ReadMe API Reference](https://readme.com/), add the following to your Stainless config: - -```yaml -openapi: - code_samples: readme -``` - -### GitHub Actions with ReadMe - -Configure your GitHub Action to upload the Stainless-enhanced OpenAPI spec to ReadMe: - -```yaml -name: Upload OpenAPI spec to Stainless and ReadMe - -on: - push: - branches: [main] - workflow_dispatch: + - name: Run preview builds + uses: stainless-api/upload-openapi-spec-action/preview@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} -jobs: - stainless: + merge: + if: github.event.action == 'closed' && github.event.pull_request.merged == true runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write steps: - - uses: actions/checkout@v4 - - uses: stainless-api/upload-openapi-spec-action@main + - name: Checkout repository + uses: actions/checkout@v4 with: - stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} - input_path: "path/to/my-company-openapi.json" - output_path: "path/to/my-company-openapi.documented.json" - project_name: "my-stainless-project" - commit_message: "feat(api): my cool feature" - - uses: readmeio/rdme@v8 + fetch-depth: 2 + + - name: Run merge build + uses: stainless-api/upload-openapi-spec-action/merge@v1 with: - rdme: openapi "path/to/my-company-openapi.documented.json" --key=${{ secrets.README_TOKEN }} --id=${{ secrets.README_DEFINITION_ID }} + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} ``` +
-This assumes the following secrets have been [uploaded to your GitHub Actions Secrets](https://docs.github.com/en/actions/security-guides/encrypted-secrets): +Then, pull requests to your GitHub repository that update OpenAPI spec or +Stainless config will build your SDKs and make a comment with the results. -- `secrets.STAINLESS_API_KEY`: Your Stainless API key. -- `secrets.README_TOKEN`: Your [ReadMe API key](https://docs.readme.com/main/reference/intro/authentication#api-key-quick-start). Only sent to ReadMe's servers. -- `secrets.README_DEFINITION_ID`: According to [ReadMe's documentation](https://docs.readme.com/main/docs/openapi-resyncing#api-definition-ids), - this can be obtained by "clicking edit on the API definition on your project API definitions page". Only sent to ReadMe's servers. +For more details about the input parameters, see the +[example workflow](./examples/pull_request.yml) file. -Remember to set the `readmeio/rdme` ref version to the latest stable available (`v8`, as of this writing). You can verify the latest version of ReadMe's GitHub Action [here](https://github.com/marketplace/actions/rdme-sync-to-readme). +For more examples of usage, including push-based workflows, using code samples, +and integration with docs platforms, see the [examples directory](./examples). -## Usage with Mintlify for docs with example snippets +## Actions -If you use Mintlify's OpenAPI support for your API reference documentation, -add the following to your Stainless config: +This repository provides three GitHub actions. -```yaml -openapi: - code_samples: mintlify -``` +- `stainless-api/upload-openapi-spec-action/build`: Build SDKs for a Stainless +project. For information about the input parameters, see the [action +definition](./build/action.yml). -Mintlify can generate your docs based on the OpenAPI spec in your docs repo if it is [configured to do so](https://mintlify.com/docs/api-playground/openapi/setup#in-the-repo). +- `stainless-api/upload-openapi-spec-action/preview`: Preview changes to SDKs +introduced by a pull request. For information about the input parameters, see +the [action definition](./preview/action.yml). -### GitHub Actions with Mintlify +- `stainless-api/upload-openapi-spec-action/merge`: Merge changes to SDKs from +a pull request. For information about the input parameters, see the [action +definition](./merge/action.yml). -To integrate Stainless with your GitHub Actions workflow: +### Workflow permissions -```yaml -name: Upload OpenAPI spec to Stainless and (Mintlify) docs repo +The GitHub actions use the following +[workflow permissions](https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#jobsjob_idpermissions): -on: - push: - branches: [main] - workflow_dispatch: +- The `preview` and `merge` actions have a `make_comment` input, which, if set, +will comment on the pull request with the build results. This is set to true by +default. The actions use the `github_token` input to make a comment, and the +comment must have the `pull-requests: write` permission. -jobs: - stainless: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - name: Push spec and config to Stainless and output documented spec - uses: stainless-api/upload-openapi-spec-action@main - with: - stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} - input_path: "path/to/my-company-openapi.json" - output_path: "path/to/my-company-openapi.documented.json" - project_name: "my-stainless-project" - commit_message: "feat(api): my cool feature" - - name: Push documented spec to docs repo - uses: dmnemec/copy_file_to_another_repo_action@main - env: - API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }} - with: - source_file: "path/to/my-company-openapi.documented.json" - destination_repo: "{DOCS_REPO_NAME}" - destination_folder: "openapi-specs" # (optional) the folder in the destination repository to place the file in, if not the root directory - user_email: "{EMAIL}" # the email associated with the GH token - user_name: "{USERNAME}" # the username associated with the GH token - commit_message: "Auto-updates from Stainless" -``` +- The `preview` action relies on being in a Git repository that can fetch from +the remote to determine base revisions. This will be the case if you use the +[`actions/checkout`](https://github.com/actions/checkout) GitHub action +beforehand. That action needs the `contents: read` permission. -This assumes the following secrets have been [uploaded to your GitHub Actions Secrets](https://docs.github.com/en/actions/security-guides/encrypted-secrets): +### Versioning policy -- `secrets.STAINLESS_API_KEY`: Your Stainless API key. -- `secrets.API_TOKEN_GITHUB`: A GitHub [Personal Access Token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) with permissions to push to your docs repo. +This action is in public beta, and breaking changes may be introduced in any +commit. We recommend pinning your actions to a full-length commit SHA to avoid +potential breaking changes. diff --git a/action.yml b/action.yml index eb6551ae..708fa293 100644 --- a/action.yml +++ b/action.yml @@ -1,5 +1,8 @@ -name: Stainless — Upload OpenAPI specification -description: Upload your OpenAPI spec to update your Stainless SDKs (and, if configured, add example snippets to your API docs). Works with GitHub Actions and GitLab CI. +# This action is provided for backward-compatibility purposes; do not use it +# for new projects. Instead, use `upload-openapi-spec-action/build`. + +name: Stainless — Build SDK +description: Build SDKs branding: icon: book-open color: green diff --git a/build/action.yml b/build/action.yml new file mode 100644 index 00000000..b9a56107 --- /dev/null +++ b/build/action.yml @@ -0,0 +1,107 @@ +name: Stainless — Build SDK +description: Build SDKs +branding: + icon: book-open + color: green +runs: + using: node20 + main: dist/build.js +inputs: + stainless_api_key: + description: Stainless API key. + required: true + project: + description: Stainless project name. + required: true + oas_path: + description: >- + Path to your OpenAPI spec. If omitted, and `merge_branch` is false, + will use the existing OpenAPI spec on the Stainless branch. + required: false + config_path: + description: >- + Path to your Stainless config. If omitted, and `merge_branch` is false, + will use the existing Stainless config on the Stainless branch. + required: false + commit_message: + description: >- + Commit message to use in the commits in the SDK repo. Use a commit + message in the conventional commits format: + https://www.conventionalcommits.org/en/v1.0.0/ + required: false + guess_config: + description: >- + If true, update the existing Stainless config file based on the OpenAPI + spec. Cannot be specified if `config_path` is specified. + required: false + default: false + branch: + description: Stainless branch to create the build on. + required: false + default: main + merge_branch: + description: >- + Stainless branch to merge changes from. The OpenAPI spec and Stainless + config from the `merge_branch` will be used to create a build on top of + the Stainless branch. + required: false + base_revision: + description: >- + A base revision to compare this build against. Must be a config commit + SHA. Cannot be specified if `merge_branch` is specified. + required: false + base_branch: + description: >- + Stainless branch to create the base build on. Must be specified if + `base_revision` is specified. + required: false + output_dir: + description: >- + Directory to write output files to. Defaults to the runner's temporary + directory. + required: false + default: ${{ runner.temp }} + +outputs: + outcomes: + description: >- + JSON-stringified object of build outcomes. Keys are languages, and values + contain the `commit` result of the build for that language. Will look + like: + + ``` + { + "typescript": { + "conclusion": "success", + "commit": { + "sha": "...", + ... + }, + }, + ... + } + ``` + base_outcomes: + description: >- + JSON-stringified object of base build outcomes. Present when + `base_revision` is specified. Keys are languages, and values contain the + `commit` result of the build for that language. Will look like: + + ``` + { + "typescript": { + "conclusion": "success", + "commit": { + "sha": "...", + ... + }, + }, + ... + } + ``` + documented_spec_path: + description: >- + Path to an OpenAPI spec with SDK code samples. Present when `output_dir` + is specified and `code_samples` is in your Stainless config. See + https://app.stainless.com/docs/reference/config#open-api-config for + more details. diff --git a/dist/build.js b/dist/build.js new file mode 100644 index 00000000..ec6c29d1 --- /dev/null +++ b/dist/build.js @@ -0,0 +1,21892 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// node_modules/@actions/core/lib/utils.js +var require_utils = __commonJS({ + "node_modules/@actions/core/lib/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.toCommandProperties = exports2.toCommandValue = void 0; + function toCommandValue(input) { + if (input === null || input === void 0) { + return ""; + } else if (typeof input === "string" || input instanceof String) { + return input; + } + return JSON.stringify(input); + } + exports2.toCommandValue = toCommandValue; + function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; + } + exports2.toCommandProperties = toCommandProperties; + } +}); + +// node_modules/@actions/core/lib/command.js +var require_command = __commonJS({ + "node_modules/@actions/core/lib/command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.issue = exports2.issueCommand = void 0; + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); + } + exports2.issueCommand = issueCommand; + function issue(name, message = "") { + issueCommand(name, {}, message); + } + exports2.issue = issue; + var CMD_STRING = "::"; + var Command = class { + constructor(command, properties, message) { + if (!command) { + command = "missing.command"; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += " "; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } else { + cmdStr += ","; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } + }; + function escapeData(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A"); + } + function escapeProperty(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C"); + } + } +}); + +// node_modules/@actions/core/lib/file-command.js +var require_file_command = __commonJS({ + "node_modules/@actions/core/lib/file-command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.prepareKeyValueMessage = exports2.issueFileCommand = void 0; + var crypto = __importStar(require("crypto")); + var fs2 = __importStar(require("fs")); + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs2.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs2.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { + encoding: "utf8" + }); + } + exports2.issueFileCommand = issueFileCommand; + function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${crypto.randomUUID()}`; + const convertedValue = (0, utils_1.toCommandValue)(value); + if (key.includes(delimiter)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + } + if (convertedValue.includes(delimiter)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + } + return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; + } + exports2.prepareKeyValueMessage = prepareKeyValueMessage; + } +}); + +// node_modules/@actions/http-client/lib/proxy.js +var require_proxy = __commonJS({ + "node_modules/@actions/http-client/lib/proxy.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.checkBypass = exports2.getProxyUrl = void 0; + function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === "https:"; + if (checkBypass(reqUrl)) { + return void 0; + } + const proxyVar = (() => { + if (usingSsl) { + return process.env["https_proxy"] || process.env["HTTPS_PROXY"]; + } else { + return process.env["http_proxy"] || process.env["HTTP_PROXY"]; + } + })(); + if (proxyVar) { + try { + return new DecodedURL(proxyVar); + } catch (_a2) { + if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) + return new DecodedURL(`http://${proxyVar}`); + } + } else { + return void 0; + } + } + exports2.getProxyUrl = getProxyUrl; + function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) { + return true; + } + const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || ""; + if (!noProxy) { + return false; + } + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } else if (reqUrl.protocol === "http:") { + reqPort = 80; + } else if (reqUrl.protocol === "https:") { + reqPort = 443; + } + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === "number") { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) { + if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) { + return true; + } + } + return false; + } + exports2.checkBypass = checkBypass; + function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]"); + } + var DecodedURL = class extends URL { + constructor(url, base) { + super(url, base); + this._decodedUsername = decodeURIComponent(super.username); + this._decodedPassword = decodeURIComponent(super.password); + } + get username() { + return this._decodedUsername; + } + get password() { + return this._decodedPassword; + } + }; + } +}); + +// node_modules/tunnel/lib/tunnel.js +var require_tunnel = __commonJS({ + "node_modules/tunnel/lib/tunnel.js"(exports2) { + "use strict"; + var net = require("net"); + var tls = require("tls"); + var http = require("http"); + var https = require("https"); + var events = require("events"); + var assert = require("assert"); + var util = require("util"); + exports2.httpOverHttp = httpOverHttp; + exports2.httpsOverHttp = httpsOverHttp; + exports2.httpOverHttps = httpOverHttps; + exports2.httpsOverHttps = httpsOverHttps; + function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; + } + function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; + } + function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + self.on("free", function onFree(socket, host, port, localAddress) { + var options2 = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options2.host && pending.port === options2.port) { + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); + } + util.inherits(TunnelingAgent, events.EventEmitter); + TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({ request: req }, self.options, toOptions(host, port, localAddress)); + if (self.sockets.length >= this.maxSockets) { + self.requests.push(options); + return; + } + self.createSocket(options, function(socket) { + socket.on("free", onFree); + socket.on("close", onCloseOrRemove); + socket.on("agentRemove", onCloseOrRemove); + req.onSocket(socket); + function onFree() { + self.emit("free", socket, options); + } + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener("free", onFree); + socket.removeListener("close", onCloseOrRemove); + socket.removeListener("agentRemove", onCloseOrRemove); + } + }); + }; + TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: "CONNECT", + path: options.host + ":" + options.port, + agent: false, + headers: { + host: options.host + ":" + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64"); + } + debug("making CONNECT request"); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; + connectReq.once("response", onResponse); + connectReq.once("upgrade", onUpgrade); + connectReq.once("connect", onConnect); + connectReq.once("error", onError); + connectReq.end(); + function onResponse(res) { + res.upgrade = true; + } + function onUpgrade(res, socket, head) { + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + if (res.statusCode !== 200) { + debug( + "tunneling socket could not be established, statusCode=%d", + res.statusCode + ); + socket.destroy(); + var error = new Error("tunneling socket could not be established, statusCode=" + res.statusCode); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug("got illegal response body from proxy"); + socket.destroy(); + var error = new Error("got illegal response body from proxy"); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self.removeSocket(placeholder); + return; + } + debug("tunneling connection has established"); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + function onError(cause) { + connectReq.removeAllListeners(); + debug( + "tunneling socket could not be established, cause=%s\n", + cause.message, + cause.stack + ); + var error = new Error("tunneling socket could not be established, cause=" + cause.message); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self.removeSocket(placeholder); + } + }; + TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket); + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + var pending = this.requests.shift(); + if (pending) { + this.createSocket(pending, function(socket2) { + pending.request.onSocket(socket2); + }); + } + }; + function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader("host"); + var tlsOptions = mergeOptions({}, self.options, { + socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host + }); + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); + } + function toOptions(host, port, localAddress) { + if (typeof host === "string") { + return { + host, + port, + localAddress + }; + } + return host; + } + function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === "object") { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== void 0) { + target[k] = overrides[k]; + } + } + } + } + return target; + } + var debug; + if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === "string") { + args[0] = "TUNNEL: " + args[0]; + } else { + args.unshift("TUNNEL:"); + } + console.error.apply(console, args); + }; + } else { + debug = function() { + }; + } + exports2.debug = debug; + } +}); + +// node_modules/tunnel/index.js +var require_tunnel2 = __commonJS({ + "node_modules/tunnel/index.js"(exports2, module2) { + module2.exports = require_tunnel(); + } +}); + +// node_modules/undici/lib/core/symbols.js +var require_symbols = __commonJS({ + "node_modules/undici/lib/core/symbols.js"(exports2, module2) { + module2.exports = { + kClose: Symbol("close"), + kDestroy: Symbol("destroy"), + kDispatch: Symbol("dispatch"), + kUrl: Symbol("url"), + kWriting: Symbol("writing"), + kResuming: Symbol("resuming"), + kQueue: Symbol("queue"), + kConnect: Symbol("connect"), + kConnecting: Symbol("connecting"), + kHeadersList: Symbol("headers list"), + kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"), + kKeepAliveMaxTimeout: Symbol("max keep alive timeout"), + kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"), + kKeepAliveTimeoutValue: Symbol("keep alive timeout"), + kKeepAlive: Symbol("keep alive"), + kHeadersTimeout: Symbol("headers timeout"), + kBodyTimeout: Symbol("body timeout"), + kServerName: Symbol("server name"), + kLocalAddress: Symbol("local address"), + kHost: Symbol("host"), + kNoRef: Symbol("no ref"), + kBodyUsed: Symbol("used"), + kRunning: Symbol("running"), + kBlocking: Symbol("blocking"), + kPending: Symbol("pending"), + kSize: Symbol("size"), + kBusy: Symbol("busy"), + kQueued: Symbol("queued"), + kFree: Symbol("free"), + kConnected: Symbol("connected"), + kClosed: Symbol("closed"), + kNeedDrain: Symbol("need drain"), + kReset: Symbol("reset"), + kDestroyed: Symbol.for("nodejs.stream.destroyed"), + kMaxHeadersSize: Symbol("max headers size"), + kRunningIdx: Symbol("running index"), + kPendingIdx: Symbol("pending index"), + kError: Symbol("error"), + kClients: Symbol("clients"), + kClient: Symbol("client"), + kParser: Symbol("parser"), + kOnDestroyed: Symbol("destroy callbacks"), + kPipelining: Symbol("pipelining"), + kSocket: Symbol("socket"), + kHostHeader: Symbol("host header"), + kConnector: Symbol("connector"), + kStrictContentLength: Symbol("strict content length"), + kMaxRedirections: Symbol("maxRedirections"), + kMaxRequests: Symbol("maxRequestsPerClient"), + kProxy: Symbol("proxy agent options"), + kCounter: Symbol("socket request counter"), + kInterceptors: Symbol("dispatch interceptors"), + kMaxResponseSize: Symbol("max response size"), + kHTTP2Session: Symbol("http2Session"), + kHTTP2SessionState: Symbol("http2Session state"), + kHTTP2BuildRequest: Symbol("http2 build request"), + kHTTP1BuildRequest: Symbol("http1 build request"), + kHTTP2CopyHeaders: Symbol("http2 copy headers"), + kHTTPConnVersion: Symbol("http connection version"), + kRetryHandlerDefaultRetry: Symbol("retry agent default retry"), + kConstruct: Symbol("constructable") + }; + } +}); + +// node_modules/undici/lib/core/errors.js +var require_errors = __commonJS({ + "node_modules/undici/lib/core/errors.js"(exports2, module2) { + "use strict"; + var UndiciError = class extends Error { + constructor(message) { + super(message); + this.name = "UndiciError"; + this.code = "UND_ERR"; + } + }; + var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ConnectTimeoutError); + this.name = "ConnectTimeoutError"; + this.message = message || "Connect Timeout Error"; + this.code = "UND_ERR_CONNECT_TIMEOUT"; + } + }; + var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersTimeoutError); + this.name = "HeadersTimeoutError"; + this.message = message || "Headers Timeout Error"; + this.code = "UND_ERR_HEADERS_TIMEOUT"; + } + }; + var HeadersOverflowError = class _HeadersOverflowError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersOverflowError); + this.name = "HeadersOverflowError"; + this.message = message || "Headers Overflow Error"; + this.code = "UND_ERR_HEADERS_OVERFLOW"; + } + }; + var BodyTimeoutError = class _BodyTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _BodyTimeoutError); + this.name = "BodyTimeoutError"; + this.message = message || "Body Timeout Error"; + this.code = "UND_ERR_BODY_TIMEOUT"; + } + }; + var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError { + constructor(message, statusCode, headers, body) { + super(message); + Error.captureStackTrace(this, _ResponseStatusCodeError); + this.name = "ResponseStatusCodeError"; + this.message = message || "Response Status Code Error"; + this.code = "UND_ERR_RESPONSE_STATUS_CODE"; + this.body = body; + this.status = statusCode; + this.statusCode = statusCode; + this.headers = headers; + } + }; + var InvalidArgumentError = class _InvalidArgumentError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidArgumentError); + this.name = "InvalidArgumentError"; + this.message = message || "Invalid Argument Error"; + this.code = "UND_ERR_INVALID_ARG"; + } + }; + var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidReturnValueError); + this.name = "InvalidReturnValueError"; + this.message = message || "Invalid Return Value Error"; + this.code = "UND_ERR_INVALID_RETURN_VALUE"; + } + }; + var RequestAbortedError = class _RequestAbortedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestAbortedError); + this.name = "AbortError"; + this.message = message || "Request aborted"; + this.code = "UND_ERR_ABORTED"; + } + }; + var InformationalError = class _InformationalError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InformationalError); + this.name = "InformationalError"; + this.message = message || "Request information"; + this.code = "UND_ERR_INFO"; + } + }; + var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestContentLengthMismatchError); + this.name = "RequestContentLengthMismatchError"; + this.message = message || "Request body length does not match content-length header"; + this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"; + } + }; + var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseContentLengthMismatchError); + this.name = "ResponseContentLengthMismatchError"; + this.message = message || "Response body length does not match content-length header"; + this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"; + } + }; + var ClientDestroyedError = class _ClientDestroyedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientDestroyedError); + this.name = "ClientDestroyedError"; + this.message = message || "The client is destroyed"; + this.code = "UND_ERR_DESTROYED"; + } + }; + var ClientClosedError = class _ClientClosedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientClosedError); + this.name = "ClientClosedError"; + this.message = message || "The client is closed"; + this.code = "UND_ERR_CLOSED"; + } + }; + var SocketError = class _SocketError extends UndiciError { + constructor(message, socket) { + super(message); + Error.captureStackTrace(this, _SocketError); + this.name = "SocketError"; + this.message = message || "Socket error"; + this.code = "UND_ERR_SOCKET"; + this.socket = socket; + } + }; + var NotSupportedError = class _NotSupportedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _NotSupportedError); + this.name = "NotSupportedError"; + this.message = message || "Not supported error"; + this.code = "UND_ERR_NOT_SUPPORTED"; + } + }; + var BalancedPoolMissingUpstreamError = class extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, NotSupportedError); + this.name = "MissingUpstreamError"; + this.message = message || "No upstream has been added to the BalancedPool"; + this.code = "UND_ERR_BPL_MISSING_UPSTREAM"; + } + }; + var HTTPParserError = class _HTTPParserError extends Error { + constructor(message, code, data) { + super(message); + Error.captureStackTrace(this, _HTTPParserError); + this.name = "HTTPParserError"; + this.code = code ? `HPE_${code}` : void 0; + this.data = data ? data.toString() : void 0; + } + }; + var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseExceededMaxSizeError); + this.name = "ResponseExceededMaxSizeError"; + this.message = message || "Response content exceeded max size"; + this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE"; + } + }; + var RequestRetryError = class _RequestRetryError extends UndiciError { + constructor(message, code, { headers, data }) { + super(message); + Error.captureStackTrace(this, _RequestRetryError); + this.name = "RequestRetryError"; + this.message = message || "Request retry error"; + this.code = "UND_ERR_REQ_RETRY"; + this.statusCode = code; + this.data = data; + this.headers = headers; + } + }; + module2.exports = { + HTTPParserError, + UndiciError, + HeadersTimeoutError, + HeadersOverflowError, + BodyTimeoutError, + RequestContentLengthMismatchError, + ConnectTimeoutError, + ResponseStatusCodeError, + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError, + ClientDestroyedError, + ClientClosedError, + InformationalError, + SocketError, + NotSupportedError, + ResponseContentLengthMismatchError, + BalancedPoolMissingUpstreamError, + ResponseExceededMaxSizeError, + RequestRetryError + }; + } +}); + +// node_modules/undici/lib/core/constants.js +var require_constants = __commonJS({ + "node_modules/undici/lib/core/constants.js"(exports2, module2) { + "use strict"; + var headerNameLowerCasedRecord = {}; + var wellknownHeaderNames = [ + "Accept", + "Accept-Encoding", + "Accept-Language", + "Accept-Ranges", + "Access-Control-Allow-Credentials", + "Access-Control-Allow-Headers", + "Access-Control-Allow-Methods", + "Access-Control-Allow-Origin", + "Access-Control-Expose-Headers", + "Access-Control-Max-Age", + "Access-Control-Request-Headers", + "Access-Control-Request-Method", + "Age", + "Allow", + "Alt-Svc", + "Alt-Used", + "Authorization", + "Cache-Control", + "Clear-Site-Data", + "Connection", + "Content-Disposition", + "Content-Encoding", + "Content-Language", + "Content-Length", + "Content-Location", + "Content-Range", + "Content-Security-Policy", + "Content-Security-Policy-Report-Only", + "Content-Type", + "Cookie", + "Cross-Origin-Embedder-Policy", + "Cross-Origin-Opener-Policy", + "Cross-Origin-Resource-Policy", + "Date", + "Device-Memory", + "Downlink", + "ECT", + "ETag", + "Expect", + "Expect-CT", + "Expires", + "Forwarded", + "From", + "Host", + "If-Match", + "If-Modified-Since", + "If-None-Match", + "If-Range", + "If-Unmodified-Since", + "Keep-Alive", + "Last-Modified", + "Link", + "Location", + "Max-Forwards", + "Origin", + "Permissions-Policy", + "Pragma", + "Proxy-Authenticate", + "Proxy-Authorization", + "RTT", + "Range", + "Referer", + "Referrer-Policy", + "Refresh", + "Retry-After", + "Sec-WebSocket-Accept", + "Sec-WebSocket-Extensions", + "Sec-WebSocket-Key", + "Sec-WebSocket-Protocol", + "Sec-WebSocket-Version", + "Server", + "Server-Timing", + "Service-Worker-Allowed", + "Service-Worker-Navigation-Preload", + "Set-Cookie", + "SourceMap", + "Strict-Transport-Security", + "Supports-Loading-Mode", + "TE", + "Timing-Allow-Origin", + "Trailer", + "Transfer-Encoding", + "Upgrade", + "Upgrade-Insecure-Requests", + "User-Agent", + "Vary", + "Via", + "WWW-Authenticate", + "X-Content-Type-Options", + "X-DNS-Prefetch-Control", + "X-Frame-Options", + "X-Permitted-Cross-Domain-Policies", + "X-Powered-By", + "X-Requested-With", + "X-XSS-Protection" + ]; + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = wellknownHeaderNames[i]; + const lowerCasedKey = key.toLowerCase(); + headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey; + } + Object.setPrototypeOf(headerNameLowerCasedRecord, null); + module2.exports = { + wellknownHeaderNames, + headerNameLowerCasedRecord + }; + } +}); + +// node_modules/undici/lib/core/util.js +var require_util = __commonJS({ + "node_modules/undici/lib/core/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { kDestroyed, kBodyUsed } = require_symbols(); + var { IncomingMessage } = require("http"); + var stream = require("stream"); + var net = require("net"); + var { InvalidArgumentError } = require_errors(); + var { Blob: Blob2 } = require("buffer"); + var nodeUtil = require("util"); + var { stringify: stringify2 } = require("querystring"); + var { headerNameLowerCasedRecord } = require_constants(); + var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v)); + function nop() { + } + function isStream(obj) { + return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; + } + function isBlobLike2(object) { + return Blob2 && object instanceof Blob2 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]); + } + function buildURL(url, queryParams) { + if (url.includes("?") || url.includes("#")) { + throw new Error('Query params cannot be passed when url already contains "?" or "#".'); + } + const stringified = stringify2(queryParams); + if (stringified) { + url += "?" + stringified; + } + return url; + } + function parseURL(url) { + if (typeof url === "string") { + url = new URL(url); + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + return url; + } + if (!url || typeof url !== "object") { + throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object."); + } + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + if (!(url instanceof URL)) { + if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) { + throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer."); + } + if (url.path != null && typeof url.path !== "string") { + throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined."); + } + if (url.pathname != null && typeof url.pathname !== "string") { + throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined."); + } + if (url.hostname != null && typeof url.hostname !== "string") { + throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined."); + } + if (url.origin != null && typeof url.origin !== "string") { + throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined."); + } + const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; + let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`; + let path2 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; + if (origin.endsWith("/")) { + origin = origin.substring(0, origin.length - 1); + } + if (path2 && !path2.startsWith("/")) { + path2 = `/${path2}`; + } + url = new URL(origin + path2); + } + return url; + } + function parseOrigin(url) { + url = parseURL(url); + if (url.pathname !== "/" || url.search || url.hash) { + throw new InvalidArgumentError("invalid url"); + } + return url; + } + function getHostname(host) { + if (host[0] === "[") { + const idx2 = host.indexOf("]"); + assert(idx2 !== -1); + return host.substring(1, idx2); + } + const idx = host.indexOf(":"); + if (idx === -1) return host; + return host.substring(0, idx); + } + function getServerName(host) { + if (!host) { + return null; + } + assert.strictEqual(typeof host, "string"); + const servername = getHostname(host); + if (net.isIP(servername)) { + return ""; + } + return servername; + } + function deepClone(obj) { + return JSON.parse(JSON.stringify(obj)); + } + function isAsyncIterable2(obj) { + return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function"); + } + function isIterable(obj) { + return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function")); + } + function bodyLength(body) { + if (body == null) { + return 0; + } else if (isStream(body)) { + const state = body._readableState; + return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; + } else if (isBlobLike2(body)) { + return body.size != null ? body.size : null; + } else if (isBuffer(body)) { + return body.byteLength; + } + return null; + } + function isDestroyed(stream2) { + return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]); + } + function isReadableAborted(stream2) { + const state = stream2 && stream2._readableState; + return isDestroyed(stream2) && state && !state.endEmitted; + } + function destroy(stream2, err) { + if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) { + return; + } + if (typeof stream2.destroy === "function") { + if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) { + stream2.socket = null; + } + stream2.destroy(err); + } else if (err) { + process.nextTick((stream3, err2) => { + stream3.emit("error", err2); + }, stream2, err); + } + if (stream2.destroyed !== true) { + stream2[kDestroyed] = true; + } + } + var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/; + function parseKeepAliveTimeout(val) { + const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR); + return m ? parseInt(m[1], 10) * 1e3 : null; + } + function headerNameToString(value) { + return headerNameLowerCasedRecord[value] || value.toLowerCase(); + } + function parseHeaders(headers, obj = {}) { + if (!Array.isArray(headers)) return headers; + for (let i = 0; i < headers.length; i += 2) { + const key = headers[i].toString().toLowerCase(); + let val = obj[key]; + if (!val) { + if (Array.isArray(headers[i + 1])) { + obj[key] = headers[i + 1].map((x) => x.toString("utf8")); + } else { + obj[key] = headers[i + 1].toString("utf8"); + } + } else { + if (!Array.isArray(val)) { + val = [val]; + obj[key] = val; + } + val.push(headers[i + 1].toString("utf8")); + } + } + if ("content-length" in obj && "content-disposition" in obj) { + obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1"); + } + return obj; + } + function parseRawHeaders(headers) { + const ret = []; + let hasContentLength = false; + let contentDispositionIdx = -1; + for (let n = 0; n < headers.length; n += 2) { + const key = headers[n + 0].toString(); + const val = headers[n + 1].toString("utf8"); + if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) { + ret.push(key, val); + hasContentLength = true; + } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) { + contentDispositionIdx = ret.push(key, val) - 1; + } else { + ret.push(key, val); + } + } + if (hasContentLength && contentDispositionIdx !== -1) { + ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1"); + } + return ret; + } + function isBuffer(buffer) { + return buffer instanceof Uint8Array || Buffer.isBuffer(buffer); + } + function validateHandler(handler, method, upgrade) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + if (typeof handler.onConnect !== "function") { + throw new InvalidArgumentError("invalid onConnect method"); + } + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) { + throw new InvalidArgumentError("invalid onBodySent method"); + } + if (upgrade || method === "CONNECT") { + if (typeof handler.onUpgrade !== "function") { + throw new InvalidArgumentError("invalid onUpgrade method"); + } + } else { + if (typeof handler.onHeaders !== "function") { + throw new InvalidArgumentError("invalid onHeaders method"); + } + if (typeof handler.onData !== "function") { + throw new InvalidArgumentError("invalid onData method"); + } + if (typeof handler.onComplete !== "function") { + throw new InvalidArgumentError("invalid onComplete method"); + } + } + } + function isDisturbed(body) { + return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body))); + } + function isErrored(body) { + return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test( + nodeUtil.inspect(body) + ))); + } + function isReadable(body) { + return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test( + nodeUtil.inspect(body) + ))); + } + function getSocketInfo(socket) { + return { + localAddress: socket.localAddress, + localPort: socket.localPort, + remoteAddress: socket.remoteAddress, + remotePort: socket.remotePort, + remoteFamily: socket.remoteFamily, + timeout: socket.timeout, + bytesWritten: socket.bytesWritten, + bytesRead: socket.bytesRead + }; + } + async function* convertIterableToBuffer(iterable) { + for await (const chunk of iterable) { + yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk); + } + } + var ReadableStream; + function ReadableStreamFrom2(iterable) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (ReadableStream.from) { + return ReadableStream.from(convertIterableToBuffer(iterable)); + } + let iterator; + return new ReadableStream( + { + async start() { + iterator = iterable[Symbol.asyncIterator](); + }, + async pull(controller) { + const { done, value } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + const buf = Buffer.isBuffer(value) ? value : Buffer.from(value); + controller.enqueue(new Uint8Array(buf)); + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + } + }, + 0 + ); + } + function isFormDataLike(object) { + return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData"; + } + function throwIfAborted(signal) { + if (!signal) { + return; + } + if (typeof signal.throwIfAborted === "function") { + signal.throwIfAborted(); + } else { + if (signal.aborted) { + const err = new Error("The operation was aborted"); + err.name = "AbortError"; + throw err; + } + } + } + function addAbortListener(signal, listener) { + if ("addEventListener" in signal) { + signal.addEventListener("abort", listener, { once: true }); + return () => signal.removeEventListener("abort", listener); + } + signal.addListener("abort", listener); + return () => signal.removeListener("abort", listener); + } + var hasToWellFormed = !!String.prototype.toWellFormed; + function toUSVString(val) { + if (hasToWellFormed) { + return `${val}`.toWellFormed(); + } else if (nodeUtil.toUSVString) { + return nodeUtil.toUSVString(val); + } + return `${val}`; + } + function parseRangeHeader(range) { + if (range == null || range === "") return { start: 0, end: null, size: null }; + const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null; + return m ? { + start: parseInt(m[1]), + end: m[2] ? parseInt(m[2]) : null, + size: m[3] ? parseInt(m[3]) : null + } : null; + } + var kEnumerableProperty = /* @__PURE__ */ Object.create(null); + kEnumerableProperty.enumerable = true; + module2.exports = { + kEnumerableProperty, + nop, + isDisturbed, + isErrored, + isReadable, + toUSVString, + isReadableAborted, + isBlobLike: isBlobLike2, + parseOrigin, + parseURL, + getServerName, + isStream, + isIterable, + isAsyncIterable: isAsyncIterable2, + isDestroyed, + headerNameToString, + parseRawHeaders, + parseHeaders, + parseKeepAliveTimeout, + destroy, + bodyLength, + deepClone, + ReadableStreamFrom: ReadableStreamFrom2, + isBuffer, + validateHandler, + getSocketInfo, + isFormDataLike, + buildURL, + throwIfAborted, + addAbortListener, + parseRangeHeader, + nodeMajor, + nodeMinor, + nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13, + safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"] + }; + } +}); + +// node_modules/undici/lib/timers.js +var require_timers = __commonJS({ + "node_modules/undici/lib/timers.js"(exports2, module2) { + "use strict"; + var fastNow = Date.now(); + var fastNowTimeout; + var fastTimers = []; + function onTimeout() { + fastNow = Date.now(); + let len = fastTimers.length; + let idx = 0; + while (idx < len) { + const timer = fastTimers[idx]; + if (timer.state === 0) { + timer.state = fastNow + timer.delay; + } else if (timer.state > 0 && fastNow >= timer.state) { + timer.state = -1; + timer.callback(timer.opaque); + } + if (timer.state === -1) { + timer.state = -2; + if (idx !== len - 1) { + fastTimers[idx] = fastTimers.pop(); + } else { + fastTimers.pop(); + } + len -= 1; + } else { + idx += 1; + } + } + if (fastTimers.length > 0) { + refreshTimeout(); + } + } + function refreshTimeout() { + if (fastNowTimeout && fastNowTimeout.refresh) { + fastNowTimeout.refresh(); + } else { + clearTimeout(fastNowTimeout); + fastNowTimeout = setTimeout(onTimeout, 1e3); + if (fastNowTimeout.unref) { + fastNowTimeout.unref(); + } + } + } + var Timeout = class { + constructor(callback, delay, opaque) { + this.callback = callback; + this.delay = delay; + this.opaque = opaque; + this.state = -2; + this.refresh(); + } + refresh() { + if (this.state === -2) { + fastTimers.push(this); + if (!fastNowTimeout || fastTimers.length === 1) { + refreshTimeout(); + } + } + this.state = 0; + } + clear() { + this.state = -1; + } + }; + module2.exports = { + setTimeout(callback, delay, opaque) { + return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque); + }, + clearTimeout(timeout) { + if (timeout instanceof Timeout) { + timeout.clear(); + } else { + clearTimeout(timeout); + } + } + }; + } +}); + +// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js +var require_sbmh = __commonJS({ + "node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + function SBMH(needle) { + if (typeof needle === "string") { + needle = Buffer.from(needle); + } + if (!Buffer.isBuffer(needle)) { + throw new TypeError("The needle has to be a String or a Buffer."); + } + const needleLength = needle.length; + if (needleLength === 0) { + throw new Error("The needle cannot be an empty String/Buffer."); + } + if (needleLength > 256) { + throw new Error("The needle cannot have a length bigger than 256."); + } + this.maxMatches = Infinity; + this.matches = 0; + this._occ = new Array(256).fill(needleLength); + this._lookbehind_size = 0; + this._needle = needle; + this._bufpos = 0; + this._lookbehind = Buffer.alloc(needleLength); + for (var i = 0; i < needleLength - 1; ++i) { + this._occ[needle[i]] = needleLength - 1 - i; + } + } + inherits(SBMH, EventEmitter); + SBMH.prototype.reset = function() { + this._lookbehind_size = 0; + this.matches = 0; + this._bufpos = 0; + }; + SBMH.prototype.push = function(chunk, pos) { + if (!Buffer.isBuffer(chunk)) { + chunk = Buffer.from(chunk, "binary"); + } + const chlen = chunk.length; + this._bufpos = pos || 0; + let r; + while (r !== chlen && this.matches < this.maxMatches) { + r = this._sbmh_feed(chunk); + } + return r; + }; + SBMH.prototype._sbmh_feed = function(data) { + const len = data.length; + const needle = this._needle; + const needleLength = needle.length; + const lastNeedleChar = needle[needleLength - 1]; + let pos = -this._lookbehind_size; + let ch; + if (pos < 0) { + while (pos < 0 && pos <= len - needleLength) { + ch = this._sbmh_lookup_char(data, pos + needleLength - 1); + if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) { + this._lookbehind_size = 0; + ++this.matches; + this.emit("info", true); + return this._bufpos = pos + needleLength; + } + pos += this._occ[ch]; + } + if (pos < 0) { + while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { + ++pos; + } + } + if (pos >= 0) { + this.emit("info", false, this._lookbehind, 0, this._lookbehind_size); + this._lookbehind_size = 0; + } else { + const bytesToCutOff = this._lookbehind_size + pos; + if (bytesToCutOff > 0) { + this.emit("info", false, this._lookbehind, 0, bytesToCutOff); + } + this._lookbehind.copy( + this._lookbehind, + 0, + bytesToCutOff, + this._lookbehind_size - bytesToCutOff + ); + this._lookbehind_size -= bytesToCutOff; + data.copy(this._lookbehind, this._lookbehind_size); + this._lookbehind_size += len; + this._bufpos = len; + return len; + } + } + pos += (pos >= 0) * this._bufpos; + if (data.indexOf(needle, pos) !== -1) { + pos = data.indexOf(needle, pos); + ++this.matches; + if (pos > 0) { + this.emit("info", true, data, this._bufpos, pos); + } else { + this.emit("info", true); + } + return this._bufpos = pos + needleLength; + } else { + pos = len - needleLength; + } + while (pos < len && (data[pos] !== needle[0] || Buffer.compare( + data.subarray(pos, pos + len - pos), + needle.subarray(0, len - pos) + ) !== 0)) { + ++pos; + } + if (pos < len) { + data.copy(this._lookbehind, 0, pos, pos + (len - pos)); + this._lookbehind_size = len - pos; + } + if (pos > 0) { + this.emit("info", false, data, this._bufpos, pos < len ? pos : len); + } + this._bufpos = len; + return len; + }; + SBMH.prototype._sbmh_lookup_char = function(data, pos) { + return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos]; + }; + SBMH.prototype._sbmh_memcmp = function(data, pos, len) { + for (var i = 0; i < len; ++i) { + if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { + return false; + } + } + return true; + }; + module2.exports = SBMH; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js +var require_PartStream = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) { + "use strict"; + var inherits = require("node:util").inherits; + var ReadableStream = require("node:stream").Readable; + function PartStream(opts) { + ReadableStream.call(this, opts); + } + inherits(PartStream, ReadableStream); + PartStream.prototype._read = function(n) { + }; + module2.exports = PartStream; + } +}); + +// node_modules/@fastify/busboy/lib/utils/getLimit.js +var require_getLimit = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) { + "use strict"; + module2.exports = function getLimit(limits, name, defaultLimit) { + if (!limits || limits[name] === void 0 || limits[name] === null) { + return defaultLimit; + } + if (typeof limits[name] !== "number" || isNaN(limits[name])) { + throw new TypeError("Limit " + name + " is not a valid number"); + } + return limits[name]; + }; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js +var require_HeaderParser = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + var getLimit = require_getLimit(); + var StreamSearch = require_sbmh(); + var B_DCRLF = Buffer.from("\r\n\r\n"); + var RE_CRLF = /\r\n/g; + var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/; + function HeaderParser(cfg) { + EventEmitter.call(this); + cfg = cfg || {}; + const self = this; + this.nread = 0; + this.maxed = false; + this.npairs = 0; + this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3); + this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024); + this.buffer = ""; + this.header = {}; + this.finished = false; + this.ss = new StreamSearch(B_DCRLF); + this.ss.on("info", function(isMatch, data, start, end) { + if (data && !self.maxed) { + if (self.nread + end - start >= self.maxHeaderSize) { + end = self.maxHeaderSize - self.nread + start; + self.nread = self.maxHeaderSize; + self.maxed = true; + } else { + self.nread += end - start; + } + self.buffer += data.toString("binary", start, end); + } + if (isMatch) { + self._finish(); + } + }); + } + inherits(HeaderParser, EventEmitter); + HeaderParser.prototype.push = function(data) { + const r = this.ss.push(data); + if (this.finished) { + return r; + } + }; + HeaderParser.prototype.reset = function() { + this.finished = false; + this.buffer = ""; + this.header = {}; + this.ss.reset(); + }; + HeaderParser.prototype._finish = function() { + if (this.buffer) { + this._parseHeader(); + } + this.ss.matches = this.ss.maxMatches; + const header = this.header; + this.header = {}; + this.buffer = ""; + this.finished = true; + this.nread = this.npairs = 0; + this.maxed = false; + this.emit("header", header); + }; + HeaderParser.prototype._parseHeader = function() { + if (this.npairs === this.maxHeaderPairs) { + return; + } + const lines = this.buffer.split(RE_CRLF); + const len = lines.length; + let m, h; + for (var i = 0; i < len; ++i) { + if (lines[i].length === 0) { + continue; + } + if (lines[i][0] === " " || lines[i][0] === " ") { + if (h) { + this.header[h][this.header[h].length - 1] += lines[i]; + continue; + } + } + const posColon = lines[i].indexOf(":"); + if (posColon === -1 || posColon === 0) { + return; + } + m = RE_HDR.exec(lines[i]); + h = m[1].toLowerCase(); + this.header[h] = this.header[h] || []; + this.header[h].push(m[2] || ""); + if (++this.npairs === this.maxHeaderPairs) { + break; + } + } + }; + module2.exports = HeaderParser; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js +var require_Dicer = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var inherits = require("node:util").inherits; + var StreamSearch = require_sbmh(); + var PartStream = require_PartStream(); + var HeaderParser = require_HeaderParser(); + var DASH = 45; + var B_ONEDASH = Buffer.from("-"); + var B_CRLF = Buffer.from("\r\n"); + var EMPTY_FN = function() { + }; + function Dicer(cfg) { + if (!(this instanceof Dicer)) { + return new Dicer(cfg); + } + WritableStream.call(this, cfg); + if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") { + throw new TypeError("Boundary required"); + } + if (typeof cfg.boundary === "string") { + this.setBoundary(cfg.boundary); + } else { + this._bparser = void 0; + } + this._headerFirst = cfg.headerFirst; + this._dashes = 0; + this._parts = 0; + this._finished = false; + this._realFinish = false; + this._isPreamble = true; + this._justMatched = false; + this._firstWrite = true; + this._inHeader = true; + this._part = void 0; + this._cb = void 0; + this._ignoreData = false; + this._partOpts = { highWaterMark: cfg.partHwm }; + this._pause = false; + const self = this; + this._hparser = new HeaderParser(cfg); + this._hparser.on("header", function(header) { + self._inHeader = false; + self._part.emit("header", header); + }); + } + inherits(Dicer, WritableStream); + Dicer.prototype.emit = function(ev) { + if (ev === "finish" && !this._realFinish) { + if (!this._finished) { + const self = this; + process.nextTick(function() { + self.emit("error", new Error("Unexpected end of multipart data")); + if (self._part && !self._ignoreData) { + const type = self._isPreamble ? "Preamble" : "Part"; + self._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data")); + self._part.push(null); + process.nextTick(function() { + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + }); + return; + } + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + }); + } + } else { + WritableStream.prototype.emit.apply(this, arguments); + } + }; + Dicer.prototype._write = function(data, encoding, cb) { + if (!this._hparser && !this._bparser) { + return cb(); + } + if (this._headerFirst && this._isPreamble) { + if (!this._part) { + this._part = new PartStream(this._partOpts); + if (this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else { + this._ignore(); + } + } + const r = this._hparser.push(data); + if (!this._inHeader && r !== void 0 && r < data.length) { + data = data.slice(r); + } else { + return cb(); + } + } + if (this._firstWrite) { + this._bparser.push(B_CRLF); + this._firstWrite = false; + } + this._bparser.push(data); + if (this._pause) { + this._cb = cb; + } else { + cb(); + } + }; + Dicer.prototype.reset = function() { + this._part = void 0; + this._bparser = void 0; + this._hparser = void 0; + }; + Dicer.prototype.setBoundary = function(boundary) { + const self = this; + this._bparser = new StreamSearch("\r\n--" + boundary); + this._bparser.on("info", function(isMatch, data, start, end) { + self._oninfo(isMatch, data, start, end); + }); + }; + Dicer.prototype._ignore = function() { + if (this._part && !this._ignoreData) { + this._ignoreData = true; + this._part.on("error", EMPTY_FN); + this._part.resume(); + } + }; + Dicer.prototype._oninfo = function(isMatch, data, start, end) { + let buf; + const self = this; + let i = 0; + let r; + let shouldWriteMore = true; + if (!this._part && this._justMatched && data) { + while (this._dashes < 2 && start + i < end) { + if (data[start + i] === DASH) { + ++i; + ++this._dashes; + } else { + if (this._dashes) { + buf = B_ONEDASH; + } + this._dashes = 0; + break; + } + } + if (this._dashes === 2) { + if (start + i < end && this.listenerCount("trailer") !== 0) { + this.emit("trailer", data.slice(start + i, end)); + } + this.reset(); + this._finished = true; + if (self._parts === 0) { + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + } + } + if (this._dashes) { + return; + } + } + if (this._justMatched) { + this._justMatched = false; + } + if (!this._part) { + this._part = new PartStream(this._partOpts); + this._part._read = function(n) { + self._unpause(); + }; + if (this._isPreamble && this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else if (this._isPreamble !== true && this.listenerCount("part") !== 0) { + this.emit("part", this._part); + } else { + this._ignore(); + } + if (!this._isPreamble) { + this._inHeader = true; + } + } + if (data && start < end && !this._ignoreData) { + if (this._isPreamble || !this._inHeader) { + if (buf) { + shouldWriteMore = this._part.push(buf); + } + shouldWriteMore = this._part.push(data.slice(start, end)); + if (!shouldWriteMore) { + this._pause = true; + } + } else if (!this._isPreamble && this._inHeader) { + if (buf) { + this._hparser.push(buf); + } + r = this._hparser.push(data.slice(start, end)); + if (!this._inHeader && r !== void 0 && r < end) { + this._oninfo(false, data, start + r, end); + } + } + } + if (isMatch) { + this._hparser.reset(); + if (this._isPreamble) { + this._isPreamble = false; + } else { + if (start !== end) { + ++this._parts; + this._part.on("end", function() { + if (--self._parts === 0) { + if (self._finished) { + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + } else { + self._unpause(); + } + } + }); + } + } + this._part.push(null); + this._part = void 0; + this._ignoreData = false; + this._justMatched = true; + this._dashes = 0; + } + }; + Dicer.prototype._unpause = function() { + if (!this._pause) { + return; + } + this._pause = false; + if (this._cb) { + const cb = this._cb; + this._cb = void 0; + cb(); + } + }; + module2.exports = Dicer; + } +}); + +// node_modules/@fastify/busboy/lib/utils/decodeText.js +var require_decodeText = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) { + "use strict"; + var utf8Decoder = new TextDecoder("utf-8"); + var textDecoders = /* @__PURE__ */ new Map([ + ["utf-8", utf8Decoder], + ["utf8", utf8Decoder] + ]); + function getDecoder(charset) { + let lc; + while (true) { + switch (charset) { + case "utf-8": + case "utf8": + return decoders.utf8; + case "latin1": + case "ascii": + // TODO: Make these a separate, strict decoder? + case "us-ascii": + case "iso-8859-1": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "windows-1252": + case "iso_8859-1:1987": + case "cp1252": + case "x-cp1252": + return decoders.latin1; + case "utf16le": + case "utf-16le": + case "ucs2": + case "ucs-2": + return decoders.utf16le; + case "base64": + return decoders.base64; + default: + if (lc === void 0) { + lc = true; + charset = charset.toLowerCase(); + continue; + } + return decoders.other.bind(charset); + } + } + } + var decoders = { + utf8: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.utf8Slice(0, data.length); + }, + latin1: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + return data; + } + return data.latin1Slice(0, data.length); + }, + utf16le: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.ucs2Slice(0, data.length); + }, + base64: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.base64Slice(0, data.length); + }, + other: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + if (textDecoders.has(exports2.toString())) { + try { + return textDecoders.get(exports2).decode(data); + } catch { + } + } + return typeof data === "string" ? data : data.toString(); + } + }; + function decodeText(text, sourceEncoding, destEncoding) { + if (text) { + return getDecoder(destEncoding)(text, sourceEncoding); + } + return text; + } + module2.exports = decodeText; + } +}); + +// node_modules/@fastify/busboy/lib/utils/parseParams.js +var require_parseParams = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) { + "use strict"; + var decodeText = require_decodeText(); + var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g; + var EncodedLookup = { + "%00": "\0", + "%01": "", + "%02": "", + "%03": "", + "%04": "", + "%05": "", + "%06": "", + "%07": "\x07", + "%08": "\b", + "%09": " ", + "%0a": "\n", + "%0A": "\n", + "%0b": "\v", + "%0B": "\v", + "%0c": "\f", + "%0C": "\f", + "%0d": "\r", + "%0D": "\r", + "%0e": "", + "%0E": "", + "%0f": "", + "%0F": "", + "%10": "", + "%11": "", + "%12": "", + "%13": "", + "%14": "", + "%15": "", + "%16": "", + "%17": "", + "%18": "", + "%19": "", + "%1a": "", + "%1A": "", + "%1b": "\x1B", + "%1B": "\x1B", + "%1c": "", + "%1C": "", + "%1d": "", + "%1D": "", + "%1e": "", + "%1E": "", + "%1f": "", + "%1F": "", + "%20": " ", + "%21": "!", + "%22": '"', + "%23": "#", + "%24": "$", + "%25": "%", + "%26": "&", + "%27": "'", + "%28": "(", + "%29": ")", + "%2a": "*", + "%2A": "*", + "%2b": "+", + "%2B": "+", + "%2c": ",", + "%2C": ",", + "%2d": "-", + "%2D": "-", + "%2e": ".", + "%2E": ".", + "%2f": "/", + "%2F": "/", + "%30": "0", + "%31": "1", + "%32": "2", + "%33": "3", + "%34": "4", + "%35": "5", + "%36": "6", + "%37": "7", + "%38": "8", + "%39": "9", + "%3a": ":", + "%3A": ":", + "%3b": ";", + "%3B": ";", + "%3c": "<", + "%3C": "<", + "%3d": "=", + "%3D": "=", + "%3e": ">", + "%3E": ">", + "%3f": "?", + "%3F": "?", + "%40": "@", + "%41": "A", + "%42": "B", + "%43": "C", + "%44": "D", + "%45": "E", + "%46": "F", + "%47": "G", + "%48": "H", + "%49": "I", + "%4a": "J", + "%4A": "J", + "%4b": "K", + "%4B": "K", + "%4c": "L", + "%4C": "L", + "%4d": "M", + "%4D": "M", + "%4e": "N", + "%4E": "N", + "%4f": "O", + "%4F": "O", + "%50": "P", + "%51": "Q", + "%52": "R", + "%53": "S", + "%54": "T", + "%55": "U", + "%56": "V", + "%57": "W", + "%58": "X", + "%59": "Y", + "%5a": "Z", + "%5A": "Z", + "%5b": "[", + "%5B": "[", + "%5c": "\\", + "%5C": "\\", + "%5d": "]", + "%5D": "]", + "%5e": "^", + "%5E": "^", + "%5f": "_", + "%5F": "_", + "%60": "`", + "%61": "a", + "%62": "b", + "%63": "c", + "%64": "d", + "%65": "e", + "%66": "f", + "%67": "g", + "%68": "h", + "%69": "i", + "%6a": "j", + "%6A": "j", + "%6b": "k", + "%6B": "k", + "%6c": "l", + "%6C": "l", + "%6d": "m", + "%6D": "m", + "%6e": "n", + "%6E": "n", + "%6f": "o", + "%6F": "o", + "%70": "p", + "%71": "q", + "%72": "r", + "%73": "s", + "%74": "t", + "%75": "u", + "%76": "v", + "%77": "w", + "%78": "x", + "%79": "y", + "%7a": "z", + "%7A": "z", + "%7b": "{", + "%7B": "{", + "%7c": "|", + "%7C": "|", + "%7d": "}", + "%7D": "}", + "%7e": "~", + "%7E": "~", + "%7f": "\x7F", + "%7F": "\x7F", + "%80": "\x80", + "%81": "\x81", + "%82": "\x82", + "%83": "\x83", + "%84": "\x84", + "%85": "\x85", + "%86": "\x86", + "%87": "\x87", + "%88": "\x88", + "%89": "\x89", + "%8a": "\x8A", + "%8A": "\x8A", + "%8b": "\x8B", + "%8B": "\x8B", + "%8c": "\x8C", + "%8C": "\x8C", + "%8d": "\x8D", + "%8D": "\x8D", + "%8e": "\x8E", + "%8E": "\x8E", + "%8f": "\x8F", + "%8F": "\x8F", + "%90": "\x90", + "%91": "\x91", + "%92": "\x92", + "%93": "\x93", + "%94": "\x94", + "%95": "\x95", + "%96": "\x96", + "%97": "\x97", + "%98": "\x98", + "%99": "\x99", + "%9a": "\x9A", + "%9A": "\x9A", + "%9b": "\x9B", + "%9B": "\x9B", + "%9c": "\x9C", + "%9C": "\x9C", + "%9d": "\x9D", + "%9D": "\x9D", + "%9e": "\x9E", + "%9E": "\x9E", + "%9f": "\x9F", + "%9F": "\x9F", + "%a0": "\xA0", + "%A0": "\xA0", + "%a1": "\xA1", + "%A1": "\xA1", + "%a2": "\xA2", + "%A2": "\xA2", + "%a3": "\xA3", + "%A3": "\xA3", + "%a4": "\xA4", + "%A4": "\xA4", + "%a5": "\xA5", + "%A5": "\xA5", + "%a6": "\xA6", + "%A6": "\xA6", + "%a7": "\xA7", + "%A7": "\xA7", + "%a8": "\xA8", + "%A8": "\xA8", + "%a9": "\xA9", + "%A9": "\xA9", + "%aa": "\xAA", + "%Aa": "\xAA", + "%aA": "\xAA", + "%AA": "\xAA", + "%ab": "\xAB", + "%Ab": "\xAB", + "%aB": "\xAB", + "%AB": "\xAB", + "%ac": "\xAC", + "%Ac": "\xAC", + "%aC": "\xAC", + "%AC": "\xAC", + "%ad": "\xAD", + "%Ad": "\xAD", + "%aD": "\xAD", + "%AD": "\xAD", + "%ae": "\xAE", + "%Ae": "\xAE", + "%aE": "\xAE", + "%AE": "\xAE", + "%af": "\xAF", + "%Af": "\xAF", + "%aF": "\xAF", + "%AF": "\xAF", + "%b0": "\xB0", + "%B0": "\xB0", + "%b1": "\xB1", + "%B1": "\xB1", + "%b2": "\xB2", + "%B2": "\xB2", + "%b3": "\xB3", + "%B3": "\xB3", + "%b4": "\xB4", + "%B4": "\xB4", + "%b5": "\xB5", + "%B5": "\xB5", + "%b6": "\xB6", + "%B6": "\xB6", + "%b7": "\xB7", + "%B7": "\xB7", + "%b8": "\xB8", + "%B8": "\xB8", + "%b9": "\xB9", + "%B9": "\xB9", + "%ba": "\xBA", + "%Ba": "\xBA", + "%bA": "\xBA", + "%BA": "\xBA", + "%bb": "\xBB", + "%Bb": "\xBB", + "%bB": "\xBB", + "%BB": "\xBB", + "%bc": "\xBC", + "%Bc": "\xBC", + "%bC": "\xBC", + "%BC": "\xBC", + "%bd": "\xBD", + "%Bd": "\xBD", + "%bD": "\xBD", + "%BD": "\xBD", + "%be": "\xBE", + "%Be": "\xBE", + "%bE": "\xBE", + "%BE": "\xBE", + "%bf": "\xBF", + "%Bf": "\xBF", + "%bF": "\xBF", + "%BF": "\xBF", + "%c0": "\xC0", + "%C0": "\xC0", + "%c1": "\xC1", + "%C1": "\xC1", + "%c2": "\xC2", + "%C2": "\xC2", + "%c3": "\xC3", + "%C3": "\xC3", + "%c4": "\xC4", + "%C4": "\xC4", + "%c5": "\xC5", + "%C5": "\xC5", + "%c6": "\xC6", + "%C6": "\xC6", + "%c7": "\xC7", + "%C7": "\xC7", + "%c8": "\xC8", + "%C8": "\xC8", + "%c9": "\xC9", + "%C9": "\xC9", + "%ca": "\xCA", + "%Ca": "\xCA", + "%cA": "\xCA", + "%CA": "\xCA", + "%cb": "\xCB", + "%Cb": "\xCB", + "%cB": "\xCB", + "%CB": "\xCB", + "%cc": "\xCC", + "%Cc": "\xCC", + "%cC": "\xCC", + "%CC": "\xCC", + "%cd": "\xCD", + "%Cd": "\xCD", + "%cD": "\xCD", + "%CD": "\xCD", + "%ce": "\xCE", + "%Ce": "\xCE", + "%cE": "\xCE", + "%CE": "\xCE", + "%cf": "\xCF", + "%Cf": "\xCF", + "%cF": "\xCF", + "%CF": "\xCF", + "%d0": "\xD0", + "%D0": "\xD0", + "%d1": "\xD1", + "%D1": "\xD1", + "%d2": "\xD2", + "%D2": "\xD2", + "%d3": "\xD3", + "%D3": "\xD3", + "%d4": "\xD4", + "%D4": "\xD4", + "%d5": "\xD5", + "%D5": "\xD5", + "%d6": "\xD6", + "%D6": "\xD6", + "%d7": "\xD7", + "%D7": "\xD7", + "%d8": "\xD8", + "%D8": "\xD8", + "%d9": "\xD9", + "%D9": "\xD9", + "%da": "\xDA", + "%Da": "\xDA", + "%dA": "\xDA", + "%DA": "\xDA", + "%db": "\xDB", + "%Db": "\xDB", + "%dB": "\xDB", + "%DB": "\xDB", + "%dc": "\xDC", + "%Dc": "\xDC", + "%dC": "\xDC", + "%DC": "\xDC", + "%dd": "\xDD", + "%Dd": "\xDD", + "%dD": "\xDD", + "%DD": "\xDD", + "%de": "\xDE", + "%De": "\xDE", + "%dE": "\xDE", + "%DE": "\xDE", + "%df": "\xDF", + "%Df": "\xDF", + "%dF": "\xDF", + "%DF": "\xDF", + "%e0": "\xE0", + "%E0": "\xE0", + "%e1": "\xE1", + "%E1": "\xE1", + "%e2": "\xE2", + "%E2": "\xE2", + "%e3": "\xE3", + "%E3": "\xE3", + "%e4": "\xE4", + "%E4": "\xE4", + "%e5": "\xE5", + "%E5": "\xE5", + "%e6": "\xE6", + "%E6": "\xE6", + "%e7": "\xE7", + "%E7": "\xE7", + "%e8": "\xE8", + "%E8": "\xE8", + "%e9": "\xE9", + "%E9": "\xE9", + "%ea": "\xEA", + "%Ea": "\xEA", + "%eA": "\xEA", + "%EA": "\xEA", + "%eb": "\xEB", + "%Eb": "\xEB", + "%eB": "\xEB", + "%EB": "\xEB", + "%ec": "\xEC", + "%Ec": "\xEC", + "%eC": "\xEC", + "%EC": "\xEC", + "%ed": "\xED", + "%Ed": "\xED", + "%eD": "\xED", + "%ED": "\xED", + "%ee": "\xEE", + "%Ee": "\xEE", + "%eE": "\xEE", + "%EE": "\xEE", + "%ef": "\xEF", + "%Ef": "\xEF", + "%eF": "\xEF", + "%EF": "\xEF", + "%f0": "\xF0", + "%F0": "\xF0", + "%f1": "\xF1", + "%F1": "\xF1", + "%f2": "\xF2", + "%F2": "\xF2", + "%f3": "\xF3", + "%F3": "\xF3", + "%f4": "\xF4", + "%F4": "\xF4", + "%f5": "\xF5", + "%F5": "\xF5", + "%f6": "\xF6", + "%F6": "\xF6", + "%f7": "\xF7", + "%F7": "\xF7", + "%f8": "\xF8", + "%F8": "\xF8", + "%f9": "\xF9", + "%F9": "\xF9", + "%fa": "\xFA", + "%Fa": "\xFA", + "%fA": "\xFA", + "%FA": "\xFA", + "%fb": "\xFB", + "%Fb": "\xFB", + "%fB": "\xFB", + "%FB": "\xFB", + "%fc": "\xFC", + "%Fc": "\xFC", + "%fC": "\xFC", + "%FC": "\xFC", + "%fd": "\xFD", + "%Fd": "\xFD", + "%fD": "\xFD", + "%FD": "\xFD", + "%fe": "\xFE", + "%Fe": "\xFE", + "%fE": "\xFE", + "%FE": "\xFE", + "%ff": "\xFF", + "%Ff": "\xFF", + "%fF": "\xFF", + "%FF": "\xFF" + }; + function encodedReplacer(match) { + return EncodedLookup[match]; + } + var STATE_KEY = 0; + var STATE_VALUE = 1; + var STATE_CHARSET = 2; + var STATE_LANG = 3; + function parseParams(str) { + const res = []; + let state = STATE_KEY; + let charset = ""; + let inquote = false; + let escaping = false; + let p = 0; + let tmp = ""; + const len = str.length; + for (var i = 0; i < len; ++i) { + const char = str[i]; + if (char === "\\" && inquote) { + if (escaping) { + escaping = false; + } else { + escaping = true; + continue; + } + } else if (char === '"') { + if (!escaping) { + if (inquote) { + inquote = false; + state = STATE_KEY; + } else { + inquote = true; + } + continue; + } else { + escaping = false; + } + } else { + if (escaping && inquote) { + tmp += "\\"; + } + escaping = false; + if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") { + if (state === STATE_CHARSET) { + state = STATE_LANG; + charset = tmp.substring(1); + } else { + state = STATE_VALUE; + } + tmp = ""; + continue; + } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) { + state = char === "*" ? STATE_CHARSET : STATE_VALUE; + res[p] = [tmp, void 0]; + tmp = ""; + continue; + } else if (!inquote && char === ";") { + state = STATE_KEY; + if (charset) { + if (tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } + charset = ""; + } else if (tmp.length) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + res[p] = tmp; + } else { + res[p][1] = tmp; + } + tmp = ""; + ++p; + continue; + } else if (!inquote && (char === " " || char === " ")) { + continue; + } + } + tmp += char; + } + if (charset && tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } else if (tmp) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + if (tmp) { + res[p] = tmp; + } + } else { + res[p][1] = tmp; + } + return res; + } + module2.exports = parseParams; + } +}); + +// node_modules/@fastify/busboy/lib/utils/basename.js +var require_basename = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) { + "use strict"; + module2.exports = function basename(path2) { + if (typeof path2 !== "string") { + return ""; + } + for (var i = path2.length - 1; i >= 0; --i) { + switch (path2.charCodeAt(i)) { + case 47: + // '/' + case 92: + path2 = path2.slice(i + 1); + return path2 === ".." || path2 === "." ? "" : path2; + } + } + return path2 === ".." || path2 === "." ? "" : path2; + }; + } +}); + +// node_modules/@fastify/busboy/lib/types/multipart.js +var require_multipart = __commonJS({ + "node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) { + "use strict"; + var { Readable } = require("node:stream"); + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var parseParams = require_parseParams(); + var decodeText = require_decodeText(); + var basename = require_basename(); + var getLimit = require_getLimit(); + var RE_BOUNDARY = /^boundary$/i; + var RE_FIELD = /^form-data$/i; + var RE_CHARSET = /^charset$/i; + var RE_FILENAME = /^filename$/i; + var RE_NAME = /^name$/i; + Multipart.detect = /^multipart\/form-data/i; + function Multipart(boy, cfg) { + let i; + let len; + const self = this; + let boundary; + const limits = cfg.limits; + const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0); + const parsedConType = cfg.parsedConType || []; + const defCharset = cfg.defCharset || "utf8"; + const preservePath = cfg.preservePath; + const fileOpts = { highWaterMark: cfg.fileHwm }; + for (i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) { + boundary = parsedConType[i][1]; + break; + } + } + function checkFinished() { + if (nends === 0 && finished && !boy._done) { + finished = false; + self.end(); + } + } + if (typeof boundary !== "string") { + throw new Error("Multipart: Boundary not found"); + } + const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + const fileSizeLimit = getLimit(limits, "fileSize", Infinity); + const filesLimit = getLimit(limits, "files", Infinity); + const fieldsLimit = getLimit(limits, "fields", Infinity); + const partsLimit = getLimit(limits, "parts", Infinity); + const headerPairsLimit = getLimit(limits, "headerPairs", 2e3); + const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024); + let nfiles = 0; + let nfields = 0; + let nends = 0; + let curFile; + let curField; + let finished = false; + this._needDrain = false; + this._pause = false; + this._cb = void 0; + this._nparts = 0; + this._boy = boy; + const parserCfg = { + boundary, + maxHeaderPairs: headerPairsLimit, + maxHeaderSize: headerSizeLimit, + partHwm: fileOpts.highWaterMark, + highWaterMark: cfg.highWaterMark + }; + this.parser = new Dicer(parserCfg); + this.parser.on("drain", function() { + self._needDrain = false; + if (self._cb && !self._pause) { + const cb = self._cb; + self._cb = void 0; + cb(); + } + }).on("part", function onPart(part) { + if (++self._nparts > partsLimit) { + self.parser.removeListener("part", onPart); + self.parser.on("part", skipPart); + boy.hitPartsLimit = true; + boy.emit("partsLimit"); + return skipPart(part); + } + if (curField) { + const field = curField; + field.emit("end"); + field.removeAllListeners("end"); + } + part.on("header", function(header) { + let contype; + let fieldname; + let parsed; + let charset; + let encoding; + let filename; + let nsize = 0; + if (header["content-type"]) { + parsed = parseParams(header["content-type"][0]); + if (parsed[0]) { + contype = parsed[0].toLowerCase(); + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_CHARSET.test(parsed[i][0])) { + charset = parsed[i][1].toLowerCase(); + break; + } + } + } + } + if (contype === void 0) { + contype = "text/plain"; + } + if (charset === void 0) { + charset = defCharset; + } + if (header["content-disposition"]) { + parsed = parseParams(header["content-disposition"][0]); + if (!RE_FIELD.test(parsed[0])) { + return skipPart(part); + } + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_NAME.test(parsed[i][0])) { + fieldname = parsed[i][1]; + } else if (RE_FILENAME.test(parsed[i][0])) { + filename = parsed[i][1]; + if (!preservePath) { + filename = basename(filename); + } + } + } + } else { + return skipPart(part); + } + if (header["content-transfer-encoding"]) { + encoding = header["content-transfer-encoding"][0].toLowerCase(); + } else { + encoding = "7bit"; + } + let onData, onEnd; + if (isPartAFile(fieldname, contype, filename)) { + if (nfiles === filesLimit) { + if (!boy.hitFilesLimit) { + boy.hitFilesLimit = true; + boy.emit("filesLimit"); + } + return skipPart(part); + } + ++nfiles; + if (boy.listenerCount("file") === 0) { + self.parser._ignore(); + return; + } + ++nends; + const file = new FileStream(fileOpts); + curFile = file; + file.on("end", function() { + --nends; + self._pause = false; + checkFinished(); + if (self._cb && !self._needDrain) { + const cb = self._cb; + self._cb = void 0; + cb(); + } + }); + file._read = function(n) { + if (!self._pause) { + return; + } + self._pause = false; + if (self._cb && !self._needDrain) { + const cb = self._cb; + self._cb = void 0; + cb(); + } + }; + boy.emit("file", fieldname, file, filename, encoding, contype); + onData = function(data) { + if ((nsize += data.length) > fileSizeLimit) { + const extralen = fileSizeLimit - nsize + data.length; + if (extralen > 0) { + file.push(data.slice(0, extralen)); + } + file.truncated = true; + file.bytesRead = fileSizeLimit; + part.removeAllListeners("data"); + file.emit("limit"); + return; + } else if (!file.push(data)) { + self._pause = true; + } + file.bytesRead = nsize; + }; + onEnd = function() { + curFile = void 0; + file.push(null); + }; + } else { + if (nfields === fieldsLimit) { + if (!boy.hitFieldsLimit) { + boy.hitFieldsLimit = true; + boy.emit("fieldsLimit"); + } + return skipPart(part); + } + ++nfields; + ++nends; + let buffer = ""; + let truncated = false; + curField = part; + onData = function(data) { + if ((nsize += data.length) > fieldSizeLimit) { + const extralen = fieldSizeLimit - (nsize - data.length); + buffer += data.toString("binary", 0, extralen); + truncated = true; + part.removeAllListeners("data"); + } else { + buffer += data.toString("binary"); + } + }; + onEnd = function() { + curField = void 0; + if (buffer.length) { + buffer = decodeText(buffer, "binary", charset); + } + boy.emit("field", fieldname, buffer, false, truncated, encoding, contype); + --nends; + checkFinished(); + }; + } + part._readableState.sync = false; + part.on("data", onData); + part.on("end", onEnd); + }).on("error", function(err) { + if (curFile) { + curFile.emit("error", err); + } + }); + }).on("error", function(err) { + boy.emit("error", err); + }).on("finish", function() { + finished = true; + checkFinished(); + }); + } + Multipart.prototype.write = function(chunk, cb) { + const r = this.parser.write(chunk); + if (r && !this._pause) { + cb(); + } else { + this._needDrain = !r; + this._cb = cb; + } + }; + Multipart.prototype.end = function() { + const self = this; + if (self.parser.writable) { + self.parser.end(); + } else if (!self._boy._done) { + process.nextTick(function() { + self._boy._done = true; + self._boy.emit("finish"); + }); + } + }; + function skipPart(part) { + part.resume(); + } + function FileStream(opts) { + Readable.call(this, opts); + this.bytesRead = 0; + this.truncated = false; + } + inherits(FileStream, Readable); + FileStream.prototype._read = function(n) { + }; + module2.exports = Multipart; + } +}); + +// node_modules/@fastify/busboy/lib/utils/Decoder.js +var require_Decoder = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) { + "use strict"; + var RE_PLUS = /\+/g; + var HEX = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ]; + function Decoder() { + this.buffer = void 0; + } + Decoder.prototype.write = function(str) { + str = str.replace(RE_PLUS, " "); + let res = ""; + let i = 0; + let p = 0; + const len = str.length; + for (; i < len; ++i) { + if (this.buffer !== void 0) { + if (!HEX[str.charCodeAt(i)]) { + res += "%" + this.buffer; + this.buffer = void 0; + --i; + } else { + this.buffer += str[i]; + ++p; + if (this.buffer.length === 2) { + res += String.fromCharCode(parseInt(this.buffer, 16)); + this.buffer = void 0; + } + } + } else if (str[i] === "%") { + if (i > p) { + res += str.substring(p, i); + p = i; + } + this.buffer = ""; + ++p; + } + } + if (p < len && this.buffer === void 0) { + res += str.substring(p); + } + return res; + }; + Decoder.prototype.reset = function() { + this.buffer = void 0; + }; + module2.exports = Decoder; + } +}); + +// node_modules/@fastify/busboy/lib/types/urlencoded.js +var require_urlencoded = __commonJS({ + "node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) { + "use strict"; + var Decoder = require_Decoder(); + var decodeText = require_decodeText(); + var getLimit = require_getLimit(); + var RE_CHARSET = /^charset$/i; + UrlEncoded.detect = /^application\/x-www-form-urlencoded/i; + function UrlEncoded(boy, cfg) { + const limits = cfg.limits; + const parsedConType = cfg.parsedConType; + this.boy = boy; + this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100); + this.fieldsLimit = getLimit(limits, "fields", Infinity); + let charset; + for (var i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) { + charset = parsedConType[i][1].toLowerCase(); + break; + } + } + if (charset === void 0) { + charset = cfg.defCharset || "utf8"; + } + this.decoder = new Decoder(); + this.charset = charset; + this._fields = 0; + this._state = "key"; + this._checkingBytes = true; + this._bytesKey = 0; + this._bytesVal = 0; + this._key = ""; + this._val = ""; + this._keyTrunc = false; + this._valTrunc = false; + this._hitLimit = false; + } + UrlEncoded.prototype.write = function(data, cb) { + if (this._fields === this.fieldsLimit) { + if (!this.boy.hitFieldsLimit) { + this.boy.hitFieldsLimit = true; + this.boy.emit("fieldsLimit"); + } + return cb(); + } + let idxeq; + let idxamp; + let i; + let p = 0; + const len = data.length; + while (p < len) { + if (this._state === "key") { + idxeq = idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 61) { + idxeq = i; + break; + } else if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesKey; + } + } + if (idxeq !== void 0) { + if (idxeq > p) { + this._key += this.decoder.write(data.toString("binary", p, idxeq)); + } + this._state = "val"; + this._hitLimit = false; + this._checkingBytes = true; + this._val = ""; + this._bytesVal = 0; + this._valTrunc = false; + this.decoder.reset(); + p = idxeq + 1; + } else if (idxamp !== void 0) { + ++this._fields; + let key; + const keyTrunc = this._keyTrunc; + if (idxamp > p) { + key = this._key += this.decoder.write(data.toString("binary", p, idxamp)); + } else { + key = this._key; + } + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + if (key.length) { + this.boy.emit( + "field", + decodeText(key, "binary", this.charset), + "", + keyTrunc, + false + ); + } + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._key += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) { + this._checkingBytes = false; + this._keyTrunc = true; + } + } else { + if (p < len) { + this._key += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } else { + idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesVal; + } + } + if (idxamp !== void 0) { + ++this._fields; + if (idxamp > p) { + this._val += this.decoder.write(data.toString("binary", p, idxamp)); + } + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + this._state = "key"; + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._val += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) { + this._checkingBytes = false; + this._valTrunc = true; + } + } else { + if (p < len) { + this._val += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } + } + cb(); + }; + UrlEncoded.prototype.end = function() { + if (this.boy._done) { + return; + } + if (this._state === "key" && this._key.length > 0) { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + "", + this._keyTrunc, + false + ); + } else if (this._state === "val") { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + } + this.boy._done = true; + this.boy.emit("finish"); + }; + module2.exports = UrlEncoded; + } +}); + +// node_modules/@fastify/busboy/lib/main.js +var require_main = __commonJS({ + "node_modules/@fastify/busboy/lib/main.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var MultipartParser = require_multipart(); + var UrlencodedParser = require_urlencoded(); + var parseParams = require_parseParams(); + function Busboy(opts) { + if (!(this instanceof Busboy)) { + return new Busboy(opts); + } + if (typeof opts !== "object") { + throw new TypeError("Busboy expected an options-Object."); + } + if (typeof opts.headers !== "object") { + throw new TypeError("Busboy expected an options-Object with headers-attribute."); + } + if (typeof opts.headers["content-type"] !== "string") { + throw new TypeError("Missing Content-Type-header."); + } + const { + headers, + ...streamOptions + } = opts; + this.opts = { + autoDestroy: false, + ...streamOptions + }; + WritableStream.call(this, this.opts); + this._done = false; + this._parser = this.getParserByHeaders(headers); + this._finished = false; + } + inherits(Busboy, WritableStream); + Busboy.prototype.emit = function(ev) { + if (ev === "finish") { + if (!this._done) { + this._parser?.end(); + return; + } else if (this._finished) { + return; + } + this._finished = true; + } + WritableStream.prototype.emit.apply(this, arguments); + }; + Busboy.prototype.getParserByHeaders = function(headers) { + const parsed = parseParams(headers["content-type"]); + const cfg = { + defCharset: this.opts.defCharset, + fileHwm: this.opts.fileHwm, + headers, + highWaterMark: this.opts.highWaterMark, + isPartAFile: this.opts.isPartAFile, + limits: this.opts.limits, + parsedConType: parsed, + preservePath: this.opts.preservePath + }; + if (MultipartParser.detect.test(parsed[0])) { + return new MultipartParser(this, cfg); + } + if (UrlencodedParser.detect.test(parsed[0])) { + return new UrlencodedParser(this, cfg); + } + throw new Error("Unsupported Content-Type."); + }; + Busboy.prototype._write = function(chunk, encoding, cb) { + this._parser.write(chunk, cb); + }; + module2.exports = Busboy; + module2.exports.default = Busboy; + module2.exports.Busboy = Busboy; + module2.exports.Dicer = Dicer; + } +}); + +// node_modules/undici/lib/fetch/constants.js +var require_constants2 = __commonJS({ + "node_modules/undici/lib/fetch/constants.js"(exports2, module2) { + "use strict"; + var { MessageChannel, receiveMessageOnPort } = require("worker_threads"); + var corsSafeListedMethods = ["GET", "HEAD", "POST"]; + var corsSafeListedMethodsSet = new Set(corsSafeListedMethods); + var nullBodyStatus = [101, 204, 205, 304]; + var redirectStatus = [301, 302, 303, 307, 308]; + var redirectStatusSet = new Set(redirectStatus); + var badPorts = [ + "1", + "7", + "9", + "11", + "13", + "15", + "17", + "19", + "20", + "21", + "22", + "23", + "25", + "37", + "42", + "43", + "53", + "69", + "77", + "79", + "87", + "95", + "101", + "102", + "103", + "104", + "109", + "110", + "111", + "113", + "115", + "117", + "119", + "123", + "135", + "137", + "139", + "143", + "161", + "179", + "389", + "427", + "465", + "512", + "513", + "514", + "515", + "526", + "530", + "531", + "532", + "540", + "548", + "554", + "556", + "563", + "587", + "601", + "636", + "989", + "990", + "993", + "995", + "1719", + "1720", + "1723", + "2049", + "3659", + "4045", + "5060", + "5061", + "6000", + "6566", + "6665", + "6666", + "6667", + "6668", + "6669", + "6697", + "10080" + ]; + var badPortsSet = new Set(badPorts); + var referrerPolicy = [ + "", + "no-referrer", + "no-referrer-when-downgrade", + "same-origin", + "origin", + "strict-origin", + "origin-when-cross-origin", + "strict-origin-when-cross-origin", + "unsafe-url" + ]; + var referrerPolicySet = new Set(referrerPolicy); + var requestRedirect = ["follow", "manual", "error"]; + var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"]; + var safeMethodsSet = new Set(safeMethods); + var requestMode = ["navigate", "same-origin", "no-cors", "cors"]; + var requestCredentials = ["omit", "same-origin", "include"]; + var requestCache = [ + "default", + "no-store", + "reload", + "no-cache", + "force-cache", + "only-if-cached" + ]; + var requestBodyHeader = [ + "content-encoding", + "content-language", + "content-location", + "content-type", + // See https://github.com/nodejs/undici/issues/2021 + // 'Content-Length' is a forbidden header name, which is typically + // removed in the Headers implementation. However, undici doesn't + // filter out headers, so we add it here. + "content-length" + ]; + var requestDuplex = [ + "half" + ]; + var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"]; + var forbiddenMethodsSet = new Set(forbiddenMethods); + var subresource = [ + "audio", + "audioworklet", + "font", + "image", + "manifest", + "paintworklet", + "script", + "style", + "track", + "video", + "xslt", + "" + ]; + var subresourceSet = new Set(subresource); + var DOMException2 = globalThis.DOMException ?? (() => { + try { + atob("~"); + } catch (err) { + return Object.getPrototypeOf(err).constructor; + } + })(); + var channel; + var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js + // structuredClone was added in v17.0.0, but fetch supports v16.8 + function structuredClone2(value, options = void 0) { + if (arguments.length === 0) { + throw new TypeError("missing argument"); + } + if (!channel) { + channel = new MessageChannel(); + } + channel.port1.unref(); + channel.port2.unref(); + channel.port1.postMessage(value, options?.transfer); + return receiveMessageOnPort(channel.port2).message; + }; + module2.exports = { + DOMException: DOMException2, + structuredClone, + subresource, + forbiddenMethods, + requestBodyHeader, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + redirectStatus, + corsSafeListedMethods, + nullBodyStatus, + safeMethods, + badPorts, + requestDuplex, + subresourceSet, + badPortsSet, + redirectStatusSet, + corsSafeListedMethodsSet, + safeMethodsSet, + forbiddenMethodsSet, + referrerPolicySet + }; + } +}); + +// node_modules/undici/lib/fetch/global.js +var require_global = __commonJS({ + "node_modules/undici/lib/fetch/global.js"(exports2, module2) { + "use strict"; + var globalOrigin = Symbol.for("undici.globalOrigin.1"); + function getGlobalOrigin() { + return globalThis[globalOrigin]; + } + function setGlobalOrigin(newOrigin) { + if (newOrigin === void 0) { + Object.defineProperty(globalThis, globalOrigin, { + value: void 0, + writable: true, + enumerable: false, + configurable: false + }); + return; + } + const parsedURL = new URL(newOrigin); + if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") { + throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`); + } + Object.defineProperty(globalThis, globalOrigin, { + value: parsedURL, + writable: true, + enumerable: false, + configurable: false + }); + } + module2.exports = { + getGlobalOrigin, + setGlobalOrigin + }; + } +}); + +// node_modules/undici/lib/fetch/util.js +var require_util2 = __commonJS({ + "node_modules/undici/lib/fetch/util.js"(exports2, module2) { + "use strict"; + var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2(); + var { getGlobalOrigin } = require_global(); + var { performance: performance2 } = require("perf_hooks"); + var { isBlobLike: isBlobLike2, toUSVString, ReadableStreamFrom: ReadableStreamFrom2 } = require_util(); + var assert = require("assert"); + var { isUint8Array } = require("util/types"); + var supportedHashes = []; + var crypto; + try { + crypto = require("crypto"); + const possibleRelevantHashes = ["sha256", "sha384", "sha512"]; + supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)); + } catch { + } + function responseURL(response) { + const urlList = response.urlList; + const length = urlList.length; + return length === 0 ? null : urlList[length - 1].toString(); + } + function responseLocationURL(response, requestFragment) { + if (!redirectStatusSet.has(response.status)) { + return null; + } + let location = response.headersList.get("location"); + if (location !== null && isValidHeaderValue(location)) { + location = new URL(location, responseURL(response)); + } + if (location && !location.hash) { + location.hash = requestFragment; + } + return location; + } + function requestCurrentURL(request) { + return request.urlList[request.urlList.length - 1]; + } + function requestBadPort(request) { + const url = requestCurrentURL(request); + if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) { + return "blocked"; + } + return "allowed"; + } + function isErrorLike(object) { + return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException"); + } + function isValidReasonPhrase(statusText) { + for (let i = 0; i < statusText.length; ++i) { + const c = statusText.charCodeAt(i); + if (!(c === 9 || // HTAB + c >= 32 && c <= 126 || // SP / VCHAR + c >= 128 && c <= 255)) { + return false; + } + } + return true; + } + function isTokenCharCode(c) { + switch (c) { + case 34: + case 40: + case 41: + case 44: + case 47: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 91: + case 92: + case 93: + case 123: + case 125: + return false; + default: + return c >= 33 && c <= 126; + } + } + function isValidHTTPToken(characters) { + if (characters.length === 0) { + return false; + } + for (let i = 0; i < characters.length; ++i) { + if (!isTokenCharCode(characters.charCodeAt(i))) { + return false; + } + } + return true; + } + function isValidHeaderName(potentialValue) { + return isValidHTTPToken(potentialValue); + } + function isValidHeaderValue(potentialValue) { + if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) { + return false; + } + if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) { + return false; + } + return true; + } + function setRequestReferrerPolicyOnRedirect(request, actualResponse) { + const { headersList } = actualResponse; + const policyHeader = (headersList.get("referrer-policy") ?? "").split(","); + let policy = ""; + if (policyHeader.length > 0) { + for (let i = policyHeader.length; i !== 0; i--) { + const token = policyHeader[i - 1].trim(); + if (referrerPolicyTokens.has(token)) { + policy = token; + break; + } + } + } + if (policy !== "") { + request.referrerPolicy = policy; + } + } + function crossOriginResourcePolicyCheck() { + return "allowed"; + } + function corsCheck() { + return "success"; + } + function TAOCheck() { + return "success"; + } + function appendFetchMetadata(httpRequest) { + let header = null; + header = httpRequest.mode; + httpRequest.headersList.set("sec-fetch-mode", header); + } + function appendRequestOriginHeader(request) { + let serializedOrigin = request.origin; + if (request.responseTainting === "cors" || request.mode === "websocket") { + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } else if (request.method !== "GET" && request.method !== "HEAD") { + switch (request.referrerPolicy) { + case "no-referrer": + serializedOrigin = null; + break; + case "no-referrer-when-downgrade": + case "strict-origin": + case "strict-origin-when-cross-origin": + if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + case "same-origin": + if (!sameOrigin(request, requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + default: + } + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } + } + function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) { + return performance2.now(); + } + function createOpaqueTimingInfo(timingInfo) { + return { + startTime: timingInfo.startTime ?? 0, + redirectStartTime: 0, + redirectEndTime: 0, + postRedirectStartTime: timingInfo.startTime ?? 0, + finalServiceWorkerStartTime: 0, + finalNetworkResponseStartTime: 0, + finalNetworkRequestStartTime: 0, + endTime: 0, + encodedBodySize: 0, + decodedBodySize: 0, + finalConnectionTimingInfo: null + }; + } + function makePolicyContainer() { + return { + referrerPolicy: "strict-origin-when-cross-origin" + }; + } + function clonePolicyContainer(policyContainer) { + return { + referrerPolicy: policyContainer.referrerPolicy + }; + } + function determineRequestsReferrer(request) { + const policy = request.referrerPolicy; + assert(policy); + let referrerSource = null; + if (request.referrer === "client") { + const globalOrigin = getGlobalOrigin(); + if (!globalOrigin || globalOrigin.origin === "null") { + return "no-referrer"; + } + referrerSource = new URL(globalOrigin); + } else if (request.referrer instanceof URL) { + referrerSource = request.referrer; + } + let referrerURL = stripURLForReferrer(referrerSource); + const referrerOrigin = stripURLForReferrer(referrerSource, true); + if (referrerURL.toString().length > 4096) { + referrerURL = referrerOrigin; + } + const areSameOrigin = sameOrigin(request, referrerURL); + const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url); + switch (policy) { + case "origin": + return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true); + case "unsafe-url": + return referrerURL; + case "same-origin": + return areSameOrigin ? referrerOrigin : "no-referrer"; + case "origin-when-cross-origin": + return areSameOrigin ? referrerURL : referrerOrigin; + case "strict-origin-when-cross-origin": { + const currentURL = requestCurrentURL(request); + if (sameOrigin(referrerURL, currentURL)) { + return referrerURL; + } + if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) { + return "no-referrer"; + } + return referrerOrigin; + } + case "strict-origin": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + case "no-referrer-when-downgrade": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + default: + return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin; + } + } + function stripURLForReferrer(url, originOnly) { + assert(url instanceof URL); + if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") { + return "no-referrer"; + } + url.username = ""; + url.password = ""; + url.hash = ""; + if (originOnly) { + url.pathname = ""; + url.search = ""; + } + return url; + } + function isURLPotentiallyTrustworthy(url) { + if (!(url instanceof URL)) { + return false; + } + if (url.href === "about:blank" || url.href === "about:srcdoc") { + return true; + } + if (url.protocol === "data:") return true; + if (url.protocol === "file:") return true; + return isOriginPotentiallyTrustworthy(url.origin); + function isOriginPotentiallyTrustworthy(origin) { + if (origin == null || origin === "null") return false; + const originAsURL = new URL(origin); + if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") { + return true; + } + if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) { + return true; + } + return false; + } + } + function bytesMatch(bytes, metadataList) { + if (crypto === void 0) { + return true; + } + const parsedMetadata = parseMetadata(metadataList); + if (parsedMetadata === "no metadata") { + return true; + } + if (parsedMetadata.length === 0) { + return true; + } + const strongest = getStrongestMetadata(parsedMetadata); + const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest); + for (const item of metadata) { + const algorithm = item.algo; + const expectedValue = item.hash; + let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64"); + if (actualValue[actualValue.length - 1] === "=") { + if (actualValue[actualValue.length - 2] === "=") { + actualValue = actualValue.slice(0, -2); + } else { + actualValue = actualValue.slice(0, -1); + } + } + if (compareBase64Mixed(actualValue, expectedValue)) { + return true; + } + } + return false; + } + var parseHashWithOptions = /(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i; + function parseMetadata(metadata) { + const result = []; + let empty = true; + for (const token of metadata.split(" ")) { + empty = false; + const parsedToken = parseHashWithOptions.exec(token); + if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) { + continue; + } + const algorithm = parsedToken.groups.algo.toLowerCase(); + if (supportedHashes.includes(algorithm)) { + result.push(parsedToken.groups); + } + } + if (empty === true) { + return "no metadata"; + } + return result; + } + function getStrongestMetadata(metadataList) { + let algorithm = metadataList[0].algo; + if (algorithm[3] === "5") { + return algorithm; + } + for (let i = 1; i < metadataList.length; ++i) { + const metadata = metadataList[i]; + if (metadata.algo[3] === "5") { + algorithm = "sha512"; + break; + } else if (algorithm[3] === "3") { + continue; + } else if (metadata.algo[3] === "3") { + algorithm = "sha384"; + } + } + return algorithm; + } + function filterMetadataListByAlgorithm(metadataList, algorithm) { + if (metadataList.length === 1) { + return metadataList; + } + let pos = 0; + for (let i = 0; i < metadataList.length; ++i) { + if (metadataList[i].algo === algorithm) { + metadataList[pos++] = metadataList[i]; + } + } + metadataList.length = pos; + return metadataList; + } + function compareBase64Mixed(actualValue, expectedValue) { + if (actualValue.length !== expectedValue.length) { + return false; + } + for (let i = 0; i < actualValue.length; ++i) { + if (actualValue[i] !== expectedValue[i]) { + if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") { + continue; + } + return false; + } + } + return true; + } + function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) { + } + function sameOrigin(A, B) { + if (A.origin === B.origin && A.origin === "null") { + return true; + } + if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) { + return true; + } + return false; + } + function createDeferredPromise() { + let res; + let rej; + const promise = new Promise((resolve, reject) => { + res = resolve; + rej = reject; + }); + return { promise, resolve: res, reject: rej }; + } + function isAborted(fetchParams) { + return fetchParams.controller.state === "aborted"; + } + function isCancelled(fetchParams) { + return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated"; + } + var normalizeMethodRecord = { + delete: "DELETE", + DELETE: "DELETE", + get: "GET", + GET: "GET", + head: "HEAD", + HEAD: "HEAD", + options: "OPTIONS", + OPTIONS: "OPTIONS", + post: "POST", + POST: "POST", + put: "PUT", + PUT: "PUT" + }; + Object.setPrototypeOf(normalizeMethodRecord, null); + function normalizeMethod(method) { + return normalizeMethodRecord[method.toLowerCase()] ?? method; + } + function serializeJavascriptValueToJSONString(value) { + const result = JSON.stringify(value); + if (result === void 0) { + throw new TypeError("Value is not JSON serializable"); + } + assert(typeof result === "string"); + return result; + } + var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); + function makeIterator(iterator, name, kind) { + const object = { + index: 0, + kind, + target: iterator + }; + const i = { + next() { + if (Object.getPrototypeOf(this) !== i) { + throw new TypeError( + `'next' called on an object that does not implement interface ${name} Iterator.` + ); + } + const { index, kind: kind2, target } = object; + const values = target(); + const len = values.length; + if (index >= len) { + return { value: void 0, done: true }; + } + const pair = values[index]; + object.index = index + 1; + return iteratorResult(pair, kind2); + }, + // The class string of an iterator prototype object for a given interface is the + // result of concatenating the identifier of the interface and the string " Iterator". + [Symbol.toStringTag]: `${name} Iterator` + }; + Object.setPrototypeOf(i, esIteratorPrototype); + return Object.setPrototypeOf({}, i); + } + function iteratorResult(pair, kind) { + let result; + switch (kind) { + case "key": { + result = pair[0]; + break; + } + case "value": { + result = pair[1]; + break; + } + case "key+value": { + result = pair; + break; + } + } + return { value: result, done: false }; + } + async function fullyReadBody(body, processBody, processBodyError) { + const successSteps = processBody; + const errorSteps = processBodyError; + let reader; + try { + reader = body.stream.getReader(); + } catch (e) { + errorSteps(e); + return; + } + try { + const result = await readAllBytes(reader); + successSteps(result); + } catch (e) { + errorSteps(e); + } + } + var ReadableStream = globalThis.ReadableStream; + function isReadableStreamLike(stream) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function"; + } + var MAXIMUM_ARGUMENT_LENGTH = 65535; + function isomorphicDecode(input) { + if (input.length < MAXIMUM_ARGUMENT_LENGTH) { + return String.fromCharCode(...input); + } + return input.reduce((previous, current) => previous + String.fromCharCode(current), ""); + } + function readableStreamClose(controller) { + try { + controller.close(); + } catch (err) { + if (!err.message.includes("Controller is already closed")) { + throw err; + } + } + } + function isomorphicEncode(input) { + for (let i = 0; i < input.length; i++) { + assert(input.charCodeAt(i) <= 255); + } + return input; + } + async function readAllBytes(reader) { + const bytes = []; + let byteLength = 0; + while (true) { + const { done, value: chunk } = await reader.read(); + if (done) { + return Buffer.concat(bytes, byteLength); + } + if (!isUint8Array(chunk)) { + throw new TypeError("Received non-Uint8Array chunk"); + } + bytes.push(chunk); + byteLength += chunk.length; + } + } + function urlIsLocal(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "about:" || protocol === "blob:" || protocol === "data:"; + } + function urlHasHttpsScheme(url) { + if (typeof url === "string") { + return url.startsWith("https:"); + } + return url.protocol === "https:"; + } + function urlIsHttpHttpsScheme(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "http:" || protocol === "https:"; + } + var hasOwn2 = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key)); + module2.exports = { + isAborted, + isCancelled, + createDeferredPromise, + ReadableStreamFrom: ReadableStreamFrom2, + toUSVString, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + coarsenedSharedCurrentTime, + determineRequestsReferrer, + makePolicyContainer, + clonePolicyContainer, + appendFetchMetadata, + appendRequestOriginHeader, + TAOCheck, + corsCheck, + crossOriginResourcePolicyCheck, + createOpaqueTimingInfo, + setRequestReferrerPolicyOnRedirect, + isValidHTTPToken, + requestBadPort, + requestCurrentURL, + responseURL, + responseLocationURL, + isBlobLike: isBlobLike2, + isURLPotentiallyTrustworthy, + isValidReasonPhrase, + sameOrigin, + normalizeMethod, + serializeJavascriptValueToJSONString, + makeIterator, + isValidHeaderName, + isValidHeaderValue, + hasOwn: hasOwn2, + isErrorLike, + fullyReadBody, + bytesMatch, + isReadableStreamLike, + readableStreamClose, + isomorphicEncode, + isomorphicDecode, + urlIsLocal, + urlHasHttpsScheme, + urlIsHttpHttpsScheme, + readAllBytes, + normalizeMethodRecord, + parseMetadata + }; + } +}); + +// node_modules/undici/lib/fetch/symbols.js +var require_symbols2 = __commonJS({ + "node_modules/undici/lib/fetch/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kUrl: Symbol("url"), + kHeaders: Symbol("headers"), + kSignal: Symbol("signal"), + kState: Symbol("state"), + kGuard: Symbol("guard"), + kRealm: Symbol("realm") + }; + } +}); + +// node_modules/undici/lib/fetch/webidl.js +var require_webidl = __commonJS({ + "node_modules/undici/lib/fetch/webidl.js"(exports2, module2) { + "use strict"; + var { types } = require("util"); + var { hasOwn: hasOwn2, toUSVString } = require_util2(); + var webidl = {}; + webidl.converters = {}; + webidl.util = {}; + webidl.errors = {}; + webidl.errors.exception = function(message) { + return new TypeError(`${message.header}: ${message.message}`); + }; + webidl.errors.conversionFailed = function(context) { + const plural = context.types.length === 1 ? "" : " one of"; + const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`; + return webidl.errors.exception({ + header: context.prefix, + message + }); + }; + webidl.errors.invalidArgument = function(context) { + return webidl.errors.exception({ + header: context.prefix, + message: `"${context.value}" is an invalid ${context.type}.` + }); + }; + webidl.brandCheck = function(V, I, opts = void 0) { + if (opts?.strict !== false && !(V instanceof I)) { + throw new TypeError("Illegal invocation"); + } else { + return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag]; + } + }; + webidl.argumentLengthCheck = function({ length }, min, ctx) { + if (length < min) { + throw webidl.errors.exception({ + message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`, + ...ctx + }); + } + }; + webidl.illegalConstructor = function() { + throw webidl.errors.exception({ + header: "TypeError", + message: "Illegal constructor" + }); + }; + webidl.util.Type = function(V) { + switch (typeof V) { + case "undefined": + return "Undefined"; + case "boolean": + return "Boolean"; + case "string": + return "String"; + case "symbol": + return "Symbol"; + case "number": + return "Number"; + case "bigint": + return "BigInt"; + case "function": + case "object": { + if (V === null) { + return "Null"; + } + return "Object"; + } + } + }; + webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) { + let upperBound; + let lowerBound; + if (bitLength === 64) { + upperBound = Math.pow(2, 53) - 1; + if (signedness === "unsigned") { + lowerBound = 0; + } else { + lowerBound = Math.pow(-2, 53) + 1; + } + } else if (signedness === "unsigned") { + lowerBound = 0; + upperBound = Math.pow(2, bitLength) - 1; + } else { + lowerBound = Math.pow(-2, bitLength) - 1; + upperBound = Math.pow(2, bitLength - 1) - 1; + } + let x = Number(V); + if (x === 0) { + x = 0; + } + if (opts.enforceRange === true) { + if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Could not convert ${V} to an integer.` + }); + } + x = webidl.util.IntegerPart(x); + if (x < lowerBound || x > upperBound) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` + }); + } + return x; + } + if (!Number.isNaN(x) && opts.clamp === true) { + x = Math.min(Math.max(x, lowerBound), upperBound); + if (Math.floor(x) % 2 === 0) { + x = Math.floor(x); + } else { + x = Math.ceil(x); + } + return x; + } + if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + return 0; + } + x = webidl.util.IntegerPart(x); + x = x % Math.pow(2, bitLength); + if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) { + return x - Math.pow(2, bitLength); + } + return x; + }; + webidl.util.IntegerPart = function(n) { + const r = Math.floor(Math.abs(n)); + if (n < 0) { + return -1 * r; + } + return r; + }; + webidl.sequenceConverter = function(converter) { + return (V) => { + if (webidl.util.Type(V) !== "Object") { + throw webidl.errors.exception({ + header: "Sequence", + message: `Value of type ${webidl.util.Type(V)} is not an Object.` + }); + } + const method = V?.[Symbol.iterator]?.(); + const seq = []; + if (method === void 0 || typeof method.next !== "function") { + throw webidl.errors.exception({ + header: "Sequence", + message: "Object is not an iterator." + }); + } + while (true) { + const { done, value } = method.next(); + if (done) { + break; + } + seq.push(converter(value)); + } + return seq; + }; + }; + webidl.recordConverter = function(keyConverter, valueConverter) { + return (O) => { + if (webidl.util.Type(O) !== "Object") { + throw webidl.errors.exception({ + header: "Record", + message: `Value of type ${webidl.util.Type(O)} is not an Object.` + }); + } + const result = {}; + if (!types.isProxy(O)) { + const keys2 = Object.keys(O); + for (const key of keys2) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + return result; + } + const keys = Reflect.ownKeys(O); + for (const key of keys) { + const desc = Reflect.getOwnPropertyDescriptor(O, key); + if (desc?.enumerable) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + } + return result; + }; + }; + webidl.interfaceConverter = function(i) { + return (V, opts = {}) => { + if (opts.strict !== false && !(V instanceof i)) { + throw webidl.errors.exception({ + header: i.name, + message: `Expected ${V} to be an instance of ${i.name}.` + }); + } + return V; + }; + }; + webidl.dictionaryConverter = function(converters) { + return (dictionary) => { + const type = webidl.util.Type(dictionary); + const dict = {}; + if (type === "Null" || type === "Undefined") { + return dict; + } else if (type !== "Object") { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` + }); + } + for (const options of converters) { + const { key, defaultValue, required, converter } = options; + if (required === true) { + if (!hasOwn2(dictionary, key)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Missing required key "${key}".` + }); + } + } + let value = dictionary[key]; + const hasDefault = hasOwn2(options, "defaultValue"); + if (hasDefault && value !== null) { + value = value ?? defaultValue; + } + if (required || hasDefault || value !== void 0) { + value = converter(value); + if (options.allowedValues && !options.allowedValues.includes(value)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.` + }); + } + dict[key] = value; + } + } + return dict; + }; + }; + webidl.nullableConverter = function(converter) { + return (V) => { + if (V === null) { + return V; + } + return converter(V); + }; + }; + webidl.converters.DOMString = function(V, opts = {}) { + if (V === null && opts.legacyNullToEmptyString) { + return ""; + } + if (typeof V === "symbol") { + throw new TypeError("Could not convert argument of type symbol to string."); + } + return String(V); + }; + webidl.converters.ByteString = function(V) { + const x = webidl.converters.DOMString(V); + for (let index = 0; index < x.length; index++) { + if (x.charCodeAt(index) > 255) { + throw new TypeError( + `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.` + ); + } + } + return x; + }; + webidl.converters.USVString = toUSVString; + webidl.converters.boolean = function(V) { + const x = Boolean(V); + return x; + }; + webidl.converters.any = function(V) { + return V; + }; + webidl.converters["long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "signed"); + return x; + }; + webidl.converters["unsigned long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "unsigned"); + return x; + }; + webidl.converters["unsigned long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 32, "unsigned"); + return x; + }; + webidl.converters["unsigned short"] = function(V, opts) { + const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts); + return x; + }; + webidl.converters.ArrayBuffer = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) { + throw webidl.errors.conversionFailed({ + prefix: `${V}`, + argument: `${V}`, + types: ["ArrayBuffer"] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.TypedArray = function(V, T, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) { + throw webidl.errors.conversionFailed({ + prefix: `${T.name}`, + argument: `${V}`, + types: [T.name] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.DataView = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) { + throw webidl.errors.exception({ + header: "DataView", + message: "Object is not a DataView." + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.BufferSource = function(V, opts = {}) { + if (types.isAnyArrayBuffer(V)) { + return webidl.converters.ArrayBuffer(V, opts); + } + if (types.isTypedArray(V)) { + return webidl.converters.TypedArray(V, V.constructor); + } + if (types.isDataView(V)) { + return webidl.converters.DataView(V, opts); + } + throw new TypeError(`Could not convert ${V} to a BufferSource.`); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.ByteString + ); + webidl.converters["sequence>"] = webidl.sequenceConverter( + webidl.converters["sequence"] + ); + webidl.converters["record"] = webidl.recordConverter( + webidl.converters.ByteString, + webidl.converters.ByteString + ); + module2.exports = { + webidl + }; + } +}); + +// node_modules/undici/lib/fetch/dataURL.js +var require_dataURL = __commonJS({ + "node_modules/undici/lib/fetch/dataURL.js"(exports2, module2) { + var assert = require("assert"); + var { atob: atob2 } = require("buffer"); + var { isomorphicDecode } = require_util2(); + var encoder = new TextEncoder(); + var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/; + var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/; + var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/; + function dataURLProcessor(dataURL) { + assert(dataURL.protocol === "data:"); + let input = URLSerializer(dataURL, true); + input = input.slice(5); + const position = { position: 0 }; + let mimeType = collectASequenceOfCodePointsFast( + ",", + input, + position + ); + const mimeTypeLength = mimeType.length; + mimeType = removeASCIIWhitespace(mimeType, true, true); + if (position.position >= input.length) { + return "failure"; + } + position.position++; + const encodedBody = input.slice(mimeTypeLength + 1); + let body = stringPercentDecode(encodedBody); + if (/;(\u0020){0,}base64$/i.test(mimeType)) { + const stringBody = isomorphicDecode(body); + body = forgivingBase64(stringBody); + if (body === "failure") { + return "failure"; + } + mimeType = mimeType.slice(0, -6); + mimeType = mimeType.replace(/(\u0020)+$/, ""); + mimeType = mimeType.slice(0, -1); + } + if (mimeType.startsWith(";")) { + mimeType = "text/plain" + mimeType; + } + let mimeTypeRecord = parseMIMEType(mimeType); + if (mimeTypeRecord === "failure") { + mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII"); + } + return { mimeType: mimeTypeRecord, body }; + } + function URLSerializer(url, excludeFragment = false) { + if (!excludeFragment) { + return url.href; + } + const href = url.href; + const hashLength = url.hash.length; + return hashLength === 0 ? href : href.substring(0, href.length - hashLength); + } + function collectASequenceOfCodePoints(condition, input, position) { + let result = ""; + while (position.position < input.length && condition(input[position.position])) { + result += input[position.position]; + position.position++; + } + return result; + } + function collectASequenceOfCodePointsFast(char, input, position) { + const idx = input.indexOf(char, position.position); + const start = position.position; + if (idx === -1) { + position.position = input.length; + return input.slice(start); + } + position.position = idx; + return input.slice(start, position.position); + } + function stringPercentDecode(input) { + const bytes = encoder.encode(input); + return percentDecode(bytes); + } + function percentDecode(input) { + const output = []; + for (let i = 0; i < input.length; i++) { + const byte = input[i]; + if (byte !== 37) { + output.push(byte); + } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) { + output.push(37); + } else { + const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]); + const bytePoint = Number.parseInt(nextTwoBytes, 16); + output.push(bytePoint); + i += 2; + } + } + return Uint8Array.from(output); + } + function parseMIMEType(input) { + input = removeHTTPWhitespace(input, true, true); + const position = { position: 0 }; + const type = collectASequenceOfCodePointsFast( + "/", + input, + position + ); + if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) { + return "failure"; + } + if (position.position > input.length) { + return "failure"; + } + position.position++; + let subtype = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + subtype = removeHTTPWhitespace(subtype, false, true); + if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) { + return "failure"; + } + const typeLowercase = type.toLowerCase(); + const subtypeLowercase = subtype.toLowerCase(); + const mimeType = { + type: typeLowercase, + subtype: subtypeLowercase, + /** @type {Map} */ + parameters: /* @__PURE__ */ new Map(), + // https://mimesniff.spec.whatwg.org/#mime-type-essence + essence: `${typeLowercase}/${subtypeLowercase}` + }; + while (position.position < input.length) { + position.position++; + collectASequenceOfCodePoints( + // https://fetch.spec.whatwg.org/#http-whitespace + (char) => HTTP_WHITESPACE_REGEX.test(char), + input, + position + ); + let parameterName = collectASequenceOfCodePoints( + (char) => char !== ";" && char !== "=", + input, + position + ); + parameterName = parameterName.toLowerCase(); + if (position.position < input.length) { + if (input[position.position] === ";") { + continue; + } + position.position++; + } + if (position.position > input.length) { + break; + } + let parameterValue = null; + if (input[position.position] === '"') { + parameterValue = collectAnHTTPQuotedString(input, position, true); + collectASequenceOfCodePointsFast( + ";", + input, + position + ); + } else { + parameterValue = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + parameterValue = removeHTTPWhitespace(parameterValue, false, true); + if (parameterValue.length === 0) { + continue; + } + } + if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) { + mimeType.parameters.set(parameterName, parameterValue); + } + } + return mimeType; + } + function forgivingBase64(data) { + data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, ""); + if (data.length % 4 === 0) { + data = data.replace(/=?=$/, ""); + } + if (data.length % 4 === 1) { + return "failure"; + } + if (/[^+/0-9A-Za-z]/.test(data)) { + return "failure"; + } + const binary = atob2(data); + const bytes = new Uint8Array(binary.length); + for (let byte = 0; byte < binary.length; byte++) { + bytes[byte] = binary.charCodeAt(byte); + } + return bytes; + } + function collectAnHTTPQuotedString(input, position, extractValue) { + const positionStart = position.position; + let value = ""; + assert(input[position.position] === '"'); + position.position++; + while (true) { + value += collectASequenceOfCodePoints( + (char) => char !== '"' && char !== "\\", + input, + position + ); + if (position.position >= input.length) { + break; + } + const quoteOrBackslash = input[position.position]; + position.position++; + if (quoteOrBackslash === "\\") { + if (position.position >= input.length) { + value += "\\"; + break; + } + value += input[position.position]; + position.position++; + } else { + assert(quoteOrBackslash === '"'); + break; + } + } + if (extractValue) { + return value; + } + return input.slice(positionStart, position.position); + } + function serializeAMimeType(mimeType) { + assert(mimeType !== "failure"); + const { parameters, essence } = mimeType; + let serialization = essence; + for (let [name, value] of parameters.entries()) { + serialization += ";"; + serialization += name; + serialization += "="; + if (!HTTP_TOKEN_CODEPOINTS.test(value)) { + value = value.replace(/(\\|")/g, "\\$1"); + value = '"' + value; + value += '"'; + } + serialization += value; + } + return serialization; + } + function isHTTPWhiteSpace(char) { + return char === "\r" || char === "\n" || char === " " || char === " "; + } + function removeHTTPWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + function isASCIIWhitespace(char) { + return char === "\r" || char === "\n" || char === " " || char === "\f" || char === " "; + } + function removeASCIIWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + module2.exports = { + dataURLProcessor, + URLSerializer, + collectASequenceOfCodePoints, + collectASequenceOfCodePointsFast, + stringPercentDecode, + parseMIMEType, + collectAnHTTPQuotedString, + serializeAMimeType + }; + } +}); + +// node_modules/undici/lib/fetch/file.js +var require_file = __commonJS({ + "node_modules/undici/lib/fetch/file.js"(exports2, module2) { + "use strict"; + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { types } = require("util"); + var { kState } = require_symbols2(); + var { isBlobLike: isBlobLike2 } = require_util2(); + var { webidl } = require_webidl(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var { kEnumerableProperty } = require_util(); + var encoder = new TextEncoder(); + var File2 = class _File extends Blob2 { + constructor(fileBits, fileName, options = {}) { + webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" }); + fileBits = webidl.converters["sequence"](fileBits); + fileName = webidl.converters.USVString(fileName); + options = webidl.converters.FilePropertyBag(options); + const n = fileName; + let t = options.type; + let d; + substep: { + if (t) { + t = parseMIMEType(t); + if (t === "failure") { + t = ""; + break substep; + } + t = serializeAMimeType(t).toLowerCase(); + } + d = options.lastModified; + } + super(processBlobParts(fileBits, options), { type: t }); + this[kState] = { + name: n, + lastModified: d, + type: t + }; + } + get name() { + webidl.brandCheck(this, _File); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _File); + return this[kState].lastModified; + } + get type() { + webidl.brandCheck(this, _File); + return this[kState].type; + } + }; + var FileLike = class _FileLike { + constructor(blobLike, fileName, options = {}) { + const n = fileName; + const t = options.type; + const d = options.lastModified ?? Date.now(); + this[kState] = { + blobLike, + name: n, + type: t, + lastModified: d + }; + } + stream(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.stream(...args); + } + arrayBuffer(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.arrayBuffer(...args); + } + slice(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.slice(...args); + } + text(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.text(...args); + } + get size() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.size; + } + get type() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.type; + } + get name() { + webidl.brandCheck(this, _FileLike); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _FileLike); + return this[kState].lastModified; + } + get [Symbol.toStringTag]() { + return "File"; + } + }; + Object.defineProperties(File2.prototype, { + [Symbol.toStringTag]: { + value: "File", + configurable: true + }, + name: kEnumerableProperty, + lastModified: kEnumerableProperty + }); + webidl.converters.Blob = webidl.interfaceConverter(Blob2); + webidl.converters.BlobPart = function(V, opts) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V, opts); + } + } + return webidl.converters.USVString(V, opts); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.BlobPart + ); + webidl.converters.FilePropertyBag = webidl.dictionaryConverter([ + { + key: "lastModified", + converter: webidl.converters["long long"], + get defaultValue() { + return Date.now(); + } + }, + { + key: "type", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "endings", + converter: (value) => { + value = webidl.converters.DOMString(value); + value = value.toLowerCase(); + if (value !== "native") { + value = "transparent"; + } + return value; + }, + defaultValue: "transparent" + } + ]); + function processBlobParts(parts, options) { + const bytes = []; + for (const element of parts) { + if (typeof element === "string") { + let s = element; + if (options.endings === "native") { + s = convertLineEndingsNative(s); + } + bytes.push(encoder.encode(s)); + } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) { + if (!element.buffer) { + bytes.push(new Uint8Array(element)); + } else { + bytes.push( + new Uint8Array(element.buffer, element.byteOffset, element.byteLength) + ); + } + } else if (isBlobLike2(element)) { + bytes.push(element); + } + } + return bytes; + } + function convertLineEndingsNative(s) { + let nativeLineEnding = "\n"; + if (process.platform === "win32") { + nativeLineEnding = "\r\n"; + } + return s.replace(/\r?\n/g, nativeLineEnding); + } + function isFileLike2(object) { + return NativeFile && object instanceof NativeFile || object instanceof File2 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File"; + } + module2.exports = { File: File2, FileLike, isFileLike: isFileLike2 }; + } +}); + +// node_modules/undici/lib/fetch/formdata.js +var require_formdata = __commonJS({ + "node_modules/undici/lib/fetch/formdata.js"(exports2, module2) { + "use strict"; + var { isBlobLike: isBlobLike2, toUSVString, makeIterator } = require_util2(); + var { kState } = require_symbols2(); + var { File: UndiciFile, FileLike, isFileLike: isFileLike2 } = require_file(); + var { webidl } = require_webidl(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var File2 = NativeFile ?? UndiciFile; + var FormData2 = class _FormData { + constructor(form) { + if (form !== void 0) { + throw webidl.errors.conversionFailed({ + prefix: "FormData constructor", + argument: "Argument 1", + types: ["undefined"] + }); + } + this[kState] = []; + } + append(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + this[kState].push(entry); + } + delete(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" }); + name = webidl.converters.USVString(name); + this[kState] = this[kState].filter((entry) => entry.name !== name); + } + get(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" }); + name = webidl.converters.USVString(name); + const idx = this[kState].findIndex((entry) => entry.name === name); + if (idx === -1) { + return null; + } + return this[kState][idx].value; + } + getAll(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" }); + name = webidl.converters.USVString(name); + return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); + } + has(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" }); + name = webidl.converters.USVString(name); + return this[kState].findIndex((entry) => entry.name === name) !== -1; + } + set(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? toUSVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + const idx = this[kState].findIndex((entry2) => entry2.name === name); + if (idx !== -1) { + this[kState] = [ + ...this[kState].slice(0, idx), + entry, + ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name) + ]; + } else { + this[kState].push(entry); + } + } + entries() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key+value" + ); + } + keys() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key" + ); + } + values() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "value" + ); + } + /** + * @param {(value: string, key: string, self: FormData) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'." + ); + } + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); + } + } + }; + FormData2.prototype[Symbol.iterator] = FormData2.prototype.entries; + Object.defineProperties(FormData2.prototype, { + [Symbol.toStringTag]: { + value: "FormData", + configurable: true + } + }); + function makeEntry(name, value, filename) { + name = Buffer.from(name).toString("utf8"); + if (typeof value === "string") { + value = Buffer.from(value).toString("utf8"); + } else { + if (!isFileLike2(value)) { + value = value instanceof Blob2 ? new File2([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type }); + } + if (filename !== void 0) { + const options = { + type: value.type, + lastModified: value.lastModified + }; + value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File2([value], filename, options) : new FileLike(value, filename, options); + } + } + return { name, value }; + } + module2.exports = { FormData: FormData2 }; + } +}); + +// node_modules/undici/lib/fetch/body.js +var require_body = __commonJS({ + "node_modules/undici/lib/fetch/body.js"(exports2, module2) { + "use strict"; + var Busboy = require_main(); + var util = require_util(); + var { + ReadableStreamFrom: ReadableStreamFrom2, + isBlobLike: isBlobLike2, + isReadableStreamLike, + readableStreamClose, + createDeferredPromise, + fullyReadBody + } = require_util2(); + var { FormData: FormData2 } = require_formdata(); + var { kState } = require_symbols2(); + var { webidl } = require_webidl(); + var { DOMException: DOMException2, structuredClone } = require_constants2(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { isErrored } = require_util(); + var { isUint8Array, isArrayBuffer } = require("util/types"); + var { File: UndiciFile } = require_file(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var random; + try { + const crypto = require("node:crypto"); + random = (max) => crypto.randomInt(0, max); + } catch { + random = (max) => Math.floor(Math.random(max)); + } + var ReadableStream = globalThis.ReadableStream; + var File2 = NativeFile ?? UndiciFile; + var textEncoder = new TextEncoder(); + var textDecoder = new TextDecoder(); + function extractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + let stream = null; + if (object instanceof ReadableStream) { + stream = object; + } else if (isBlobLike2(object)) { + stream = object.stream(); + } else { + stream = new ReadableStream({ + async pull(controller) { + controller.enqueue( + typeof source === "string" ? textEncoder.encode(source) : source + ); + queueMicrotask(() => readableStreamClose(controller)); + }, + start() { + }, + type: void 0 + }); + } + assert(isReadableStreamLike(stream)); + let action = null; + let source = null; + let length = null; + let type = null; + if (typeof object === "string") { + source = object; + type = "text/plain;charset=UTF-8"; + } else if (object instanceof URLSearchParams) { + source = object.toString(); + type = "application/x-www-form-urlencoded;charset=UTF-8"; + } else if (isArrayBuffer(object)) { + source = new Uint8Array(object.slice()); + } else if (ArrayBuffer.isView(object)) { + source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)); + } else if (util.isFormDataLike(object)) { + const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`; + const prefix = `--${boundary}\r +Content-Disposition: form-data`; + const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); + const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n"); + const blobParts = []; + const rn = new Uint8Array([13, 10]); + length = 0; + let hasUnknownSizeValue = false; + for (const [name, value] of object) { + if (typeof value === "string") { + const chunk2 = textEncoder.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r +\r +${normalizeLinefeeds(value)}\r +`); + blobParts.push(chunk2); + length += chunk2.byteLength; + } else { + const chunk2 = textEncoder.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r +Content-Type: ${value.type || "application/octet-stream"}\r +\r +`); + blobParts.push(chunk2, value, rn); + if (typeof value.size === "number") { + length += chunk2.byteLength + value.size + rn.byteLength; + } else { + hasUnknownSizeValue = true; + } + } + } + const chunk = textEncoder.encode(`--${boundary}--`); + blobParts.push(chunk); + length += chunk.byteLength; + if (hasUnknownSizeValue) { + length = null; + } + source = object; + action = async function* () { + for (const part of blobParts) { + if (part.stream) { + yield* part.stream(); + } else { + yield part; + } + } + }; + type = "multipart/form-data; boundary=" + boundary; + } else if (isBlobLike2(object)) { + source = object; + length = object.size; + if (object.type) { + type = object.type; + } + } else if (typeof object[Symbol.asyncIterator] === "function") { + if (keepalive) { + throw new TypeError("keepalive"); + } + if (util.isDisturbed(object) || object.locked) { + throw new TypeError( + "Response body object should not be disturbed or locked" + ); + } + stream = object instanceof ReadableStream ? object : ReadableStreamFrom2(object); + } + if (typeof source === "string" || util.isBuffer(source)) { + length = Buffer.byteLength(source); + } + if (action != null) { + let iterator; + stream = new ReadableStream({ + async start() { + iterator = action(object)[Symbol.asyncIterator](); + }, + async pull(controller) { + const { value, done } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + if (!isErrored(stream)) { + controller.enqueue(new Uint8Array(value)); + } + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: void 0 + }); + } + const body = { stream, source, length }; + return [body, type]; + } + function safelyExtractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (object instanceof ReadableStream) { + assert(!util.isDisturbed(object), "The body has already been consumed."); + assert(!object.locked, "The stream is locked."); + } + return extractBody(object, keepalive); + } + function cloneBody(body) { + const [out1, out2] = body.stream.tee(); + const out2Clone = structuredClone(out2, { transfer: [out2] }); + const [, finalClone] = out2Clone.tee(); + body.stream = out1; + return { + stream: finalClone, + length: body.length, + source: body.source + }; + } + async function* consumeBody(body) { + if (body) { + if (isUint8Array(body)) { + yield body; + } else { + const stream = body.stream; + if (util.isDisturbed(stream)) { + throw new TypeError("The body has already been consumed."); + } + if (stream.locked) { + throw new TypeError("The stream is locked."); + } + stream[kBodyUsed] = true; + yield* stream; + } + } + } + function throwIfAborted(state) { + if (state.aborted) { + throw new DOMException2("The operation was aborted.", "AbortError"); + } + } + function bodyMixinMethods(instance) { + const methods = { + blob() { + return specConsumeBody(this, (bytes) => { + let mimeType = bodyMimeType(this); + if (mimeType === "failure") { + mimeType = ""; + } else if (mimeType) { + mimeType = serializeAMimeType(mimeType); + } + return new Blob2([bytes], { type: mimeType }); + }, instance); + }, + arrayBuffer() { + return specConsumeBody(this, (bytes) => { + return new Uint8Array(bytes).buffer; + }, instance); + }, + text() { + return specConsumeBody(this, utf8DecodeBytes, instance); + }, + json() { + return specConsumeBody(this, parseJSONFromBytes, instance); + }, + async formData() { + webidl.brandCheck(this, instance); + throwIfAborted(this[kState]); + const contentType = this.headers.get("Content-Type"); + if (/multipart\/form-data/.test(contentType)) { + const headers = {}; + for (const [key, value] of this.headers) headers[key.toLowerCase()] = value; + const responseFormData = new FormData2(); + let busboy; + try { + busboy = new Busboy({ + headers, + preservePath: true + }); + } catch (err) { + throw new DOMException2(`${err}`, "AbortError"); + } + busboy.on("field", (name, value) => { + responseFormData.append(name, value); + }); + busboy.on("file", (name, value, filename, encoding, mimeType) => { + const chunks = []; + if (encoding === "base64" || encoding.toLowerCase() === "base64") { + let base64chunk = ""; + value.on("data", (chunk) => { + base64chunk += chunk.toString().replace(/[\r\n]/gm, ""); + const end = base64chunk.length - base64chunk.length % 4; + chunks.push(Buffer.from(base64chunk.slice(0, end), "base64")); + base64chunk = base64chunk.slice(end); + }); + value.on("end", () => { + chunks.push(Buffer.from(base64chunk, "base64")); + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } else { + value.on("data", (chunk) => { + chunks.push(chunk); + }); + value.on("end", () => { + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } + }); + const busboyResolve = new Promise((resolve, reject) => { + busboy.on("finish", resolve); + busboy.on("error", (err) => reject(new TypeError(err))); + }); + if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk); + busboy.end(); + await busboyResolve; + return responseFormData; + } else if (/application\/x-www-form-urlencoded/.test(contentType)) { + let entries; + try { + let text = ""; + const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true }); + for await (const chunk of consumeBody(this[kState].body)) { + if (!isUint8Array(chunk)) { + throw new TypeError("Expected Uint8Array chunk"); + } + text += streamingDecoder.decode(chunk, { stream: true }); + } + text += streamingDecoder.decode(); + entries = new URLSearchParams(text); + } catch (err) { + throw Object.assign(new TypeError(), { cause: err }); + } + const formData = new FormData2(); + for (const [name, value] of entries) { + formData.append(name, value); + } + return formData; + } else { + await Promise.resolve(); + throwIfAborted(this[kState]); + throw webidl.errors.exception({ + header: `${instance.name}.formData`, + message: "Could not parse content as FormData." + }); + } + } + }; + return methods; + } + function mixinBody(prototype) { + Object.assign(prototype.prototype, bodyMixinMethods(prototype)); + } + async function specConsumeBody(object, convertBytesToJSValue, instance) { + webidl.brandCheck(object, instance); + throwIfAborted(object[kState]); + if (bodyUnusable(object[kState].body)) { + throw new TypeError("Body is unusable"); + } + const promise = createDeferredPromise(); + const errorSteps = (error) => promise.reject(error); + const successSteps = (data) => { + try { + promise.resolve(convertBytesToJSValue(data)); + } catch (e) { + errorSteps(e); + } + }; + if (object[kState].body == null) { + successSteps(new Uint8Array()); + return promise.promise; + } + await fullyReadBody(object[kState].body, successSteps, errorSteps); + return promise.promise; + } + function bodyUnusable(body) { + return body != null && (body.stream.locked || util.isDisturbed(body.stream)); + } + function utf8DecodeBytes(buffer) { + if (buffer.length === 0) { + return ""; + } + if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) { + buffer = buffer.subarray(3); + } + const output = textDecoder.decode(buffer); + return output; + } + function parseJSONFromBytes(bytes) { + return JSON.parse(utf8DecodeBytes(bytes)); + } + function bodyMimeType(object) { + const { headersList } = object[kState]; + const contentType = headersList.get("content-type"); + if (contentType === null) { + return "failure"; + } + return parseMIMEType(contentType); + } + module2.exports = { + extractBody, + safelyExtractBody, + cloneBody, + mixinBody + }; + } +}); + +// node_modules/undici/lib/core/request.js +var require_request = __commonJS({ + "node_modules/undici/lib/core/request.js"(exports2, module2) { + "use strict"; + var { + InvalidArgumentError, + NotSupportedError + } = require_errors(); + var assert = require("assert"); + var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols(); + var util = require_util(); + var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/; + var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; + var invalidPathRegex = /[^\u0021-\u00ff]/; + var kHandler = Symbol("handler"); + var channels = {}; + var extractBody; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.create = diagnosticsChannel.channel("undici:request:create"); + channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent"); + channels.headers = diagnosticsChannel.channel("undici:request:headers"); + channels.trailers = diagnosticsChannel.channel("undici:request:trailers"); + channels.error = diagnosticsChannel.channel("undici:request:error"); + } catch { + channels.create = { hasSubscribers: false }; + channels.bodySent = { hasSubscribers: false }; + channels.headers = { hasSubscribers: false }; + channels.trailers = { hasSubscribers: false }; + channels.error = { hasSubscribers: false }; + } + var Request = class _Request { + constructor(origin, { + path: path2, + method, + body, + headers, + query, + idempotent, + blocking, + upgrade, + headersTimeout, + bodyTimeout, + reset, + throwOnError, + expectContinue + }, handler) { + if (typeof path2 !== "string") { + throw new InvalidArgumentError("path must be a string"); + } else if (path2[0] !== "/" && !(path2.startsWith("http://") || path2.startsWith("https://")) && method !== "CONNECT") { + throw new InvalidArgumentError("path must be an absolute URL or start with a slash"); + } else if (invalidPathRegex.exec(path2) !== null) { + throw new InvalidArgumentError("invalid request path"); + } + if (typeof method !== "string") { + throw new InvalidArgumentError("method must be a string"); + } else if (tokenRegExp.exec(method) === null) { + throw new InvalidArgumentError("invalid request method"); + } + if (upgrade && typeof upgrade !== "string") { + throw new InvalidArgumentError("upgrade must be a string"); + } + if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("invalid headersTimeout"); + } + if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("invalid bodyTimeout"); + } + if (reset != null && typeof reset !== "boolean") { + throw new InvalidArgumentError("invalid reset"); + } + if (expectContinue != null && typeof expectContinue !== "boolean") { + throw new InvalidArgumentError("invalid expectContinue"); + } + this.headersTimeout = headersTimeout; + this.bodyTimeout = bodyTimeout; + this.throwOnError = throwOnError === true; + this.method = method; + this.abort = null; + if (body == null) { + this.body = null; + } else if (util.isStream(body)) { + this.body = body; + const rState = this.body._readableState; + if (!rState || !rState.autoDestroy) { + this.endHandler = function autoDestroy() { + util.destroy(this); + }; + this.body.on("end", this.endHandler); + } + this.errorHandler = (err) => { + if (this.abort) { + this.abort(err); + } else { + this.error = err; + } + }; + this.body.on("error", this.errorHandler); + } else if (util.isBuffer(body)) { + this.body = body.byteLength ? body : null; + } else if (ArrayBuffer.isView(body)) { + this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null; + } else if (body instanceof ArrayBuffer) { + this.body = body.byteLength ? Buffer.from(body) : null; + } else if (typeof body === "string") { + this.body = body.length ? Buffer.from(body) : null; + } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) { + this.body = body; + } else { + throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable"); + } + this.completed = false; + this.aborted = false; + this.upgrade = upgrade || null; + this.path = query ? util.buildURL(path2, query) : path2; + this.origin = origin; + this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; + this.blocking = blocking == null ? false : blocking; + this.reset = reset == null ? null : reset; + this.host = null; + this.contentLength = null; + this.contentType = null; + this.headers = ""; + this.expectContinue = expectContinue != null ? expectContinue : false; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(this, headers[i], headers[i + 1]); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(this, key, headers[key]); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + if (util.isFormDataLike(this.body)) { + if (util.nodeMajor < 16 || util.nodeMajor === 16 && util.nodeMinor < 8) { + throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer."); + } + if (!extractBody) { + extractBody = require_body().extractBody; + } + const [bodyStream, contentType] = extractBody(body); + if (this.contentType == null) { + this.contentType = contentType; + this.headers += `content-type: ${contentType}\r +`; + } + this.body = bodyStream.stream; + this.contentLength = bodyStream.length; + } else if (util.isBlobLike(body) && this.contentType == null && body.type) { + this.contentType = body.type; + this.headers += `content-type: ${body.type}\r +`; + } + util.validateHandler(handler, method, upgrade); + this.servername = util.getServerName(this.host); + this[kHandler] = handler; + if (channels.create.hasSubscribers) { + channels.create.publish({ request: this }); + } + } + onBodySent(chunk) { + if (this[kHandler].onBodySent) { + try { + return this[kHandler].onBodySent(chunk); + } catch (err) { + this.abort(err); + } + } + } + onRequestSent() { + if (channels.bodySent.hasSubscribers) { + channels.bodySent.publish({ request: this }); + } + if (this[kHandler].onRequestSent) { + try { + return this[kHandler].onRequestSent(); + } catch (err) { + this.abort(err); + } + } + } + onConnect(abort) { + assert(!this.aborted); + assert(!this.completed); + if (this.error) { + abort(this.error); + } else { + this.abort = abort; + return this[kHandler].onConnect(abort); + } + } + onHeaders(statusCode, headers, resume, statusText) { + assert(!this.aborted); + assert(!this.completed); + if (channels.headers.hasSubscribers) { + channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }); + } + try { + return this[kHandler].onHeaders(statusCode, headers, resume, statusText); + } catch (err) { + this.abort(err); + } + } + onData(chunk) { + assert(!this.aborted); + assert(!this.completed); + try { + return this[kHandler].onData(chunk); + } catch (err) { + this.abort(err); + return false; + } + } + onUpgrade(statusCode, headers, socket) { + assert(!this.aborted); + assert(!this.completed); + return this[kHandler].onUpgrade(statusCode, headers, socket); + } + onComplete(trailers) { + this.onFinally(); + assert(!this.aborted); + this.completed = true; + if (channels.trailers.hasSubscribers) { + channels.trailers.publish({ request: this, trailers }); + } + try { + return this[kHandler].onComplete(trailers); + } catch (err) { + this.onError(err); + } + } + onError(error) { + this.onFinally(); + if (channels.error.hasSubscribers) { + channels.error.publish({ request: this, error }); + } + if (this.aborted) { + return; + } + this.aborted = true; + return this[kHandler].onError(error); + } + onFinally() { + if (this.errorHandler) { + this.body.off("error", this.errorHandler); + this.errorHandler = null; + } + if (this.endHandler) { + this.body.off("end", this.endHandler); + this.endHandler = null; + } + } + // TODO: adjust to support H2 + addHeader(key, value) { + processHeader(this, key, value); + return this; + } + static [kHTTP1BuildRequest](origin, opts, handler) { + return new _Request(origin, opts, handler); + } + static [kHTTP2BuildRequest](origin, opts, handler) { + const headers = opts.headers; + opts = { ...opts, headers: null }; + const request = new _Request(origin, opts, handler); + request.headers = {}; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(request, headers[i], headers[i + 1], true); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(request, key, headers[key], true); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + return request; + } + static [kHTTP2CopyHeaders](raw) { + const rawHeaders = raw.split("\r\n"); + const headers = {}; + for (const header of rawHeaders) { + const [key, value] = header.split(": "); + if (value == null || value.length === 0) continue; + if (headers[key]) headers[key] += `,${value}`; + else headers[key] = value; + } + return headers; + } + }; + function processHeaderValue(key, val, skipAppend) { + if (val && typeof val === "object") { + throw new InvalidArgumentError(`invalid ${key} header`); + } + val = val != null ? `${val}` : ""; + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + return skipAppend ? val : `${key}: ${val}\r +`; + } + function processHeader(request, key, val, skipAppend = false) { + if (val && (typeof val === "object" && !Array.isArray(val))) { + throw new InvalidArgumentError(`invalid ${key} header`); + } else if (val === void 0) { + return; + } + if (request.host === null && key.length === 4 && key.toLowerCase() === "host") { + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + request.host = val; + } else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") { + request.contentLength = parseInt(val, 10); + if (!Number.isFinite(request.contentLength)) { + throw new InvalidArgumentError("invalid content-length header"); + } + } else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") { + request.contentType = val; + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); + } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") { + throw new InvalidArgumentError("invalid transfer-encoding header"); + } else if (key.length === 10 && key.toLowerCase() === "connection") { + const value = typeof val === "string" ? val.toLowerCase() : null; + if (value !== "close" && value !== "keep-alive") { + throw new InvalidArgumentError("invalid connection header"); + } else if (value === "close") { + request.reset = true; + } + } else if (key.length === 10 && key.toLowerCase() === "keep-alive") { + throw new InvalidArgumentError("invalid keep-alive header"); + } else if (key.length === 7 && key.toLowerCase() === "upgrade") { + throw new InvalidArgumentError("invalid upgrade header"); + } else if (key.length === 6 && key.toLowerCase() === "expect") { + throw new NotSupportedError("expect header not supported"); + } else if (tokenRegExp.exec(key) === null) { + throw new InvalidArgumentError("invalid header key"); + } else { + if (Array.isArray(val)) { + for (let i = 0; i < val.length; i++) { + if (skipAppend) { + if (request.headers[key]) request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`; + else request.headers[key] = processHeaderValue(key, val[i], skipAppend); + } else { + request.headers += processHeaderValue(key, val[i]); + } + } + } else { + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); + } + } + } + module2.exports = Request; + } +}); + +// node_modules/undici/lib/dispatcher.js +var require_dispatcher = __commonJS({ + "node_modules/undici/lib/dispatcher.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events"); + var Dispatcher = class extends EventEmitter { + dispatch() { + throw new Error("not implemented"); + } + close() { + throw new Error("not implemented"); + } + destroy() { + throw new Error("not implemented"); + } + }; + module2.exports = Dispatcher; + } +}); + +// node_modules/undici/lib/dispatcher-base.js +var require_dispatcher_base = __commonJS({ + "node_modules/undici/lib/dispatcher-base.js"(exports2, module2) { + "use strict"; + var Dispatcher = require_dispatcher(); + var { + ClientDestroyedError, + ClientClosedError, + InvalidArgumentError + } = require_errors(); + var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols(); + var kDestroyed = Symbol("destroyed"); + var kClosed = Symbol("closed"); + var kOnDestroyed = Symbol("onDestroyed"); + var kOnClosed = Symbol("onClosed"); + var kInterceptedDispatch = Symbol("Intercepted Dispatch"); + var DispatcherBase = class extends Dispatcher { + constructor() { + super(); + this[kDestroyed] = false; + this[kOnDestroyed] = null; + this[kClosed] = false; + this[kOnClosed] = []; + } + get destroyed() { + return this[kDestroyed]; + } + get closed() { + return this[kClosed]; + } + get interceptors() { + return this[kInterceptors]; + } + set interceptors(newInterceptors) { + if (newInterceptors) { + for (let i = newInterceptors.length - 1; i >= 0; i--) { + const interceptor = this[kInterceptors][i]; + if (typeof interceptor !== "function") { + throw new InvalidArgumentError("interceptor must be an function"); + } + } + } + this[kInterceptors] = newInterceptors; + } + close(callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.close((err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + queueMicrotask(() => callback(new ClientDestroyedError(), null)); + return; + } + if (this[kClosed]) { + if (this[kOnClosed]) { + this[kOnClosed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + this[kClosed] = true; + this[kOnClosed].push(callback); + const onClosed = () => { + const callbacks = this[kOnClosed]; + this[kOnClosed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kClose]().then(() => this.destroy()).then(() => { + queueMicrotask(onClosed); + }); + } + destroy(err, callback) { + if (typeof err === "function") { + callback = err; + err = null; + } + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.destroy(err, (err2, data) => { + return err2 ? ( + /* istanbul ignore next: should never error */ + reject(err2) + ) : resolve(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + if (this[kOnDestroyed]) { + this[kOnDestroyed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + if (!err) { + err = new ClientDestroyedError(); + } + this[kDestroyed] = true; + this[kOnDestroyed] = this[kOnDestroyed] || []; + this[kOnDestroyed].push(callback); + const onDestroyed = () => { + const callbacks = this[kOnDestroyed]; + this[kOnDestroyed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kDestroy](err).then(() => { + queueMicrotask(onDestroyed); + }); + } + [kInterceptedDispatch](opts, handler) { + if (!this[kInterceptors] || this[kInterceptors].length === 0) { + this[kInterceptedDispatch] = this[kDispatch]; + return this[kDispatch](opts, handler); + } + let dispatch = this[kDispatch].bind(this); + for (let i = this[kInterceptors].length - 1; i >= 0; i--) { + dispatch = this[kInterceptors][i](dispatch); + } + this[kInterceptedDispatch] = dispatch; + return dispatch(opts, handler); + } + dispatch(opts, handler) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + try { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object."); + } + if (this[kDestroyed] || this[kOnDestroyed]) { + throw new ClientDestroyedError(); + } + if (this[kClosed]) { + throw new ClientClosedError(); + } + return this[kInterceptedDispatch](opts, handler); + } catch (err) { + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + handler.onError(err); + return false; + } + } + }; + module2.exports = DispatcherBase; + } +}); + +// node_modules/undici/lib/core/connect.js +var require_connect = __commonJS({ + "node_modules/undici/lib/core/connect.js"(exports2, module2) { + "use strict"; + var net = require("net"); + var assert = require("assert"); + var util = require_util(); + var { InvalidArgumentError, ConnectTimeoutError } = require_errors(); + var tls; + var SessionCache; + if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) { + SessionCache = class WeakSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + this._sessionRegistry = new global.FinalizationRegistry((key) => { + if (this._sessionCache.size < this._maxCachedSessions) { + return; + } + const ref = this._sessionCache.get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this._sessionCache.delete(key); + } + }); + } + get(sessionKey) { + const ref = this._sessionCache.get(sessionKey); + return ref ? ref.deref() : null; + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + this._sessionCache.set(sessionKey, new WeakRef(session)); + this._sessionRegistry.register(session, sessionKey); + } + }; + } else { + SessionCache = class SimpleSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + } + get(sessionKey) { + return this._sessionCache.get(sessionKey); + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + if (this._sessionCache.size >= this._maxCachedSessions) { + const { value: oldestKey } = this._sessionCache.keys().next(); + this._sessionCache.delete(oldestKey); + } + this._sessionCache.set(sessionKey, session); + } + }; + } + function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) { + if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { + throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero"); + } + const options = { path: socketPath, ...opts }; + const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions); + timeout = timeout == null ? 1e4 : timeout; + allowH2 = allowH2 != null ? allowH2 : false; + return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { + let socket; + if (protocol === "https:") { + if (!tls) { + tls = require("tls"); + } + servername = servername || options.servername || util.getServerName(host) || null; + const sessionKey = servername || hostname; + const session = sessionCache.get(sessionKey) || null; + assert(sessionKey); + socket = tls.connect({ + highWaterMark: 16384, + // TLS in node can't have bigger HWM anyway... + ...options, + servername, + session, + localAddress, + // TODO(HTTP/2): Add support for h2c + ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"], + socket: httpSocket, + // upgrade socket connection + port: port || 443, + host: hostname + }); + socket.on("session", function(session2) { + sessionCache.set(sessionKey, session2); + }); + } else { + assert(!httpSocket, "httpSocket can only be sent on TLS update"); + socket = net.connect({ + highWaterMark: 64 * 1024, + // Same as nodejs fs streams. + ...options, + localAddress, + port: port || 80, + host: hostname + }); + } + if (options.keepAlive == null || options.keepAlive) { + const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay; + socket.setKeepAlive(true, keepAliveInitialDelay); + } + const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout); + socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(null, this); + } + }).on("error", function(err) { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(err); + } + }); + return socket; + }; + } + function setupTimeout(onConnectTimeout2, timeout) { + if (!timeout) { + return () => { + }; + } + let s1 = null; + let s2 = null; + const timeoutId = setTimeout(() => { + s1 = setImmediate(() => { + if (process.platform === "win32") { + s2 = setImmediate(() => onConnectTimeout2()); + } else { + onConnectTimeout2(); + } + }); + }, timeout); + return () => { + clearTimeout(timeoutId); + clearImmediate(s1); + clearImmediate(s2); + }; + } + function onConnectTimeout(socket) { + util.destroy(socket, new ConnectTimeoutError()); + } + module2.exports = buildConnector; + } +}); + +// node_modules/undici/lib/llhttp/utils.js +var require_utils2 = __commonJS({ + "node_modules/undici/lib/llhttp/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.enumToMap = void 0; + function enumToMap(obj) { + const res = {}; + Object.keys(obj).forEach((key) => { + const value = obj[key]; + if (typeof value === "number") { + res[key] = value; + } + }); + return res; + } + exports2.enumToMap = enumToMap; + } +}); + +// node_modules/undici/lib/llhttp/constants.js +var require_constants3 = __commonJS({ + "node_modules/undici/lib/llhttp/constants.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0; + var utils_1 = require_utils2(); + var ERROR; + (function(ERROR2) { + ERROR2[ERROR2["OK"] = 0] = "OK"; + ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL"; + ERROR2[ERROR2["STRICT"] = 2] = "STRICT"; + ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED"; + ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; + ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; + ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD"; + ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL"; + ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; + ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION"; + ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; + ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; + ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; + ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS"; + ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; + ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; + ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; + ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; + ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; + ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; + ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; + ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED"; + ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; + ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; + ERROR2[ERROR2["USER"] = 24] = "USER"; + })(ERROR = exports2.ERROR || (exports2.ERROR = {})); + var TYPE; + (function(TYPE2) { + TYPE2[TYPE2["BOTH"] = 0] = "BOTH"; + TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST"; + TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE"; + })(TYPE = exports2.TYPE || (exports2.TYPE = {})); + var FLAGS; + (function(FLAGS2) { + FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; + FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; + FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; + FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED"; + FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE"; + FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; + FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY"; + FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING"; + FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; + })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {})); + var LENIENT_FLAGS; + (function(LENIENT_FLAGS2) { + LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS"; + LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; + LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; + })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {})); + var METHODS; + (function(METHODS2) { + METHODS2[METHODS2["DELETE"] = 0] = "DELETE"; + METHODS2[METHODS2["GET"] = 1] = "GET"; + METHODS2[METHODS2["HEAD"] = 2] = "HEAD"; + METHODS2[METHODS2["POST"] = 3] = "POST"; + METHODS2[METHODS2["PUT"] = 4] = "PUT"; + METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT"; + METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS"; + METHODS2[METHODS2["TRACE"] = 7] = "TRACE"; + METHODS2[METHODS2["COPY"] = 8] = "COPY"; + METHODS2[METHODS2["LOCK"] = 9] = "LOCK"; + METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL"; + METHODS2[METHODS2["MOVE"] = 11] = "MOVE"; + METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND"; + METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH"; + METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH"; + METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK"; + METHODS2[METHODS2["BIND"] = 16] = "BIND"; + METHODS2[METHODS2["REBIND"] = 17] = "REBIND"; + METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND"; + METHODS2[METHODS2["ACL"] = 19] = "ACL"; + METHODS2[METHODS2["REPORT"] = 20] = "REPORT"; + METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY"; + METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT"; + METHODS2[METHODS2["MERGE"] = 23] = "MERGE"; + METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH"; + METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY"; + METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE"; + METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; + METHODS2[METHODS2["PATCH"] = 28] = "PATCH"; + METHODS2[METHODS2["PURGE"] = 29] = "PURGE"; + METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR"; + METHODS2[METHODS2["LINK"] = 31] = "LINK"; + METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK"; + METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE"; + METHODS2[METHODS2["PRI"] = 34] = "PRI"; + METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE"; + METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE"; + METHODS2[METHODS2["SETUP"] = 37] = "SETUP"; + METHODS2[METHODS2["PLAY"] = 38] = "PLAY"; + METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE"; + METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN"; + METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER"; + METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER"; + METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT"; + METHODS2[METHODS2["RECORD"] = 44] = "RECORD"; + METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH"; + })(METHODS = exports2.METHODS || (exports2.METHODS = {})); + exports2.METHODS_HTTP = [ + METHODS.DELETE, + METHODS.GET, + METHODS.HEAD, + METHODS.POST, + METHODS.PUT, + METHODS.CONNECT, + METHODS.OPTIONS, + METHODS.TRACE, + METHODS.COPY, + METHODS.LOCK, + METHODS.MKCOL, + METHODS.MOVE, + METHODS.PROPFIND, + METHODS.PROPPATCH, + METHODS.SEARCH, + METHODS.UNLOCK, + METHODS.BIND, + METHODS.REBIND, + METHODS.UNBIND, + METHODS.ACL, + METHODS.REPORT, + METHODS.MKACTIVITY, + METHODS.CHECKOUT, + METHODS.MERGE, + METHODS["M-SEARCH"], + METHODS.NOTIFY, + METHODS.SUBSCRIBE, + METHODS.UNSUBSCRIBE, + METHODS.PATCH, + METHODS.PURGE, + METHODS.MKCALENDAR, + METHODS.LINK, + METHODS.UNLINK, + METHODS.PRI, + // TODO(indutny): should we allow it with HTTP? + METHODS.SOURCE + ]; + exports2.METHODS_ICE = [ + METHODS.SOURCE + ]; + exports2.METHODS_RTSP = [ + METHODS.OPTIONS, + METHODS.DESCRIBE, + METHODS.ANNOUNCE, + METHODS.SETUP, + METHODS.PLAY, + METHODS.PAUSE, + METHODS.TEARDOWN, + METHODS.GET_PARAMETER, + METHODS.SET_PARAMETER, + METHODS.REDIRECT, + METHODS.RECORD, + METHODS.FLUSH, + // For AirPlay + METHODS.GET, + METHODS.POST + ]; + exports2.METHOD_MAP = utils_1.enumToMap(METHODS); + exports2.H_METHOD_MAP = {}; + Object.keys(exports2.METHOD_MAP).forEach((key) => { + if (/^H/.test(key)) { + exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key]; + } + }); + var FINISH; + (function(FINISH2) { + FINISH2[FINISH2["SAFE"] = 0] = "SAFE"; + FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; + FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE"; + })(FINISH = exports2.FINISH || (exports2.FINISH = {})); + exports2.ALPHA = []; + for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) { + exports2.ALPHA.push(String.fromCharCode(i)); + exports2.ALPHA.push(String.fromCharCode(i + 32)); + } + exports2.NUM_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9 + }; + exports2.HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15 + }; + exports2.NUM = [ + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9" + ]; + exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM); + exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"]; + exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]); + exports2.STRICT_URL_CHAR = [ + "!", + '"', + "$", + "%", + "&", + "'", + "(", + ")", + "*", + "+", + ",", + "-", + ".", + "/", + ":", + ";", + "<", + "=", + ">", + "@", + "[", + "\\", + "]", + "^", + "_", + "`", + "{", + "|", + "}", + "~" + ].concat(exports2.ALPHANUM); + exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]); + for (let i = 128; i <= 255; i++) { + exports2.URL_CHAR.push(i); + } + exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]); + exports2.STRICT_TOKEN = [ + "!", + "#", + "$", + "%", + "&", + "'", + "*", + "+", + "-", + ".", + "^", + "_", + "`", + "|", + "~" + ].concat(exports2.ALPHANUM); + exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]); + exports2.HEADER_CHARS = [" "]; + for (let i = 32; i <= 255; i++) { + if (i !== 127) { + exports2.HEADER_CHARS.push(i); + } + } + exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44); + exports2.MAJOR = exports2.NUM_MAP; + exports2.MINOR = exports2.MAJOR; + var HEADER_STATE; + (function(HEADER_STATE2) { + HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL"; + HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION"; + HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; + HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; + })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {})); + exports2.SPECIAL_HEADERS = { + "connection": HEADER_STATE.CONNECTION, + "content-length": HEADER_STATE.CONTENT_LENGTH, + "proxy-connection": HEADER_STATE.CONNECTION, + "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING, + "upgrade": HEADER_STATE.UPGRADE + }; + } +}); + +// node_modules/undici/lib/handler/RedirectHandler.js +var require_RedirectHandler = __commonJS({ + "node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) { + "use strict"; + var util = require_util(); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { InvalidArgumentError } = require_errors(); + var EE = require("events"); + var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; + var kBody = Symbol("body"); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + var RedirectHandler = class { + constructor(dispatch, maxRedirections, opts, handler) { + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + util.validateHandler(handler, opts.method, opts.upgrade); + this.dispatch = dispatch; + this.location = null; + this.abort = null; + this.opts = { ...opts, maxRedirections: 0 }; + this.maxRedirections = maxRedirections; + this.handler = handler; + this.history = []; + if (util.isStream(this.opts.body)) { + if (util.bodyLength(this.opts.body) === 0) { + this.opts.body.on("data", function() { + assert(false); + }); + } + if (typeof this.opts.body.readableDidRead !== "boolean") { + this.opts.body[kBodyUsed] = false; + EE.prototype.on.call(this.opts.body, "data", function() { + this[kBodyUsed] = true; + }); + } + } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } + } + onConnect(abort) { + this.abort = abort; + this.handler.onConnect(abort, { history: this.history }); + } + onUpgrade(statusCode, headers, socket) { + this.handler.onUpgrade(statusCode, headers, socket); + } + onError(error) { + this.handler.onError(error); + } + onHeaders(statusCode, headers, resume, statusText) { + this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers); + if (this.opts.origin) { + this.history.push(new URL(this.opts.path, this.opts.origin)); + } + if (!this.location) { + return this.handler.onHeaders(statusCode, headers, resume, statusText); + } + const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); + const path2 = search ? `${pathname}${search}` : pathname; + this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); + this.opts.path = path2; + this.opts.origin = origin; + this.opts.maxRedirections = 0; + this.opts.query = null; + if (statusCode === 303 && this.opts.method !== "HEAD") { + this.opts.method = "GET"; + this.opts.body = null; + } + } + onData(chunk) { + if (this.location) { + } else { + return this.handler.onData(chunk); + } + } + onComplete(trailers) { + if (this.location) { + this.location = null; + this.abort = null; + this.dispatch(this.opts, this); + } else { + this.handler.onComplete(trailers); + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) { + this.handler.onBodySent(chunk); + } + } + }; + function parseLocation(statusCode, headers) { + if (redirectableStatusCodes.indexOf(statusCode) === -1) { + return null; + } + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toString().toLowerCase() === "location") { + return headers[i + 1]; + } + } + } + function shouldRemoveHeader(header, removeContent, unknownOrigin) { + if (header.length === 4) { + return util.headerNameToString(header) === "host"; + } + if (removeContent && util.headerNameToString(header).startsWith("content-")) { + return true; + } + if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { + const name = util.headerNameToString(header); + return name === "authorization" || name === "cookie" || name === "proxy-authorization"; + } + return false; + } + function cleanRequestHeaders(headers, removeContent, unknownOrigin) { + const ret = []; + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) { + ret.push(headers[i], headers[i + 1]); + } + } + } else if (headers && typeof headers === "object") { + for (const key of Object.keys(headers)) { + if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) { + ret.push(key, headers[key]); + } + } + } else { + assert(headers == null, "headers must be an object or an array"); + } + return ret; + } + module2.exports = RedirectHandler; + } +}); + +// node_modules/undici/lib/interceptor/redirectInterceptor.js +var require_redirectInterceptor = __commonJS({ + "node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) { + "use strict"; + var RedirectHandler = require_RedirectHandler(); + function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { maxRedirections = defaultMaxRedirections } = opts; + if (!maxRedirections) { + return dispatch(opts, handler); + } + const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler); + opts = { ...opts, maxRedirections: 0 }; + return dispatch(opts, redirectHandler); + }; + }; + } + module2.exports = createRedirectInterceptor; + } +}); + +// node_modules/undici/lib/llhttp/llhttp-wasm.js +var require_llhttp_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { + module2.exports = "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"; + } +}); + +// node_modules/undici/lib/llhttp/llhttp_simd-wasm.js +var require_llhttp_simd_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { + module2.exports = "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"; + } +}); + +// node_modules/undici/lib/client.js +var require_client = __commonJS({ + "node_modules/undici/lib/client.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var net = require("net"); + var http = require("http"); + var { pipeline } = require("stream"); + var util = require_util(); + var timers = require_timers(); + var Request = require_request(); + var DispatcherBase = require_dispatcher_base(); + var { + RequestContentLengthMismatchError, + ResponseContentLengthMismatchError, + InvalidArgumentError, + RequestAbortedError, + HeadersTimeoutError, + HeadersOverflowError, + SocketError, + InformationalError, + BodyTimeoutError, + HTTPParserError, + ResponseExceededMaxSizeError, + ClientDestroyedError + } = require_errors(); + var buildConnector = require_connect(); + var { + kUrl, + kReset, + kServerName, + kClient, + kBusy, + kParser, + kConnect, + kBlocking, + kResuming, + kRunning, + kPending, + kSize, + kWriting, + kQueue, + kConnected, + kConnecting, + kNeedDrain, + kNoRef, + kKeepAliveDefaultTimeout, + kHostHeader, + kPendingIdx, + kRunningIdx, + kError, + kPipelining, + kSocket, + kKeepAliveTimeoutValue, + kMaxHeadersSize, + kKeepAliveMaxTimeout, + kKeepAliveTimeoutThreshold, + kHeadersTimeout, + kBodyTimeout, + kStrictContentLength, + kConnector, + kMaxRedirections, + kMaxRequests, + kCounter, + kClose, + kDestroy, + kDispatch, + kInterceptors, + kLocalAddress, + kMaxResponseSize, + kHTTPConnVersion, + // HTTP2 + kHost, + kHTTP2Session, + kHTTP2SessionState, + kHTTP2BuildRequest, + kHTTP2CopyHeaders, + kHTTP1BuildRequest + } = require_symbols(); + var http2; + try { + http2 = require("http2"); + } catch { + http2 = { constants: {} }; + } + var { + constants: { + HTTP2_HEADER_AUTHORITY, + HTTP2_HEADER_METHOD, + HTTP2_HEADER_PATH, + HTTP2_HEADER_SCHEME, + HTTP2_HEADER_CONTENT_LENGTH, + HTTP2_HEADER_EXPECT, + HTTP2_HEADER_STATUS + } + } = http2; + var h2ExperimentalWarned = false; + var FastBuffer = Buffer[Symbol.species]; + var kClosedResolve = Symbol("kClosedResolve"); + var channels = {}; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders"); + channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect"); + channels.connectError = diagnosticsChannel.channel("undici:client:connectError"); + channels.connected = diagnosticsChannel.channel("undici:client:connected"); + } catch { + channels.sendHeaders = { hasSubscribers: false }; + channels.beforeConnect = { hasSubscribers: false }; + channels.connectError = { hasSubscribers: false }; + channels.connected = { hasSubscribers: false }; + } + var Client = class extends DispatcherBase { + /** + * + * @param {string|URL} url + * @param {import('../types/client').Client.Options} options + */ + constructor(url, { + interceptors, + maxHeaderSize, + headersTimeout, + socketTimeout, + requestTimeout, + connectTimeout, + bodyTimeout, + idleTimeout, + keepAlive, + keepAliveTimeout, + maxKeepAliveTimeout, + keepAliveMaxTimeout, + keepAliveTimeoutThreshold, + socketPath, + pipelining, + tls, + strictContentLength, + maxCachedSessions, + maxRedirections, + connect: connect2, + maxRequestsPerClient, + localAddress, + maxResponseSize, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + // h2 + allowH2, + maxConcurrentStreams + } = {}) { + super(); + if (keepAlive !== void 0) { + throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead"); + } + if (socketTimeout !== void 0) { + throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead"); + } + if (requestTimeout !== void 0) { + throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead"); + } + if (idleTimeout !== void 0) { + throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead"); + } + if (maxKeepAliveTimeout !== void 0) { + throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead"); + } + if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) { + throw new InvalidArgumentError("invalid maxHeaderSize"); + } + if (socketPath != null && typeof socketPath !== "string") { + throw new InvalidArgumentError("invalid socketPath"); + } + if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) { + throw new InvalidArgumentError("invalid connectTimeout"); + } + if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveTimeout"); + } + if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveMaxTimeout"); + } + if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) { + throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold"); + } + if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("headersTimeout must be a positive integer or zero"); + } + if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero"); + } + if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) { + throw new InvalidArgumentError("maxRequestsPerClient must be a positive number"); + } + if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) { + throw new InvalidArgumentError("localAddress must be valid string IP address"); + } + if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) { + throw new InvalidArgumentError("maxResponseSize must be a positive number"); + } + if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) { + throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number"); + } + if (allowH2 != null && typeof allowH2 !== "boolean") { + throw new InvalidArgumentError("allowH2 must be a valid boolean value"); + } + if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) { + throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0"); + } + if (typeof connect2 !== "function") { + connect2 = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect2 + }); + } + this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })]; + this[kUrl] = util.parseOrigin(url); + this[kConnector] = connect2; + this[kSocket] = null; + this[kPipelining] = pipelining != null ? pipelining : 1; + this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize; + this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout; + this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout; + this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold; + this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]; + this[kServerName] = null; + this[kLocalAddress] = localAddress != null ? localAddress : null; + this[kResuming] = 0; + this[kNeedDrain] = 0; + this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r +`; + this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5; + this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5; + this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength; + this[kMaxRedirections] = maxRedirections; + this[kMaxRequests] = maxRequestsPerClient; + this[kClosedResolve] = null; + this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1; + this[kHTTPConnVersion] = "h1"; + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = !allowH2 ? null : { + // streams: null, // Fixed queue of streams - For future support of `push` + openStreams: 0, + // Keep track of them to decide wether or not unref the session + maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100 + // Max peerConcurrentStreams for a Node h2 server + }; + this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`; + this[kQueue] = []; + this[kRunningIdx] = 0; + this[kPendingIdx] = 0; + } + get pipelining() { + return this[kPipelining]; + } + set pipelining(value) { + this[kPipelining] = value; + resume(this, true); + } + get [kPending]() { + return this[kQueue].length - this[kPendingIdx]; + } + get [kRunning]() { + return this[kPendingIdx] - this[kRunningIdx]; + } + get [kSize]() { + return this[kQueue].length - this[kRunningIdx]; + } + get [kConnected]() { + return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed; + } + get [kBusy]() { + const socket = this[kSocket]; + return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0; + } + /* istanbul ignore: only used for test */ + [kConnect](cb) { + connect(this); + this.once("connect", cb); + } + [kDispatch](opts, handler) { + const origin = opts.origin || this[kUrl].origin; + const request = this[kHTTPConnVersion] === "h2" ? Request[kHTTP2BuildRequest](origin, opts, handler) : Request[kHTTP1BuildRequest](origin, opts, handler); + this[kQueue].push(request); + if (this[kResuming]) { + } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) { + this[kResuming] = 1; + process.nextTick(resume, this); + } else { + resume(this, true); + } + if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) { + this[kNeedDrain] = 2; + } + return this[kNeedDrain] < 2; + } + async [kClose]() { + return new Promise((resolve) => { + if (!this[kSize]) { + resolve(null); + } else { + this[kClosedResolve] = resolve; + } + }); + } + async [kDestroy](err) { + return new Promise((resolve) => { + const requests = this[kQueue].splice(this[kPendingIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + const callback = () => { + if (this[kClosedResolve]) { + this[kClosedResolve](); + this[kClosedResolve] = null; + } + resolve(); + }; + if (this[kHTTP2Session] != null) { + util.destroy(this[kHTTP2Session], err); + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = null; + } + if (!this[kSocket]) { + queueMicrotask(callback); + } else { + util.destroy(this[kSocket].on("close", callback), err); + } + resume(this); + }); + } + }; + function onHttp2SessionError(err) { + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kSocket][kError] = err; + onError(this[kClient], err); + } + function onHttp2FrameError(type, code, id) { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + if (id === 0) { + this[kSocket][kError] = err; + onError(this[kClient], err); + } + } + function onHttp2SessionEnd() { + util.destroy(this, new SocketError("other side closed")); + util.destroy(this[kSocket], new SocketError("other side closed")); + } + function onHTTP2GoAway(code) { + const client = this[kClient]; + const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`); + client[kSocket] = null; + client[kHTTP2Session] = null; + if (client.destroyed) { + assert(this[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + } else if (client[kRunning] > 0) { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit( + "disconnect", + client[kUrl], + [client], + err + ); + resume(client); + } + var constants = require_constants3(); + var createRedirectInterceptor = require_redirectInterceptor(); + var EMPTY_BUF = Buffer.alloc(0); + async function lazyllhttp() { + const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0; + let mod; + try { + mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64")); + } catch (e) { + mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64")); + } + return await WebAssembly.instantiate(mod, { + env: { + /* eslint-disable camelcase */ + wasm_on_url: (p, at, len) => { + return 0; + }, + wasm_on_status: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_begin: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageBegin() || 0; + }, + wasm_on_header_field: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_header_value: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; + }, + wasm_on_body: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_complete: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageComplete() || 0; + } + /* eslint-enable camelcase */ + } + }); + } + var llhttpInstance = null; + var llhttpPromise = lazyllhttp(); + llhttpPromise.catch(); + var currentParser = null; + var currentBufferRef = null; + var currentBufferSize = 0; + var currentBufferPtr = null; + var TIMEOUT_HEADERS = 1; + var TIMEOUT_BODY = 2; + var TIMEOUT_IDLE = 3; + var Parser = class { + constructor(client, socket, { exports: exports3 }) { + assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); + this.llhttp = exports3; + this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE); + this.client = client; + this.socket = socket; + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.statusCode = null; + this.statusText = ""; + this.upgrade = false; + this.headers = []; + this.headersSize = 0; + this.headersMaxSize = client[kMaxHeadersSize]; + this.shouldKeepAlive = false; + this.paused = false; + this.resume = this.resume.bind(this); + this.bytesRead = 0; + this.keepAlive = ""; + this.contentLength = ""; + this.connection = ""; + this.maxResponseSize = client[kMaxResponseSize]; + } + setTimeout(value, type) { + this.timeoutType = type; + if (value !== this.timeoutValue) { + timers.clearTimeout(this.timeout); + if (value) { + this.timeout = timers.setTimeout(onParserTimeout, value, this); + if (this.timeout.unref) { + this.timeout.unref(); + } + } else { + this.timeout = null; + } + this.timeoutValue = value; + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + } + resume() { + if (this.socket.destroyed || !this.paused) { + return; + } + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_resume(this.ptr); + assert(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + this.paused = false; + this.execute(this.socket.read() || EMPTY_BUF); + this.readMore(); + } + readMore() { + while (!this.paused && this.ptr) { + const chunk = this.socket.read(); + if (chunk === null) { + break; + } + this.execute(chunk); + } + } + execute(data) { + assert(this.ptr != null); + assert(currentParser == null); + assert(!this.paused); + const { socket, llhttp } = this; + if (data.length > currentBufferSize) { + if (currentBufferPtr) { + llhttp.free(currentBufferPtr); + } + currentBufferSize = Math.ceil(data.length / 4096) * 4096; + currentBufferPtr = llhttp.malloc(currentBufferSize); + } + new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data); + try { + let ret; + try { + currentBufferRef = data; + currentParser = this; + ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length); + } catch (err) { + throw err; + } finally { + currentParser = null; + currentBufferRef = null; + } + const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; + if (ret === constants.ERROR.PAUSED_UPGRADE) { + this.onUpgrade(data.slice(offset)); + } else if (ret === constants.ERROR.PAUSED) { + this.paused = true; + socket.unshift(data.slice(offset)); + } else if (ret !== constants.ERROR.OK) { + const ptr = llhttp.llhttp_get_error_reason(this.ptr); + let message = ""; + if (ptr) { + const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); + message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; + } + throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)); + } + } catch (err) { + util.destroy(socket, err); + } + } + destroy() { + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_free(this.ptr); + this.ptr = null; + timers.clearTimeout(this.timeout); + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.paused = false; + } + onStatus(buf) { + this.statusText = buf.toString(); + } + onMessageBegin() { + const { socket, client } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + } + onHeaderField(buf) { + const len = this.headers.length; + if ((len & 1) === 0) { + this.headers.push(buf); + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + } + this.trackHeader(buf.length); + } + onHeaderValue(buf) { + let len = this.headers.length; + if ((len & 1) === 1) { + this.headers.push(buf); + len += 1; + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + } + const key = this.headers[len - 2]; + if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") { + this.keepAlive += buf.toString(); + } else if (key.length === 10 && key.toString().toLowerCase() === "connection") { + this.connection += buf.toString(); + } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") { + this.contentLength += buf.toString(); + } + this.trackHeader(buf.length); + } + trackHeader(len) { + this.headersSize += len; + if (this.headersSize >= this.headersMaxSize) { + util.destroy(this.socket, new HeadersOverflowError()); + } + } + onUpgrade(head) { + const { upgrade, client, socket, headers, statusCode } = this; + assert(upgrade); + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(!socket.destroyed); + assert(socket === client[kSocket]); + assert(!this.paused); + assert(request.upgrade || request.method === "CONNECT"); + this.statusCode = null; + this.statusText = ""; + this.shouldKeepAlive = null; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + socket.unshift(head); + socket[kParser].destroy(); + socket[kParser] = null; + socket[kClient] = null; + socket[kError] = null; + socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose); + client[kSocket] = null; + client[kQueue][client[kRunningIdx]++] = null; + client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); + try { + request.onUpgrade(statusCode, headers, socket); + } catch (err) { + util.destroy(socket, err); + } + resume(client); + } + onHeadersComplete(statusCode, upgrade, shouldKeepAlive) { + const { client, socket, headers, statusText } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + assert(!this.upgrade); + assert(this.statusCode < 200); + if (statusCode === 100) { + util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket))); + return -1; + } + if (upgrade && !request.upgrade) { + util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket))); + return -1; + } + assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS); + this.statusCode = statusCode; + this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. + request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; + if (this.statusCode >= 200) { + const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]; + this.setTimeout(bodyTimeout, TIMEOUT_BODY); + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + if (request.method === "CONNECT") { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + if (upgrade) { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (this.shouldKeepAlive && client[kPipelining]) { + const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null; + if (keepAliveTimeout != null) { + const timeout = Math.min( + keepAliveTimeout - client[kKeepAliveTimeoutThreshold], + client[kKeepAliveMaxTimeout] + ); + if (timeout <= 0) { + socket[kReset] = true; + } else { + client[kKeepAliveTimeoutValue] = timeout; + } + } else { + client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]; + } + } else { + socket[kReset] = true; + } + const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false; + if (request.aborted) { + return -1; + } + if (request.method === "HEAD") { + return 1; + } + if (statusCode < 200) { + return 1; + } + if (socket[kBlocking]) { + socket[kBlocking] = false; + resume(client); + } + return pause ? constants.ERROR.PAUSED : 0; + } + onBody(buf) { + const { client, socket, statusCode, maxResponseSize } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert.strictEqual(this.timeoutType, TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + assert(statusCode >= 200); + if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) { + util.destroy(socket, new ResponseExceededMaxSizeError()); + return -1; + } + this.bytesRead += buf.length; + if (request.onData(buf) === false) { + return constants.ERROR.PAUSED; + } + } + onMessageComplete() { + const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this; + if (socket.destroyed && (!statusCode || shouldKeepAlive)) { + return -1; + } + if (upgrade) { + return; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(statusCode >= 100); + this.statusCode = null; + this.statusText = ""; + this.bytesRead = 0; + this.contentLength = ""; + this.keepAlive = ""; + this.connection = ""; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (statusCode < 200) { + return; + } + if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) { + util.destroy(socket, new ResponseContentLengthMismatchError()); + return -1; + } + request.onComplete(headers); + client[kQueue][client[kRunningIdx]++] = null; + if (socket[kWriting]) { + assert.strictEqual(client[kRunning], 0); + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (!shouldKeepAlive) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (socket[kReset] && client[kRunning] === 0) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (client[kPipelining] === 1) { + setImmediate(resume, client); + } else { + resume(client); + } + } + }; + function onParserTimeout(parser) { + const { socket, timeoutType, client } = parser; + if (timeoutType === TIMEOUT_HEADERS) { + if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { + assert(!parser.paused, "cannot be paused while waiting for headers"); + util.destroy(socket, new HeadersTimeoutError()); + } + } else if (timeoutType === TIMEOUT_BODY) { + if (!parser.paused) { + util.destroy(socket, new BodyTimeoutError()); + } + } else if (timeoutType === TIMEOUT_IDLE) { + assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); + util.destroy(socket, new InformationalError("socket idle timeout")); + } + } + function onSocketReadable() { + const { [kParser]: parser } = this; + if (parser) { + parser.readMore(); + } + } + function onSocketError(err) { + const { [kClient]: client, [kParser]: parser } = this; + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + if (client[kHTTPConnVersion] !== "h2") { + if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + this[kError] = err; + onError(this[kClient], err); + } + function onError(client, err) { + if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") { + assert(client[kPendingIdx] === client[kRunningIdx]); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + assert(client[kSize] === 0); + } + } + function onSocketEnd() { + const { [kParser]: parser, [kClient]: client } = this; + if (client[kHTTPConnVersion] !== "h2") { + if (parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this))); + } + function onSocketClose() { + const { [kClient]: client, [kParser]: parser } = this; + if (client[kHTTPConnVersion] === "h1" && parser) { + if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + } + this[kParser].destroy(); + this[kParser] = null; + } + const err = this[kError] || new SocketError("closed", util.getSocketInfo(this)); + client[kSocket] = null; + if (client.destroyed) { + assert(client[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + resume(client); + } + async function connect(client) { + assert(!client[kConnecting]); + assert(!client[kSocket]); + let { host, hostname, protocol, port } = client[kUrl]; + if (hostname[0] === "[") { + const idx = hostname.indexOf("]"); + assert(idx !== -1); + const ip = hostname.substring(1, idx); + assert(net.isIP(ip)); + hostname = ip; + } + client[kConnecting] = true; + if (channels.beforeConnect.hasSubscribers) { + channels.beforeConnect.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector] + }); + } + try { + const socket = await new Promise((resolve, reject) => { + client[kConnector]({ + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, (err, socket2) => { + if (err) { + reject(err); + } else { + resolve(socket2); + } + }); + }); + if (client.destroyed) { + util.destroy(socket.on("error", () => { + }), new ClientDestroyedError()); + return; + } + client[kConnecting] = false; + assert(socket); + const isH2 = socket.alpnProtocol === "h2"; + if (isH2) { + if (!h2ExperimentalWarned) { + h2ExperimentalWarned = true; + process.emitWarning("H2 support is experimental, expect them to change at any time.", { + code: "UNDICI-H2" + }); + } + const session = http2.connect(client[kUrl], { + createConnection: () => socket, + peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams + }); + client[kHTTPConnVersion] = "h2"; + session[kClient] = client; + session[kSocket] = socket; + session.on("error", onHttp2SessionError); + session.on("frameError", onHttp2FrameError); + session.on("end", onHttp2SessionEnd); + session.on("goaway", onHTTP2GoAway); + session.on("close", onSocketClose); + session.unref(); + client[kHTTP2Session] = session; + socket[kHTTP2Session] = session; + } else { + if (!llhttpInstance) { + llhttpInstance = await llhttpPromise; + llhttpPromise = null; + } + socket[kNoRef] = false; + socket[kWriting] = false; + socket[kReset] = false; + socket[kBlocking] = false; + socket[kParser] = new Parser(client, socket, llhttpInstance); + } + socket[kCounter] = 0; + socket[kMaxRequests] = client[kMaxRequests]; + socket[kClient] = client; + socket[kError] = null; + socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose); + client[kSocket] = socket; + if (channels.connected.hasSubscribers) { + channels.connected.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + socket + }); + } + client.emit("connect", client[kUrl], [client]); + } catch (err) { + if (client.destroyed) { + return; + } + client[kConnecting] = false; + if (channels.connectError.hasSubscribers) { + channels.connectError.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + error: err + }); + } + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { + assert(client[kRunning] === 0); + while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { + const request = client[kQueue][client[kPendingIdx]++]; + errorRequest(client, request, err); + } + } else { + onError(client, err); + } + client.emit("connectionError", client[kUrl], [client], err); + } + resume(client); + } + function emitDrain(client) { + client[kNeedDrain] = 0; + client.emit("drain", client[kUrl], [client]); + } + function resume(client, sync) { + if (client[kResuming] === 2) { + return; + } + client[kResuming] = 2; + _resume(client, sync); + client[kResuming] = 0; + if (client[kRunningIdx] > 256) { + client[kQueue].splice(0, client[kRunningIdx]); + client[kPendingIdx] -= client[kRunningIdx]; + client[kRunningIdx] = 0; + } + } + function _resume(client, sync) { + while (true) { + if (client.destroyed) { + assert(client[kPending] === 0); + return; + } + if (client[kClosedResolve] && !client[kSize]) { + client[kClosedResolve](); + client[kClosedResolve] = null; + return; + } + const socket = client[kSocket]; + if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") { + if (client[kSize] === 0) { + if (!socket[kNoRef] && socket.unref) { + socket.unref(); + socket[kNoRef] = true; + } + } else if (socket[kNoRef] && socket.ref) { + socket.ref(); + socket[kNoRef] = false; + } + if (client[kSize] === 0) { + if (socket[kParser].timeoutType !== TIMEOUT_IDLE) { + socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE); + } + } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) { + if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) { + const request2 = client[kQueue][client[kRunningIdx]]; + const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout]; + socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS); + } + } + } + if (client[kBusy]) { + client[kNeedDrain] = 2; + } else if (client[kNeedDrain] === 2) { + if (sync) { + client[kNeedDrain] = 1; + process.nextTick(emitDrain, client); + } else { + emitDrain(client); + } + continue; + } + if (client[kPending] === 0) { + return; + } + if (client[kRunning] >= (client[kPipelining] || 1)) { + return; + } + const request = client[kQueue][client[kPendingIdx]]; + if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) { + if (client[kRunning] > 0) { + return; + } + client[kServerName] = request.servername; + if (socket && socket.servername !== request.servername) { + util.destroy(socket, new InformationalError("servername changed")); + return; + } + } + if (client[kConnecting]) { + return; + } + if (!socket && !client[kHTTP2Session]) { + connect(client); + return; + } + if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) { + return; + } + if (client[kRunning] > 0 && !request.idempotent) { + return; + } + if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) { + return; + } + if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body))) { + return; + } + if (!request.aborted && write(client, request)) { + client[kPendingIdx]++; + } else { + client[kQueue].splice(client[kPendingIdx], 1); + } + } + } + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; + } + function write(client, request) { + if (client[kHTTPConnVersion] === "h2") { + writeH2(client, client[kHTTP2Session], request); + return; + } + const { body, method, path: path2, host, upgrade, headers, blocking, reset } = request; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + const bodyLength = util.bodyLength(body); + let contentLength = bodyLength; + if (contentLength === null) { + contentLength = request.contentLength; + } + if (contentLength === 0 && !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + const socket = client[kSocket]; + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); + util.destroy(socket, new InformationalError("aborted")); + }); + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + if (method === "HEAD") { + socket[kReset] = true; + } + if (upgrade || method === "CONNECT") { + socket[kReset] = true; + } + if (reset != null) { + socket[kReset] = reset; + } + if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { + socket[kReset] = true; + } + if (blocking) { + socket[kBlocking] = true; + } + let header = `${method} ${path2} HTTP/1.1\r +`; + if (typeof host === "string") { + header += `host: ${host}\r +`; + } else { + header += client[kHostHeader]; + } + if (upgrade) { + header += `connection: upgrade\r +upgrade: ${upgrade}\r +`; + } else if (client[kPipelining] && !socket[kReset]) { + header += "connection: keep-alive\r\n"; + } else { + header += "connection: close\r\n"; + } + if (headers) { + header += headers; + } + if (channels.sendHeaders.hasSubscribers) { + channels.sendHeaders.publish({ request, headers: header, socket }); + } + if (!body || bodyLength === 0) { + if (contentLength === 0) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + assert(contentLength === null, "no body must not have content length"); + socket.write(`${header}\r +`, "latin1"); + } + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(body); + socket.uncork(); + request.onBodySent(body); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload }); + } else { + writeBlob({ body, client, request, socket, contentLength, header, expectsPayload }); + } + } else if (util.isStream(body)) { + writeStream({ body, client, request, socket, contentLength, header, expectsPayload }); + } else if (util.isIterable(body)) { + writeIterable({ body, client, request, socket, contentLength, header, expectsPayload }); + } else { + assert(false); + } + return true; + } + function writeH2(client, session, request) { + const { body, method, path: path2, host, upgrade, expectContinue, signal, headers: reqHeaders } = request; + let headers; + if (typeof reqHeaders === "string") headers = Request[kHTTP2CopyHeaders](reqHeaders.trim()); + else headers = reqHeaders; + if (upgrade) { + errorRequest(client, request, new Error("Upgrade not supported for H2")); + return false; + } + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); + }); + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + let stream; + const h2State = client[kHTTP2SessionState]; + headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost]; + headers[HTTP2_HEADER_METHOD] = method; + if (method === "CONNECT") { + session.ref(); + stream = session.request(headers, { endStream: false, signal }); + if (stream.id && !stream.pending) { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + } else { + stream.once("ready", () => { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + }); + } + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) session.unref(); + }); + return true; + } + headers[HTTP2_HEADER_PATH] = path2; + headers[HTTP2_HEADER_SCHEME] = "https"; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + let contentLength = util.bodyLength(body); + if (contentLength == null) { + contentLength = request.contentLength; + } + if (contentLength === 0 || !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + if (contentLength != null) { + assert(body, "no body must not have content length"); + headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`; + } + session.ref(); + const shouldEndStream = method === "GET" || method === "HEAD"; + if (expectContinue) { + headers[HTTP2_HEADER_EXPECT] = "100-continue"; + stream = session.request(headers, { endStream: shouldEndStream, signal }); + stream.once("continue", writeBodyH2); + } else { + stream = session.request(headers, { + endStream: shouldEndStream, + signal + }); + writeBodyH2(); + } + ++h2State.openStreams; + stream.once("response", (headers2) => { + const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2; + if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), "") === false) { + stream.pause(); + } + }); + stream.once("end", () => { + request.onComplete([]); + }); + stream.on("data", (chunk) => { + if (request.onData(chunk) === false) { + stream.pause(); + } + }); + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) { + session.unref(); + } + }); + stream.once("error", function(err) { + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + stream.once("frameError", (type, code) => { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + errorRequest(client, request, err); + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + return true; + function writeBodyH2() { + if (!body) { + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + stream.cork(); + stream.write(body); + stream.uncork(); + stream.end(); + request.onBodySent(body); + request.onRequestSent(); + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ + client, + request, + contentLength, + h2stream: stream, + expectsPayload, + body: body.stream(), + socket: client[kSocket], + header: "" + }); + } else { + writeBlob({ + body, + client, + request, + contentLength, + expectsPayload, + h2stream: stream, + header: "", + socket: client[kSocket] + }); + } + } else if (util.isStream(body)) { + writeStream({ + body, + client, + request, + contentLength, + expectsPayload, + socket: client[kSocket], + h2stream: stream, + header: "" + }); + } else if (util.isIterable(body)) { + writeIterable({ + body, + client, + request, + contentLength, + expectsPayload, + header: "", + h2stream: stream, + socket: client[kSocket] + }); + } else { + assert(false); + } + } + } + function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + if (client[kHTTPConnVersion] === "h2") { + let onPipeData = function(chunk) { + request.onBodySent(chunk); + }; + const pipe = pipeline( + body, + h2stream, + (err) => { + if (err) { + util.destroy(body, err); + util.destroy(h2stream, err); + } else { + request.onRequestSent(); + } + } + ); + pipe.on("data", onPipeData); + pipe.once("end", () => { + pipe.removeListener("data", onPipeData); + util.destroy(pipe); + }); + return; + } + let finished = false; + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + const onData = function(chunk) { + if (finished) { + return; + } + try { + if (!writer.write(chunk) && this.pause) { + this.pause(); + } + } catch (err) { + util.destroy(this, err); + } + }; + const onDrain = function() { + if (finished) { + return; + } + if (body.resume) { + body.resume(); + } + }; + const onAbort = function() { + if (finished) { + return; + } + const err = new RequestAbortedError(); + queueMicrotask(() => onFinished(err)); + }; + const onFinished = function(err) { + if (finished) { + return; + } + finished = true; + assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); + socket.off("drain", onDrain).off("error", onFinished); + body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort); + if (!err) { + try { + writer.end(); + } catch (er) { + err = er; + } + } + writer.destroy(err); + if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) { + util.destroy(body, err); + } else { + util.destroy(body); + } + }; + body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort); + if (body.resume) { + body.resume(); + } + socket.on("drain", onDrain).on("error", onFinished); + } + async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength === body.size, "blob body must have content length"); + const isH2 = client[kHTTPConnVersion] === "h2"; + try { + if (contentLength != null && contentLength !== body.size) { + throw new RequestContentLengthMismatchError(); + } + const buffer = Buffer.from(await body.arrayBuffer()); + if (isH2) { + h2stream.cork(); + h2stream.write(buffer); + h2stream.uncork(); + } else { + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(buffer); + socket.uncork(); + } + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + resume(client); + } catch (err) { + util.destroy(isH2 ? h2stream : socket, err); + } + } + async function writeIterable({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve, reject) => { + assert(callback === null); + if (socket[kError]) { + reject(socket[kError]); + } else { + callback = resolve; + } + }); + if (client[kHTTPConnVersion] === "h2") { + h2stream.on("close", onDrain).on("drain", onDrain); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + const res = h2stream.write(chunk); + request.onBodySent(chunk); + if (!res) { + await waitForDrain(); + } + } + } catch (err) { + h2stream.destroy(err); + } finally { + request.onRequestSent(); + h2stream.end(); + h2stream.off("close", onDrain).off("drain", onDrain); + } + return; + } + socket.on("close", onDrain).on("drain", onDrain); + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + if (!writer.write(chunk)) { + await waitForDrain(); + } + } + writer.end(); + } catch (err) { + writer.destroy(err); + } finally { + socket.off("close", onDrain).off("drain", onDrain); + } + } + var AsyncWriter = class { + constructor({ socket, request, contentLength, client, expectsPayload, header }) { + this.socket = socket; + this.request = request; + this.contentLength = contentLength; + this.client = client; + this.bytesWritten = 0; + this.expectsPayload = expectsPayload; + this.header = header; + socket[kWriting] = true; + } + write(chunk) { + const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return false; + } + const len = Buffer.byteLength(chunk); + if (!len) { + return true; + } + if (contentLength !== null && bytesWritten + len > contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + socket.cork(); + if (bytesWritten === 0) { + if (!expectsPayload) { + socket[kReset] = true; + } + if (contentLength === null) { + socket.write(`${header}transfer-encoding: chunked\r +`, "latin1"); + } else { + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + } + } + if (contentLength === null) { + socket.write(`\r +${len.toString(16)}\r +`, "latin1"); + } + this.bytesWritten += len; + const ret = socket.write(chunk); + socket.uncork(); + request.onBodySent(chunk); + if (!ret) { + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + } + return ret; + } + end() { + const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this; + request.onRequestSent(); + socket[kWriting] = false; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return; + } + if (bytesWritten === 0) { + if (expectsPayload) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + socket.write(`${header}\r +`, "latin1"); + } + } else if (contentLength === null) { + socket.write("\r\n0\r\n\r\n", "latin1"); + } + if (contentLength !== null && bytesWritten !== contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } else { + process.emitWarning(new RequestContentLengthMismatchError()); + } + } + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + resume(client); + } + destroy(err) { + const { socket, client } = this; + socket[kWriting] = false; + if (err) { + assert(client[kRunning] <= 1, "pipeline should only contain this request"); + util.destroy(socket, err); + } + } + }; + function errorRequest(client, request, err) { + try { + request.onError(err); + assert(request.aborted); + } catch (err2) { + client.emit("error", err2); + } + } + module2.exports = Client; + } +}); + +// node_modules/undici/lib/node/fixed-queue.js +var require_fixed_queue = __commonJS({ + "node_modules/undici/lib/node/fixed-queue.js"(exports2, module2) { + "use strict"; + var kSize = 2048; + var kMask = kSize - 1; + var FixedCircularBuffer = class { + constructor() { + this.bottom = 0; + this.top = 0; + this.list = new Array(kSize); + this.next = null; + } + isEmpty() { + return this.top === this.bottom; + } + isFull() { + return (this.top + 1 & kMask) === this.bottom; + } + push(data) { + this.list[this.top] = data; + this.top = this.top + 1 & kMask; + } + shift() { + const nextItem = this.list[this.bottom]; + if (nextItem === void 0) + return null; + this.list[this.bottom] = void 0; + this.bottom = this.bottom + 1 & kMask; + return nextItem; + } + }; + module2.exports = class FixedQueue { + constructor() { + this.head = this.tail = new FixedCircularBuffer(); + } + isEmpty() { + return this.head.isEmpty(); + } + push(data) { + if (this.head.isFull()) { + this.head = this.head.next = new FixedCircularBuffer(); + } + this.head.push(data); + } + shift() { + const tail = this.tail; + const next = tail.shift(); + if (tail.isEmpty() && tail.next !== null) { + this.tail = tail.next; + } + return next; + } + }; + } +}); + +// node_modules/undici/lib/pool-stats.js +var require_pool_stats = __commonJS({ + "node_modules/undici/lib/pool-stats.js"(exports2, module2) { + var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols(); + var kPool = Symbol("pool"); + var PoolStats = class { + constructor(pool) { + this[kPool] = pool; + } + get connected() { + return this[kPool][kConnected]; + } + get free() { + return this[kPool][kFree]; + } + get pending() { + return this[kPool][kPending]; + } + get queued() { + return this[kPool][kQueued]; + } + get running() { + return this[kPool][kRunning]; + } + get size() { + return this[kPool][kSize]; + } + }; + module2.exports = PoolStats; + } +}); + +// node_modules/undici/lib/pool-base.js +var require_pool_base = __commonJS({ + "node_modules/undici/lib/pool-base.js"(exports2, module2) { + "use strict"; + var DispatcherBase = require_dispatcher_base(); + var FixedQueue = require_fixed_queue(); + var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols(); + var PoolStats = require_pool_stats(); + var kClients = Symbol("clients"); + var kNeedDrain = Symbol("needDrain"); + var kQueue = Symbol("queue"); + var kClosedResolve = Symbol("closed resolve"); + var kOnDrain = Symbol("onDrain"); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kGetDispatcher = Symbol("get dispatcher"); + var kAddClient = Symbol("add client"); + var kRemoveClient = Symbol("remove client"); + var kStats = Symbol("stats"); + var PoolBase = class extends DispatcherBase { + constructor() { + super(); + this[kQueue] = new FixedQueue(); + this[kClients] = []; + this[kQueued] = 0; + const pool = this; + this[kOnDrain] = function onDrain(origin, targets) { + const queue = pool[kQueue]; + let needDrain = false; + while (!needDrain) { + const item = queue.shift(); + if (!item) { + break; + } + pool[kQueued]--; + needDrain = !this.dispatch(item.opts, item.handler); + } + this[kNeedDrain] = needDrain; + if (!this[kNeedDrain] && pool[kNeedDrain]) { + pool[kNeedDrain] = false; + pool.emit("drain", origin, [pool, ...targets]); + } + if (pool[kClosedResolve] && queue.isEmpty()) { + Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]); + } + }; + this[kOnConnect] = (origin, targets) => { + pool.emit("connect", origin, [pool, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + pool.emit("disconnect", origin, [pool, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + pool.emit("connectionError", origin, [pool, ...targets], err); + }; + this[kStats] = new PoolStats(this); + } + get [kBusy]() { + return this[kNeedDrain]; + } + get [kConnected]() { + return this[kClients].filter((client) => client[kConnected]).length; + } + get [kFree]() { + return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length; + } + get [kPending]() { + let ret = this[kQueued]; + for (const { [kPending]: pending } of this[kClients]) { + ret += pending; + } + return ret; + } + get [kRunning]() { + let ret = 0; + for (const { [kRunning]: running } of this[kClients]) { + ret += running; + } + return ret; + } + get [kSize]() { + let ret = this[kQueued]; + for (const { [kSize]: size } of this[kClients]) { + ret += size; + } + return ret; + } + get stats() { + return this[kStats]; + } + async [kClose]() { + if (this[kQueue].isEmpty()) { + return Promise.all(this[kClients].map((c) => c.close())); + } else { + return new Promise((resolve) => { + this[kClosedResolve] = resolve; + }); + } + } + async [kDestroy](err) { + while (true) { + const item = this[kQueue].shift(); + if (!item) { + break; + } + item.handler.onError(err); + } + return Promise.all(this[kClients].map((c) => c.destroy(err))); + } + [kDispatch](opts, handler) { + const dispatcher = this[kGetDispatcher](); + if (!dispatcher) { + this[kNeedDrain] = true; + this[kQueue].push({ opts, handler }); + this[kQueued]++; + } else if (!dispatcher.dispatch(opts, handler)) { + dispatcher[kNeedDrain] = true; + this[kNeedDrain] = !this[kGetDispatcher](); + } + return !this[kNeedDrain]; + } + [kAddClient](client) { + client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].push(client); + if (this[kNeedDrain]) { + process.nextTick(() => { + if (this[kNeedDrain]) { + this[kOnDrain](client[kUrl], [this, client]); + } + }); + } + return this; + } + [kRemoveClient](client) { + client.close(() => { + const idx = this[kClients].indexOf(client); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + }); + this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true); + } + }; + module2.exports = { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + }; + } +}); + +// node_modules/undici/lib/pool.js +var require_pool = __commonJS({ + "node_modules/undici/lib/pool.js"(exports2, module2) { + "use strict"; + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kGetDispatcher + } = require_pool_base(); + var Client = require_client(); + var { + InvalidArgumentError + } = require_errors(); + var util = require_util(); + var { kUrl, kInterceptors } = require_symbols(); + var buildConnector = require_connect(); + var kOptions = Symbol("options"); + var kConnections = Symbol("connections"); + var kFactory = Symbol("factory"); + function defaultFactory(origin, opts) { + return new Client(origin, opts); + } + var Pool = class extends PoolBase { + constructor(origin, { + connections, + factory = defaultFactory, + connect, + connectTimeout, + tls, + maxCachedSessions, + socketPath, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + allowH2, + ...options + } = {}) { + super(); + if (connections != null && (!Number.isFinite(connections) || connections < 0)) { + throw new InvalidArgumentError("invalid connections"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (typeof connect !== "function") { + connect = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect + }); + } + this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : []; + this[kConnections] = connections || null; + this[kUrl] = util.parseOrigin(origin); + this[kOptions] = { ...util.deepClone(options), connect, allowH2 }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kFactory] = factory; + this.on("connectionError", (origin2, targets, error) => { + for (const target of targets) { + const idx = this[kClients].indexOf(target); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + } + }); + } + [kGetDispatcher]() { + let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]); + if (dispatcher) { + return dispatcher; + } + if (!this[kConnections] || this[kClients].length < this[kConnections]) { + dispatcher = this[kFactory](this[kUrl], this[kOptions]); + this[kAddClient](dispatcher); + } + return dispatcher; + } + }; + module2.exports = Pool; + } +}); + +// node_modules/undici/lib/balanced-pool.js +var require_balanced_pool = __commonJS({ + "node_modules/undici/lib/balanced-pool.js"(exports2, module2) { + "use strict"; + var { + BalancedPoolMissingUpstreamError, + InvalidArgumentError + } = require_errors(); + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + } = require_pool_base(); + var Pool = require_pool(); + var { kUrl, kInterceptors } = require_symbols(); + var { parseOrigin } = require_util(); + var kFactory = Symbol("factory"); + var kOptions = Symbol("options"); + var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor"); + var kCurrentWeight = Symbol("kCurrentWeight"); + var kIndex = Symbol("kIndex"); + var kWeight = Symbol("kWeight"); + var kMaxWeightPerServer = Symbol("kMaxWeightPerServer"); + var kErrorPenalty = Symbol("kErrorPenalty"); + function getGreatestCommonDivisor(a, b) { + if (b === 0) return a; + return getGreatestCommonDivisor(b, a % b); + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var BalancedPool = class extends PoolBase { + constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) { + super(); + this[kOptions] = opts; + this[kIndex] = -1; + this[kCurrentWeight] = 0; + this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100; + this[kErrorPenalty] = this[kOptions].errorPenalty || 15; + if (!Array.isArray(upstreams)) { + upstreams = [upstreams]; + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : []; + this[kFactory] = factory; + for (const upstream of upstreams) { + this.addUpstream(upstream); + } + this._updateBalancedPoolStats(); + } + addUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) { + return this; + } + const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions])); + this[kAddClient](pool); + pool.on("connect", () => { + pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]); + }); + pool.on("connectionError", () => { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + }); + pool.on("disconnect", (...args) => { + const err = args[2]; + if (err && err.code === "UND_ERR_SOCKET") { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + } + }); + for (const client of this[kClients]) { + client[kWeight] = this[kMaxWeightPerServer]; + } + this._updateBalancedPoolStats(); + return this; + } + _updateBalancedPoolStats() { + this[kGreatestCommonDivisor] = this[kClients].map((p) => p[kWeight]).reduce(getGreatestCommonDivisor, 0); + } + removeUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true); + if (pool) { + this[kRemoveClient](pool); + } + return this; + } + get upstreams() { + return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin); + } + [kGetDispatcher]() { + if (this[kClients].length === 0) { + throw new BalancedPoolMissingUpstreamError(); + } + const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true); + if (!dispatcher) { + return; + } + const allClientsBusy = this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true); + if (allClientsBusy) { + return; + } + let counter = 0; + let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]); + while (counter++ < this[kClients].length) { + this[kIndex] = (this[kIndex] + 1) % this[kClients].length; + const pool = this[kClients][this[kIndex]]; + if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) { + maxWeightIndex = this[kIndex]; + } + if (this[kIndex] === 0) { + this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]; + if (this[kCurrentWeight] <= 0) { + this[kCurrentWeight] = this[kMaxWeightPerServer]; + } + } + if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) { + return pool; + } + } + this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]; + this[kIndex] = maxWeightIndex; + return this[kClients][maxWeightIndex]; + } + }; + module2.exports = BalancedPool; + } +}); + +// node_modules/undici/lib/compat/dispatcher-weakref.js +var require_dispatcher_weakref = __commonJS({ + "node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module2) { + "use strict"; + var { kConnected, kSize } = require_symbols(); + var CompatWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value; + } + }; + var CompatFinalizer = class { + constructor(finalizer) { + this.finalizer = finalizer; + } + register(dispatcher, key) { + if (dispatcher.on) { + dispatcher.on("disconnect", () => { + if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) { + this.finalizer(key); + } + }); + } + } + }; + module2.exports = function() { + if (process.env.NODE_V8_COVERAGE) { + return { + WeakRef: CompatWeakRef, + FinalizationRegistry: CompatFinalizer + }; + } + return { + WeakRef: global.WeakRef || CompatWeakRef, + FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer + }; + }; + } +}); + +// node_modules/undici/lib/agent.js +var require_agent = __commonJS({ + "node_modules/undici/lib/agent.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError } = require_errors(); + var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); + var DispatcherBase = require_dispatcher_base(); + var Pool = require_pool(); + var Client = require_client(); + var util = require_util(); + var createRedirectInterceptor = require_redirectInterceptor(); + var { WeakRef: WeakRef2, FinalizationRegistry } = require_dispatcher_weakref()(); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kMaxRedirections = Symbol("maxRedirections"); + var kOnDrain = Symbol("onDrain"); + var kFactory = Symbol("factory"); + var kFinalizer = Symbol("finalizer"); + var kOptions = Symbol("options"); + function defaultFactory(origin, opts) { + return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts); + } + var Agent = class extends DispatcherBase { + constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { + super(); + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (!Number.isInteger(maxRedirections) || maxRedirections < 0) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (connect && typeof connect !== "function") { + connect = { ...connect }; + } + this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })]; + this[kOptions] = { ...util.deepClone(options), connect }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kMaxRedirections] = maxRedirections; + this[kFactory] = factory; + this[kClients] = /* @__PURE__ */ new Map(); + this[kFinalizer] = new FinalizationRegistry( + /* istanbul ignore next: gc is undeterministic */ + (key) => { + const ref = this[kClients].get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this[kClients].delete(key); + } + } + ); + const agent = this; + this[kOnDrain] = (origin, targets) => { + agent.emit("drain", origin, [agent, ...targets]); + }; + this[kOnConnect] = (origin, targets) => { + agent.emit("connect", origin, [agent, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + agent.emit("disconnect", origin, [agent, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + agent.emit("connectionError", origin, [agent, ...targets], err); + }; + } + get [kRunning]() { + let ret = 0; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + ret += client[kRunning]; + } + } + return ret; + } + [kDispatch](opts, handler) { + let key; + if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) { + key = String(opts.origin); + } else { + throw new InvalidArgumentError("opts.origin must be a non-empty string or URL."); + } + const ref = this[kClients].get(key); + let dispatcher = ref ? ref.deref() : null; + if (!dispatcher) { + dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].set(key, new WeakRef2(dispatcher)); + this[kFinalizer].register(dispatcher, key); + } + return dispatcher.dispatch(opts, handler); + } + async [kClose]() { + const closePromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + closePromises.push(client.close()); + } + } + await Promise.all(closePromises); + } + async [kDestroy](err) { + const destroyPromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + destroyPromises.push(client.destroy(err)); + } + } + await Promise.all(destroyPromises); + } + }; + module2.exports = Agent; + } +}); + +// node_modules/undici/lib/api/readable.js +var require_readable = __commonJS({ + "node_modules/undici/lib/api/readable.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { Readable } = require("stream"); + var { RequestAbortedError, NotSupportedError, InvalidArgumentError } = require_errors(); + var util = require_util(); + var { ReadableStreamFrom: ReadableStreamFrom2, toUSVString } = require_util(); + var Blob2; + var kConsume = Symbol("kConsume"); + var kReading = Symbol("kReading"); + var kBody = Symbol("kBody"); + var kAbort = Symbol("abort"); + var kContentType = Symbol("kContentType"); + var noop2 = () => { + }; + module2.exports = class BodyReadable extends Readable { + constructor({ + resume, + abort, + contentType = "", + highWaterMark = 64 * 1024 + // Same as nodejs fs streams. + }) { + super({ + autoDestroy: true, + read: resume, + highWaterMark + }); + this._readableState.dataEmitted = false; + this[kAbort] = abort; + this[kConsume] = null; + this[kBody] = null; + this[kContentType] = contentType; + this[kReading] = false; + } + destroy(err) { + if (this.destroyed) { + return this; + } + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (err) { + this[kAbort](); + } + return super.destroy(err); + } + emit(ev, ...args) { + if (ev === "data") { + this._readableState.dataEmitted = true; + } else if (ev === "error") { + this._readableState.errorEmitted = true; + } + return super.emit(ev, ...args); + } + on(ev, ...args) { + if (ev === "data" || ev === "readable") { + this[kReading] = true; + } + return super.on(ev, ...args); + } + addListener(ev, ...args) { + return this.on(ev, ...args); + } + off(ev, ...args) { + const ret = super.off(ev, ...args); + if (ev === "data" || ev === "readable") { + this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0; + } + return ret; + } + removeListener(ev, ...args) { + return this.off(ev, ...args); + } + push(chunk) { + if (this[kConsume] && chunk !== null && this.readableLength === 0) { + consumePush(this[kConsume], chunk); + return this[kReading] ? super.push(chunk) : true; + } + return super.push(chunk); + } + // https://fetch.spec.whatwg.org/#dom-body-text + async text() { + return consume(this, "text"); + } + // https://fetch.spec.whatwg.org/#dom-body-json + async json() { + return consume(this, "json"); + } + // https://fetch.spec.whatwg.org/#dom-body-blob + async blob() { + return consume(this, "blob"); + } + // https://fetch.spec.whatwg.org/#dom-body-arraybuffer + async arrayBuffer() { + return consume(this, "arrayBuffer"); + } + // https://fetch.spec.whatwg.org/#dom-body-formdata + async formData() { + throw new NotSupportedError(); + } + // https://fetch.spec.whatwg.org/#dom-body-bodyused + get bodyUsed() { + return util.isDisturbed(this); + } + // https://fetch.spec.whatwg.org/#dom-body-body + get body() { + if (!this[kBody]) { + this[kBody] = ReadableStreamFrom2(this); + if (this[kConsume]) { + this[kBody].getReader(); + assert(this[kBody].locked); + } + } + return this[kBody]; + } + dump(opts) { + let limit2 = opts && Number.isFinite(opts.limit) ? opts.limit : 262144; + const signal = opts && opts.signal; + if (signal) { + try { + if (typeof signal !== "object" || !("aborted" in signal)) { + throw new InvalidArgumentError("signal must be an AbortSignal"); + } + util.throwIfAborted(signal); + } catch (err) { + return Promise.reject(err); + } + } + if (this.closed) { + return Promise.resolve(null); + } + return new Promise((resolve, reject) => { + const signalListenerCleanup = signal ? util.addAbortListener(signal, () => { + this.destroy(); + }) : noop2; + this.on("close", function() { + signalListenerCleanup(); + if (signal && signal.aborted) { + reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" })); + } else { + resolve(null); + } + }).on("error", noop2).on("data", function(chunk) { + limit2 -= chunk.length; + if (limit2 <= 0) { + this.destroy(); + } + }).resume(); + }); + } + }; + function isLocked(self) { + return self[kBody] && self[kBody].locked === true || self[kConsume]; + } + function isUnusable(self) { + return util.isDisturbed(self) || isLocked(self); + } + async function consume(stream, type) { + if (isUnusable(stream)) { + throw new TypeError("unusable"); + } + assert(!stream[kConsume]); + return new Promise((resolve, reject) => { + stream[kConsume] = { + type, + stream, + resolve, + reject, + length: 0, + body: [] + }; + stream.on("error", function(err) { + consumeFinish(this[kConsume], err); + }).on("close", function() { + if (this[kConsume].body !== null) { + consumeFinish(this[kConsume], new RequestAbortedError()); + } + }); + process.nextTick(consumeStart, stream[kConsume]); + }); + } + function consumeStart(consume2) { + if (consume2.body === null) { + return; + } + const { _readableState: state } = consume2.stream; + for (const chunk of state.buffer) { + consumePush(consume2, chunk); + } + if (state.endEmitted) { + consumeEnd(this[kConsume]); + } else { + consume2.stream.on("end", function() { + consumeEnd(this[kConsume]); + }); + } + consume2.stream.resume(); + while (consume2.stream.read() != null) { + } + } + function consumeEnd(consume2) { + const { type, body, resolve, stream, length } = consume2; + try { + if (type === "text") { + resolve(toUSVString(Buffer.concat(body))); + } else if (type === "json") { + resolve(JSON.parse(Buffer.concat(body))); + } else if (type === "arrayBuffer") { + const dst = new Uint8Array(length); + let pos = 0; + for (const buf of body) { + dst.set(buf, pos); + pos += buf.byteLength; + } + resolve(dst.buffer); + } else if (type === "blob") { + if (!Blob2) { + Blob2 = require("buffer").Blob; + } + resolve(new Blob2(body, { type: stream[kContentType] })); + } + consumeFinish(consume2); + } catch (err) { + stream.destroy(err); + } + } + function consumePush(consume2, chunk) { + consume2.length += chunk.length; + consume2.body.push(chunk); + } + function consumeFinish(consume2, err) { + if (consume2.body === null) { + return; + } + if (err) { + consume2.reject(err); + } else { + consume2.resolve(); + } + consume2.type = null; + consume2.stream = null; + consume2.resolve = null; + consume2.reject = null; + consume2.length = 0; + consume2.body = null; + } + } +}); + +// node_modules/undici/lib/api/util.js +var require_util3 = __commonJS({ + "node_modules/undici/lib/api/util.js"(exports2, module2) { + var assert = require("assert"); + var { + ResponseStatusCodeError + } = require_errors(); + var { toUSVString } = require_util(); + async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) { + assert(body); + let chunks = []; + let limit2 = 0; + for await (const chunk of body) { + chunks.push(chunk); + limit2 += chunk.length; + if (limit2 > 128 * 1024) { + chunks = null; + break; + } + } + if (statusCode === 204 || !contentType || !chunks) { + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + return; + } + try { + if (contentType.startsWith("application/json")) { + const payload = JSON.parse(toUSVString(Buffer.concat(chunks))); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + if (contentType.startsWith("text/")) { + const payload = toUSVString(Buffer.concat(chunks)); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + } catch (err) { + } + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + } + module2.exports = { getResolveErrorBodyCallback }; + } +}); + +// node_modules/undici/lib/api/abort-signal.js +var require_abort_signal = __commonJS({ + "node_modules/undici/lib/api/abort-signal.js"(exports2, module2) { + var { addAbortListener } = require_util(); + var { RequestAbortedError } = require_errors(); + var kListener = Symbol("kListener"); + var kSignal = Symbol("kSignal"); + function abort(self) { + if (self.abort) { + self.abort(); + } else { + self.onError(new RequestAbortedError()); + } + } + function addSignal(self, signal) { + self[kSignal] = null; + self[kListener] = null; + if (!signal) { + return; + } + if (signal.aborted) { + abort(self); + return; + } + self[kSignal] = signal; + self[kListener] = () => { + abort(self); + }; + addAbortListener(self[kSignal], self[kListener]); + } + function removeSignal(self) { + if (!self[kSignal]) { + return; + } + if ("removeEventListener" in self[kSignal]) { + self[kSignal].removeEventListener("abort", self[kListener]); + } else { + self[kSignal].removeListener("abort", self[kListener]); + } + self[kSignal] = null; + self[kListener] = null; + } + module2.exports = { + addSignal, + removeSignal + }; + } +}); + +// node_modules/undici/lib/api/api-request.js +var require_api_request = __commonJS({ + "node_modules/undici/lib/api/api-request.js"(exports2, module2) { + "use strict"; + var Readable = require_readable(); + var { + InvalidArgumentError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var RequestHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) { + throw new InvalidArgumentError("invalid highWaterMark"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_REQUEST"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.res = null; + this.abort = null; + this.body = body; + this.trailers = {}; + this.context = null; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError; + this.highWaterMark = highWaterMark; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + const body = new Readable({ resume, abort, contentType, highWaterMark }); + this.callback = null; + this.res = body; + if (callback !== null) { + if (this.throwOnError && statusCode >= 400) { + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body, contentType, statusCode, statusMessage, headers } + ); + } else { + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + trailers: this.trailers, + opaque, + body, + context + }); + } + } + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + util.parseHeaders(trailers, this.trailers); + res.push(null); + } + onError(err) { + const { res, callback, body, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (res) { + this.res = null; + queueMicrotask(() => { + util.destroy(res, err); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function request(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + request.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + this.dispatch(opts, new RequestHandler(opts, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = request; + module2.exports.RequestHandler = RequestHandler; + } +}); + +// node_modules/undici/lib/api/api-stream.js +var require_api_stream = __commonJS({ + "node_modules/undici/lib/api/api-stream.js"(exports2, module2) { + "use strict"; + var { finished, PassThrough } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var StreamHandler = class extends AsyncResource { + constructor(opts, factory, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("invalid factory"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_STREAM"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.factory = factory; + this.callback = callback; + this.res = null; + this.abort = null; + this.context = null; + this.trailers = null; + this.body = body; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError || false; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { factory, opaque, context, callback, responseHeaders } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + this.factory = null; + let res; + if (this.throwOnError && statusCode >= 400) { + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + res = new PassThrough(); + this.callback = null; + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body: res, contentType, statusCode, statusMessage, headers } + ); + } else { + if (factory === null) { + return; + } + res = this.runInAsyncScope(factory, null, { + statusCode, + headers, + opaque, + context + }); + if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") { + throw new InvalidReturnValueError("expected Writable"); + } + finished(res, { readable: false }, (err) => { + const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this; + this.res = null; + if (err || !res2.readable) { + util.destroy(res2, err); + } + this.callback = null; + this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers }); + if (err) { + abort(); + } + }); + } + res.on("drain", resume); + this.res = res; + const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain; + return needDrain !== true; + } + onData(chunk) { + const { res } = this; + return res ? res.write(chunk) : true; + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + if (!res) { + return; + } + this.trailers = util.parseHeaders(trailers); + res.end(); + } + onError(err) { + const { res, callback, opaque, body } = this; + removeSignal(this); + this.factory = null; + if (res) { + this.res = null; + util.destroy(res, err); + } else if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function stream(opts, factory, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + stream.call(this, opts, factory, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + this.dispatch(opts, new StreamHandler(opts, factory, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = stream; + } +}); + +// node_modules/undici/lib/api/api-pipeline.js +var require_api_pipeline = __commonJS({ + "node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) { + "use strict"; + var { + Readable, + Duplex, + PassThrough + } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var kResume = Symbol("resume"); + var PipelineRequest = class extends Readable { + constructor() { + super({ autoDestroy: true }); + this[kResume] = null; + } + _read() { + const { [kResume]: resume } = this; + if (resume) { + this[kResume] = null; + resume(); + } + } + _destroy(err, callback) { + this._read(); + callback(err); + } + }; + var PipelineResponse = class extends Readable { + constructor(resume) { + super({ autoDestroy: true }); + this[kResume] = resume; + } + _read() { + this[kResume](); + } + _destroy(err, callback) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + callback(err); + } + }; + var PipelineHandler = class extends AsyncResource { + constructor(opts, handler) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof handler !== "function") { + throw new InvalidArgumentError("invalid handler"); + } + const { signal, method, opaque, onInfo, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_PIPELINE"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.handler = handler; + this.abort = null; + this.context = null; + this.onInfo = onInfo || null; + this.req = new PipelineRequest().on("error", util.nop); + this.ret = new Duplex({ + readableObjectMode: opts.objectMode, + autoDestroy: true, + read: () => { + const { body } = this; + if (body && body.resume) { + body.resume(); + } + }, + write: (chunk, encoding, callback) => { + const { req } = this; + if (req.push(chunk, encoding) || req._readableState.destroyed) { + callback(); + } else { + req[kResume] = callback; + } + }, + destroy: (err, callback) => { + const { body, req, res, ret, abort } = this; + if (!err && !ret._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (abort && err) { + abort(); + } + util.destroy(body, err); + util.destroy(req, err); + util.destroy(res, err); + removeSignal(this); + callback(err); + } + }).on("prefinish", () => { + const { req } = this; + req.push(null); + }); + this.res = null; + addSignal(this, signal); + } + onConnect(abort, context) { + const { ret, res } = this; + assert(!res, "pipeline cannot be retried"); + if (ret.destroyed) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume) { + const { opaque, handler, context } = this; + if (statusCode < 200) { + if (this.onInfo) { + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.onInfo({ statusCode, headers }); + } + return; + } + this.res = new PipelineResponse(resume); + let body; + try { + this.handler = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + body = this.runInAsyncScope(handler, null, { + statusCode, + headers, + opaque, + body: this.res, + context + }); + } catch (err) { + this.res.on("error", util.nop); + throw err; + } + if (!body || typeof body.on !== "function") { + throw new InvalidReturnValueError("expected Readable"); + } + body.on("data", (chunk) => { + const { ret, body: body2 } = this; + if (!ret.push(chunk) && body2.pause) { + body2.pause(); + } + }).on("error", (err) => { + const { ret } = this; + util.destroy(ret, err); + }).on("end", () => { + const { ret } = this; + ret.push(null); + }).on("close", () => { + const { ret } = this; + if (!ret._readableState.ended) { + util.destroy(ret, new RequestAbortedError()); + } + }); + this.body = body; + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + res.push(null); + } + onError(err) { + const { ret } = this; + this.handler = null; + util.destroy(ret, err); + } + }; + function pipeline(opts, handler) { + try { + const pipelineHandler = new PipelineHandler(opts, handler); + this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler); + return pipelineHandler.ret; + } catch (err) { + return new PassThrough().destroy(err); + } + } + module2.exports = pipeline; + } +}); + +// node_modules/undici/lib/api/api-upgrade.js +var require_api_upgrade = __commonJS({ + "node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors(); + var { AsyncResource } = require("async_hooks"); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var UpgradeHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_UPGRADE"); + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.abort = null; + this.context = null; + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = null; + } + onHeaders() { + throw new SocketError("bad upgrade", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context } = this; + assert.strictEqual(statusCode, 101); + removeSignal(this); + this.callback = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.runInAsyncScope(callback, null, null, { + headers, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function upgrade(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + upgrade.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const upgradeHandler = new UpgradeHandler(opts, callback); + this.dispatch({ + ...opts, + method: opts.method || "GET", + upgrade: opts.protocol || "Websocket" + }, upgradeHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = upgrade; + } +}); + +// node_modules/undici/lib/api/api-connect.js +var require_api_connect = __commonJS({ + "node_modules/undici/lib/api/api-connect.js"(exports2, module2) { + "use strict"; + var { AsyncResource } = require("async_hooks"); + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors(); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var ConnectHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_CONNECT"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.callback = callback; + this.abort = null; + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders() { + throw new SocketError("bad connect", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context } = this; + removeSignal(this); + this.callback = null; + let headers = rawHeaders; + if (headers != null) { + headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + } + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function connect(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + connect.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const connectHandler = new ConnectHandler(opts, callback); + this.dispatch({ ...opts, method: "CONNECT" }, connectHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = connect; + } +}); + +// node_modules/undici/lib/api/index.js +var require_api = __commonJS({ + "node_modules/undici/lib/api/index.js"(exports2, module2) { + "use strict"; + module2.exports.request = require_api_request(); + module2.exports.stream = require_api_stream(); + module2.exports.pipeline = require_api_pipeline(); + module2.exports.upgrade = require_api_upgrade(); + module2.exports.connect = require_api_connect(); + } +}); + +// node_modules/undici/lib/mock/mock-errors.js +var require_mock_errors = __commonJS({ + "node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) { + "use strict"; + var { UndiciError } = require_errors(); + var MockNotMatchedError = class _MockNotMatchedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _MockNotMatchedError); + this.name = "MockNotMatchedError"; + this.message = message || "The request does not match any registered mock dispatches"; + this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED"; + } + }; + module2.exports = { + MockNotMatchedError + }; + } +}); + +// node_modules/undici/lib/mock/mock-symbols.js +var require_mock_symbols = __commonJS({ + "node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kAgent: Symbol("agent"), + kOptions: Symbol("options"), + kFactory: Symbol("factory"), + kDispatches: Symbol("dispatches"), + kDispatchKey: Symbol("dispatch key"), + kDefaultHeaders: Symbol("default headers"), + kDefaultTrailers: Symbol("default trailers"), + kContentLength: Symbol("content length"), + kMockAgent: Symbol("mock agent"), + kMockAgentSet: Symbol("mock agent set"), + kMockAgentGet: Symbol("mock agent get"), + kMockDispatch: Symbol("mock dispatch"), + kClose: Symbol("close"), + kOriginalClose: Symbol("original agent close"), + kOrigin: Symbol("origin"), + kIsMockActive: Symbol("is mock active"), + kNetConnect: Symbol("net connect"), + kGetNetConnect: Symbol("get net connect"), + kConnected: Symbol("connected") + }; + } +}); + +// node_modules/undici/lib/mock/mock-utils.js +var require_mock_utils = __commonJS({ + "node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) { + "use strict"; + var { MockNotMatchedError } = require_mock_errors(); + var { + kDispatches, + kMockAgent, + kOriginalDispatch, + kOrigin, + kGetNetConnect + } = require_mock_symbols(); + var { buildURL, nop } = require_util(); + var { STATUS_CODES } = require("http"); + var { + types: { + isPromise + } + } = require("util"); + function matchValue(match, value) { + if (typeof match === "string") { + return match === value; + } + if (match instanceof RegExp) { + return match.test(value); + } + if (typeof match === "function") { + return match(value) === true; + } + return false; + } + function lowerCaseEntries(headers) { + return Object.fromEntries( + Object.entries(headers).map(([headerName, headerValue]) => { + return [headerName.toLocaleLowerCase(), headerValue]; + }) + ); + } + function getHeaderByName(headers, key) { + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) { + return headers[i + 1]; + } + } + return void 0; + } else if (typeof headers.get === "function") { + return headers.get(key); + } else { + return lowerCaseEntries(headers)[key.toLocaleLowerCase()]; + } + } + function buildHeadersFromArray(headers) { + const clone = headers.slice(); + const entries = []; + for (let index = 0; index < clone.length; index += 2) { + entries.push([clone[index], clone[index + 1]]); + } + return Object.fromEntries(entries); + } + function matchHeaders(mockDispatch2, headers) { + if (typeof mockDispatch2.headers === "function") { + if (Array.isArray(headers)) { + headers = buildHeadersFromArray(headers); + } + return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {}); + } + if (typeof mockDispatch2.headers === "undefined") { + return true; + } + if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") { + return false; + } + for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) { + const headerValue = getHeaderByName(headers, matchHeaderName); + if (!matchValue(matchHeaderValue, headerValue)) { + return false; + } + } + return true; + } + function safeUrl(path2) { + if (typeof path2 !== "string") { + return path2; + } + const pathSegments = path2.split("?"); + if (pathSegments.length !== 2) { + return path2; + } + const qp = new URLSearchParams(pathSegments.pop()); + qp.sort(); + return [...pathSegments, qp.toString()].join("?"); + } + function matchKey(mockDispatch2, { path: path2, method, body, headers }) { + const pathMatch = matchValue(mockDispatch2.path, path2); + const methodMatch = matchValue(mockDispatch2.method, method); + const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true; + const headersMatch = matchHeaders(mockDispatch2, headers); + return pathMatch && methodMatch && bodyMatch && headersMatch; + } + function getResponseData(data) { + if (Buffer.isBuffer(data)) { + return data; + } else if (typeof data === "object") { + return JSON.stringify(data); + } else { + return data.toString(); + } + } + function getMockDispatch(mockDispatches, key) { + const basePath = key.query ? buildURL(key.path, key.query) : key.path; + const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath; + let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path2 }) => matchValue(safeUrl(path2), resolvedPath)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`); + } + matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`); + } + return matchedMockDispatches[0]; + } + function addMockDispatch(mockDispatches, key, data) { + const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false }; + const replyData = typeof data === "function" ? { callback: data } : { ...data }; + const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } }; + mockDispatches.push(newMockDispatch); + return newMockDispatch; + } + function deleteMockDispatch(mockDispatches, key) { + const index = mockDispatches.findIndex((dispatch) => { + if (!dispatch.consumed) { + return false; + } + return matchKey(dispatch, key); + }); + if (index !== -1) { + mockDispatches.splice(index, 1); + } + } + function buildKey(opts) { + const { path: path2, method, body, headers, query } = opts; + return { + path: path2, + method, + body, + headers, + query + }; + } + function generateKeyValues(data) { + return Object.entries(data).reduce((keyValuePairs, [key, value]) => [ + ...keyValuePairs, + Buffer.from(`${key}`), + Array.isArray(value) ? value.map((x) => Buffer.from(`${x}`)) : Buffer.from(`${value}`) + ], []); + } + function getStatusText(statusCode) { + return STATUS_CODES[statusCode] || "unknown"; + } + async function getResponse(body) { + const buffers = []; + for await (const data of body) { + buffers.push(data); + } + return Buffer.concat(buffers).toString("utf8"); + } + function mockDispatch(opts, handler) { + const key = buildKey(opts); + const mockDispatch2 = getMockDispatch(this[kDispatches], key); + mockDispatch2.timesInvoked++; + if (mockDispatch2.data.callback) { + mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) }; + } + const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2; + const { timesInvoked, times } = mockDispatch2; + mockDispatch2.consumed = !persist && timesInvoked >= times; + mockDispatch2.pending = timesInvoked < times; + if (error !== null) { + deleteMockDispatch(this[kDispatches], key); + handler.onError(error); + return true; + } + if (typeof delay === "number" && delay > 0) { + setTimeout(() => { + handleReply(this[kDispatches]); + }, delay); + } else { + handleReply(this[kDispatches]); + } + function handleReply(mockDispatches, _data = data) { + const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers; + const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data; + if (isPromise(body)) { + body.then((newData) => handleReply(mockDispatches, newData)); + return; + } + const responseData = getResponseData(body); + const responseHeaders = generateKeyValues(headers); + const responseTrailers = generateKeyValues(trailers); + handler.abort = nop; + handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode)); + handler.onData(Buffer.from(responseData)); + handler.onComplete(responseTrailers); + deleteMockDispatch(mockDispatches, key); + } + function resume() { + } + return true; + } + function buildMockDispatch() { + const agent = this[kMockAgent]; + const origin = this[kOrigin]; + const originalDispatch = this[kOriginalDispatch]; + return function dispatch(opts, handler) { + if (agent.isMockActive) { + try { + mockDispatch.call(this, opts, handler); + } catch (error) { + if (error instanceof MockNotMatchedError) { + const netConnect = agent[kGetNetConnect](); + if (netConnect === false) { + throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`); + } + if (checkNetConnect(netConnect, origin)) { + originalDispatch.call(this, opts, handler); + } else { + throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`); + } + } else { + throw error; + } + } + } else { + originalDispatch.call(this, opts, handler); + } + }; + } + function checkNetConnect(netConnect, origin) { + const url = new URL(origin); + if (netConnect === true) { + return true; + } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) { + return true; + } + return false; + } + function buildMockOptions(opts) { + if (opts) { + const { agent, ...mockOptions } = opts; + return mockOptions; + } + } + module2.exports = { + getResponseData, + getMockDispatch, + addMockDispatch, + deleteMockDispatch, + buildKey, + generateKeyValues, + matchValue, + getResponse, + getStatusText, + mockDispatch, + buildMockDispatch, + checkNetConnect, + buildMockOptions, + getHeaderByName + }; + } +}); + +// node_modules/undici/lib/mock/mock-interceptor.js +var require_mock_interceptor = __commonJS({ + "node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) { + "use strict"; + var { getResponseData, buildKey, addMockDispatch } = require_mock_utils(); + var { + kDispatches, + kDispatchKey, + kDefaultHeaders, + kDefaultTrailers, + kContentLength, + kMockDispatch + } = require_mock_symbols(); + var { InvalidArgumentError } = require_errors(); + var { buildURL } = require_util(); + var MockScope = class { + constructor(mockDispatch) { + this[kMockDispatch] = mockDispatch; + } + /** + * Delay a reply by a set amount in ms. + */ + delay(waitInMs) { + if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) { + throw new InvalidArgumentError("waitInMs must be a valid integer > 0"); + } + this[kMockDispatch].delay = waitInMs; + return this; + } + /** + * For a defined reply, never mark as consumed. + */ + persist() { + this[kMockDispatch].persist = true; + return this; + } + /** + * Allow one to define a reply for a set amount of matching requests. + */ + times(repeatTimes) { + if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) { + throw new InvalidArgumentError("repeatTimes must be a valid integer > 0"); + } + this[kMockDispatch].times = repeatTimes; + return this; + } + }; + var MockInterceptor = class { + constructor(opts, mockDispatches) { + if (typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object"); + } + if (typeof opts.path === "undefined") { + throw new InvalidArgumentError("opts.path must be defined"); + } + if (typeof opts.method === "undefined") { + opts.method = "GET"; + } + if (typeof opts.path === "string") { + if (opts.query) { + opts.path = buildURL(opts.path, opts.query); + } else { + const parsedURL = new URL(opts.path, "data://"); + opts.path = parsedURL.pathname + parsedURL.search; + } + } + if (typeof opts.method === "string") { + opts.method = opts.method.toUpperCase(); + } + this[kDispatchKey] = buildKey(opts); + this[kDispatches] = mockDispatches; + this[kDefaultHeaders] = {}; + this[kDefaultTrailers] = {}; + this[kContentLength] = false; + } + createMockScopeDispatchData(statusCode, data, responseOptions = {}) { + const responseData = getResponseData(data); + const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {}; + const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }; + const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }; + return { statusCode, data, headers, trailers }; + } + validateReplyParameters(statusCode, data, responseOptions) { + if (typeof statusCode === "undefined") { + throw new InvalidArgumentError("statusCode must be defined"); + } + if (typeof data === "undefined") { + throw new InvalidArgumentError("data must be defined"); + } + if (typeof responseOptions !== "object") { + throw new InvalidArgumentError("responseOptions must be an object"); + } + } + /** + * Mock an undici request with a defined reply. + */ + reply(replyData) { + if (typeof replyData === "function") { + const wrappedDefaultsCallback = (opts) => { + const resolvedData = replyData(opts); + if (typeof resolvedData !== "object") { + throw new InvalidArgumentError("reply options callback must return an object"); + } + const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData; + this.validateReplyParameters(statusCode2, data2, responseOptions2); + return { + ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2) + }; + }; + const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback); + return new MockScope(newMockDispatch2); + } + const [statusCode, data = "", responseOptions = {}] = [...arguments]; + this.validateReplyParameters(statusCode, data, responseOptions); + const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions); + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData); + return new MockScope(newMockDispatch); + } + /** + * Mock an undici request with a defined error. + */ + replyWithError(error) { + if (typeof error === "undefined") { + throw new InvalidArgumentError("error must be defined"); + } + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error }); + return new MockScope(newMockDispatch); + } + /** + * Set default reply headers on the interceptor for subsequent replies + */ + defaultReplyHeaders(headers) { + if (typeof headers === "undefined") { + throw new InvalidArgumentError("headers must be defined"); + } + this[kDefaultHeaders] = headers; + return this; + } + /** + * Set default reply trailers on the interceptor for subsequent replies + */ + defaultReplyTrailers(trailers) { + if (typeof trailers === "undefined") { + throw new InvalidArgumentError("trailers must be defined"); + } + this[kDefaultTrailers] = trailers; + return this; + } + /** + * Set reply content length header for replies on the interceptor + */ + replyContentLength() { + this[kContentLength] = true; + return this; + } + }; + module2.exports.MockInterceptor = MockInterceptor; + module2.exports.MockScope = MockScope; + } +}); + +// node_modules/undici/lib/mock/mock-client.js +var require_mock_client = __commonJS({ + "node_modules/undici/lib/mock/mock-client.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Client = require_client(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockClient = class extends Client { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockClient; + } +}); + +// node_modules/undici/lib/mock/mock-pool.js +var require_mock_pool = __commonJS({ + "node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Pool = require_pool(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockPool = class extends Pool { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockPool; + } +}); + +// node_modules/undici/lib/mock/pluralizer.js +var require_pluralizer = __commonJS({ + "node_modules/undici/lib/mock/pluralizer.js"(exports2, module2) { + "use strict"; + var singulars = { + pronoun: "it", + is: "is", + was: "was", + this: "this" + }; + var plurals = { + pronoun: "they", + is: "are", + was: "were", + this: "these" + }; + module2.exports = class Pluralizer { + constructor(singular, plural) { + this.singular = singular; + this.plural = plural; + } + pluralize(count) { + const one = count === 1; + const keys = one ? singulars : plurals; + const noun = one ? this.singular : this.plural; + return { ...keys, count, noun }; + } + }; + } +}); + +// node_modules/undici/lib/mock/pending-interceptors-formatter.js +var require_pending_interceptors_formatter = __commonJS({ + "node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module2) { + "use strict"; + var { Transform } = require("stream"); + var { Console } = require("console"); + module2.exports = class PendingInterceptorsFormatter { + constructor({ disableColors } = {}) { + this.transform = new Transform({ + transform(chunk, _enc, cb) { + cb(null, chunk); + } + }); + this.logger = new Console({ + stdout: this.transform, + inspectOptions: { + colors: !disableColors && !process.env.CI + } + }); + } + format(pendingInterceptors) { + const withPrettyHeaders = pendingInterceptors.map( + ({ method, path: path2, data: { statusCode }, persist, times, timesInvoked, origin }) => ({ + Method: method, + Origin: origin, + Path: path2, + "Status code": statusCode, + Persistent: persist ? "\u2705" : "\u274C", + Invocations: timesInvoked, + Remaining: persist ? Infinity : times - timesInvoked + }) + ); + this.logger.table(withPrettyHeaders); + return this.transform.read().toString(); + } + }; + } +}); + +// node_modules/undici/lib/mock/mock-agent.js +var require_mock_agent = __commonJS({ + "node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) { + "use strict"; + var { kClients } = require_symbols(); + var Agent = require_agent(); + var { + kAgent, + kMockAgentSet, + kMockAgentGet, + kDispatches, + kIsMockActive, + kNetConnect, + kGetNetConnect, + kOptions, + kFactory + } = require_mock_symbols(); + var MockClient = require_mock_client(); + var MockPool = require_mock_pool(); + var { matchValue, buildMockOptions } = require_mock_utils(); + var { InvalidArgumentError, UndiciError } = require_errors(); + var Dispatcher = require_dispatcher(); + var Pluralizer = require_pluralizer(); + var PendingInterceptorsFormatter = require_pending_interceptors_formatter(); + var FakeWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value; + } + }; + var MockAgent = class extends Dispatcher { + constructor(opts) { + super(opts); + this[kNetConnect] = true; + this[kIsMockActive] = true; + if (opts && opts.agent && typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + const agent = opts && opts.agent ? opts.agent : new Agent(opts); + this[kAgent] = agent; + this[kClients] = agent[kClients]; + this[kOptions] = buildMockOptions(opts); + } + get(origin) { + let dispatcher = this[kMockAgentGet](origin); + if (!dispatcher) { + dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + } + return dispatcher; + } + dispatch(opts, handler) { + this.get(opts.origin); + return this[kAgent].dispatch(opts, handler); + } + async close() { + await this[kAgent].close(); + this[kClients].clear(); + } + deactivate() { + this[kIsMockActive] = false; + } + activate() { + this[kIsMockActive] = true; + } + enableNetConnect(matcher) { + if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) { + if (Array.isArray(this[kNetConnect])) { + this[kNetConnect].push(matcher); + } else { + this[kNetConnect] = [matcher]; + } + } else if (typeof matcher === "undefined") { + this[kNetConnect] = true; + } else { + throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp."); + } + } + disableNetConnect() { + this[kNetConnect] = false; + } + // This is required to bypass issues caused by using global symbols - see: + // https://github.com/nodejs/undici/issues/1447 + get isMockActive() { + return this[kIsMockActive]; + } + [kMockAgentSet](origin, dispatcher) { + this[kClients].set(origin, new FakeWeakRef(dispatcher)); + } + [kFactory](origin) { + const mockOptions = Object.assign({ agent: this }, this[kOptions]); + return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions); + } + [kMockAgentGet](origin) { + const ref = this[kClients].get(origin); + if (ref) { + return ref.deref(); + } + if (typeof origin !== "string") { + const dispatcher = this[kFactory]("http://localhost:9999"); + this[kMockAgentSet](origin, dispatcher); + return dispatcher; + } + for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) { + const nonExplicitDispatcher = nonExplicitRef.deref(); + if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) { + const dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]; + return dispatcher; + } + } + } + [kGetNetConnect]() { + return this[kNetConnect]; + } + pendingInterceptors() { + const mockAgentClients = this[kClients]; + return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending); + } + assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) { + const pending = this.pendingInterceptors(); + if (pending.length === 0) { + return; + } + const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length); + throw new UndiciError(` +${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending: + +${pendingInterceptorsFormatter.format(pending)} +`.trim()); + } + }; + module2.exports = MockAgent; + } +}); + +// node_modules/undici/lib/proxy-agent.js +var require_proxy_agent = __commonJS({ + "node_modules/undici/lib/proxy-agent.js"(exports2, module2) { + "use strict"; + var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols(); + var { URL: URL2 } = require("url"); + var Agent = require_agent(); + var Pool = require_pool(); + var DispatcherBase = require_dispatcher_base(); + var { InvalidArgumentError, RequestAbortedError } = require_errors(); + var buildConnector = require_connect(); + var kAgent = Symbol("proxy agent"); + var kClient = Symbol("proxy client"); + var kProxyHeaders = Symbol("proxy headers"); + var kRequestTls = Symbol("request tls settings"); + var kProxyTls = Symbol("proxy tls settings"); + var kConnectEndpoint = Symbol("connect endpoint function"); + function defaultProtocolPort(protocol) { + return protocol === "https:" ? 443 : 80; + } + function buildProxyOptions(opts) { + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + return { + uri: opts.uri, + protocol: opts.protocol || "https" + }; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var ProxyAgent = class extends DispatcherBase { + constructor(opts) { + super(opts); + this[kProxy] = buildProxyOptions(opts); + this[kAgent] = new Agent(opts); + this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : []; + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + const { clientFactory = defaultFactory } = opts; + if (typeof clientFactory !== "function") { + throw new InvalidArgumentError("Proxy opts.clientFactory must be a function."); + } + this[kRequestTls] = opts.requestTls; + this[kProxyTls] = opts.proxyTls; + this[kProxyHeaders] = opts.headers || {}; + const resolvedUrl = new URL2(opts.uri); + const { origin, port, host, username, password } = resolvedUrl; + if (opts.auth && opts.token) { + throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token"); + } else if (opts.auth) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`; + } else if (opts.token) { + this[kProxyHeaders]["proxy-authorization"] = opts.token; + } else if (username && password) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`; + } + const connect = buildConnector({ ...opts.proxyTls }); + this[kConnectEndpoint] = buildConnector({ ...opts.requestTls }); + this[kClient] = clientFactory(resolvedUrl, { connect }); + this[kAgent] = new Agent({ + ...opts, + connect: async (opts2, callback) => { + let requestedHost = opts2.host; + if (!opts2.port) { + requestedHost += `:${defaultProtocolPort(opts2.protocol)}`; + } + try { + const { socket, statusCode } = await this[kClient].connect({ + origin, + port, + path: requestedHost, + signal: opts2.signal, + headers: { + ...this[kProxyHeaders], + host + } + }); + if (statusCode !== 200) { + socket.on("error", () => { + }).destroy(); + callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`)); + } + if (opts2.protocol !== "https:") { + callback(null, socket); + return; + } + let servername; + if (this[kRequestTls]) { + servername = this[kRequestTls].servername; + } else { + servername = opts2.servername; + } + this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback); + } catch (err) { + callback(err); + } + } + }); + } + dispatch(opts, handler) { + const { host } = new URL2(opts.origin); + const headers = buildHeaders2(opts.headers); + throwIfProxyAuthIsSent(headers); + return this[kAgent].dispatch( + { + ...opts, + headers: { + ...headers, + host + } + }, + handler + ); + } + async [kClose]() { + await this[kAgent].close(); + await this[kClient].close(); + } + async [kDestroy]() { + await this[kAgent].destroy(); + await this[kClient].destroy(); + } + }; + function buildHeaders2(headers) { + if (Array.isArray(headers)) { + const headersPair = {}; + for (let i = 0; i < headers.length; i += 2) { + headersPair[headers[i]] = headers[i + 1]; + } + return headersPair; + } + return headers; + } + function throwIfProxyAuthIsSent(headers) { + const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization"); + if (existProxyAuth) { + throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor"); + } + } + module2.exports = ProxyAgent; + } +}); + +// node_modules/undici/lib/handler/RetryHandler.js +var require_RetryHandler = __commonJS({ + "node_modules/undici/lib/handler/RetryHandler.js"(exports2, module2) { + var assert = require("assert"); + var { kRetryHandlerDefaultRetry } = require_symbols(); + var { RequestRetryError } = require_errors(); + var { isDisturbed, parseHeaders, parseRangeHeader } = require_util(); + function calculateRetryAfterHeader(retryAfter) { + const current = Date.now(); + const diff = new Date(retryAfter).getTime() - current; + return diff; + } + var RetryHandler = class _RetryHandler { + constructor(opts, handlers) { + const { retryOptions, ...dispatchOpts } = opts; + const { + // Retry scoped + retry: retryFn, + maxRetries, + maxTimeout, + minTimeout, + timeoutFactor, + // Response scoped + methods, + errorCodes, + retryAfter, + statusCodes + } = retryOptions ?? {}; + this.dispatch = handlers.dispatch; + this.handler = handlers.handler; + this.opts = dispatchOpts; + this.abort = null; + this.aborted = false; + this.retryOpts = { + retry: retryFn ?? _RetryHandler[kRetryHandlerDefaultRetry], + retryAfter: retryAfter ?? true, + maxTimeout: maxTimeout ?? 30 * 1e3, + // 30s, + timeout: minTimeout ?? 500, + // .5s + timeoutFactor: timeoutFactor ?? 2, + maxRetries: maxRetries ?? 5, + // What errors we should retry + methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"], + // Indicates which errors to retry + statusCodes: statusCodes ?? [500, 502, 503, 504, 429], + // List of errors to retry + errorCodes: errorCodes ?? [ + "ECONNRESET", + "ECONNREFUSED", + "ENOTFOUND", + "ENETDOWN", + "ENETUNREACH", + "EHOSTDOWN", + "EHOSTUNREACH", + "EPIPE" + ] + }; + this.retryCount = 0; + this.start = 0; + this.end = null; + this.etag = null; + this.resume = null; + this.handler.onConnect((reason) => { + this.aborted = true; + if (this.abort) { + this.abort(reason); + } else { + this.reason = reason; + } + }); + } + onRequestSent() { + if (this.handler.onRequestSent) { + this.handler.onRequestSent(); + } + } + onUpgrade(statusCode, headers, socket) { + if (this.handler.onUpgrade) { + this.handler.onUpgrade(statusCode, headers, socket); + } + } + onConnect(abort) { + if (this.aborted) { + abort(this.reason); + } else { + this.abort = abort; + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) return this.handler.onBodySent(chunk); + } + static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) { + const { statusCode, code, headers } = err; + const { method, retryOptions } = opts; + const { + maxRetries, + timeout, + maxTimeout, + timeoutFactor, + statusCodes, + errorCodes, + methods + } = retryOptions; + let { counter, currentTimeout } = state; + currentTimeout = currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout; + if (code && code !== "UND_ERR_REQ_RETRY" && code !== "UND_ERR_SOCKET" && !errorCodes.includes(code)) { + cb(err); + return; + } + if (Array.isArray(methods) && !methods.includes(method)) { + cb(err); + return; + } + if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) { + cb(err); + return; + } + if (counter > maxRetries) { + cb(err); + return; + } + let retryAfterHeader = headers != null && headers["retry-after"]; + if (retryAfterHeader) { + retryAfterHeader = Number(retryAfterHeader); + retryAfterHeader = isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3; + } + const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout); + state.currentTimeout = retryTimeout; + setTimeout(() => cb(null), retryTimeout); + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const headers = parseHeaders(rawHeaders); + this.retryCount += 1; + if (statusCode >= 300) { + this.abort( + new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.resume != null) { + this.resume = null; + if (statusCode !== 206) { + return true; + } + const contentRange = parseRangeHeader(headers["content-range"]); + if (!contentRange) { + this.abort( + new RequestRetryError("Content-Range mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.etag != null && this.etag !== headers.etag) { + this.abort( + new RequestRetryError("ETag mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + const { start, size, end = size } = contentRange; + assert(this.start === start, "content-range mismatch"); + assert(this.end == null || this.end === end, "content-range mismatch"); + this.resume = resume; + return true; + } + if (this.end == null) { + if (statusCode === 206) { + const range = parseRangeHeader(headers["content-range"]); + if (range == null) { + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const { start, size, end = size } = range; + assert( + start != null && Number.isFinite(start) && this.start !== start, + "content-range mismatch" + ); + assert(Number.isFinite(start)); + assert( + end != null && Number.isFinite(end) && this.end !== end, + "invalid content-length" + ); + this.start = start; + this.end = end; + } + if (this.end == null) { + const contentLength = headers["content-length"]; + this.end = contentLength != null ? Number(contentLength) : null; + } + assert(Number.isFinite(this.start)); + assert( + this.end == null || Number.isFinite(this.end), + "invalid content-length" + ); + this.resume = resume; + this.etag = headers.etag != null ? headers.etag : null; + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const err = new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }); + this.abort(err); + return false; + } + onData(chunk) { + this.start += chunk.length; + return this.handler.onData(chunk); + } + onComplete(rawTrailers) { + this.retryCount = 0; + return this.handler.onComplete(rawTrailers); + } + onError(err) { + if (this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err); + } + this.retryOpts.retry( + err, + { + state: { counter: this.retryCount++, currentTimeout: this.retryAfter }, + opts: { retryOptions: this.retryOpts, ...this.opts } + }, + onRetry.bind(this) + ); + function onRetry(err2) { + if (err2 != null || this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err2); + } + if (this.start !== 0) { + this.opts = { + ...this.opts, + headers: { + ...this.opts.headers, + range: `bytes=${this.start}-${this.end ?? ""}` + } + }; + } + try { + this.dispatch(this.opts, this); + } catch (err3) { + this.handler.onError(err3); + } + } + } + }; + module2.exports = RetryHandler; + } +}); + +// node_modules/undici/lib/global.js +var require_global2 = __commonJS({ + "node_modules/undici/lib/global.js"(exports2, module2) { + "use strict"; + var globalDispatcher = Symbol.for("undici.globalDispatcher.1"); + var { InvalidArgumentError } = require_errors(); + var Agent = require_agent(); + if (getGlobalDispatcher() === void 0) { + setGlobalDispatcher(new Agent()); + } + function setGlobalDispatcher(agent) { + if (!agent || typeof agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument agent must implement Agent"); + } + Object.defineProperty(globalThis, globalDispatcher, { + value: agent, + writable: true, + enumerable: false, + configurable: false + }); + } + function getGlobalDispatcher() { + return globalThis[globalDispatcher]; + } + module2.exports = { + setGlobalDispatcher, + getGlobalDispatcher + }; + } +}); + +// node_modules/undici/lib/handler/DecoratorHandler.js +var require_DecoratorHandler = __commonJS({ + "node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module2) { + "use strict"; + module2.exports = class DecoratorHandler { + constructor(handler) { + this.handler = handler; + } + onConnect(...args) { + return this.handler.onConnect(...args); + } + onError(...args) { + return this.handler.onError(...args); + } + onUpgrade(...args) { + return this.handler.onUpgrade(...args); + } + onHeaders(...args) { + return this.handler.onHeaders(...args); + } + onData(...args) { + return this.handler.onData(...args); + } + onComplete(...args) { + return this.handler.onComplete(...args); + } + onBodySent(...args) { + return this.handler.onBodySent(...args); + } + }; + } +}); + +// node_modules/undici/lib/fetch/headers.js +var require_headers = __commonJS({ + "node_modules/undici/lib/fetch/headers.js"(exports2, module2) { + "use strict"; + var { kHeadersList, kConstruct } = require_symbols(); + var { kGuard } = require_symbols2(); + var { kEnumerableProperty } = require_util(); + var { + makeIterator, + isValidHeaderName, + isValidHeaderValue + } = require_util2(); + var util = require("util"); + var { webidl } = require_webidl(); + var assert = require("assert"); + var kHeadersMap = Symbol("headers map"); + var kHeadersSortedMap = Symbol("headers map sorted"); + function isHTTPWhiteSpaceCharCode(code) { + return code === 10 || code === 13 || code === 9 || code === 32; + } + function headerValueNormalize(potentialValue) { + let i = 0; + let j = potentialValue.length; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i; + return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j); + } + function fill(headers, object) { + if (Array.isArray(object)) { + for (let i = 0; i < object.length; ++i) { + const header = object[i]; + if (header.length !== 2) { + throw webidl.errors.exception({ + header: "Headers constructor", + message: `expected name/value pair to be length 2, found ${header.length}.` + }); + } + appendHeader(headers, header[0], header[1]); + } + } else if (typeof object === "object" && object !== null) { + const keys = Object.keys(object); + for (let i = 0; i < keys.length; ++i) { + appendHeader(headers, keys[i], object[keys[i]]); + } + } else { + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + } + } + function appendHeader(headers, name, value) { + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value, + type: "header value" + }); + } + if (headers[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (headers[kGuard] === "request-no-cors") { + } + return headers[kHeadersList].append(name, value); + } + var HeadersList = class _HeadersList { + /** @type {[string, string][]|null} */ + cookies = null; + constructor(init) { + if (init instanceof _HeadersList) { + this[kHeadersMap] = new Map(init[kHeadersMap]); + this[kHeadersSortedMap] = init[kHeadersSortedMap]; + this.cookies = init.cookies === null ? null : [...init.cookies]; + } else { + this[kHeadersMap] = new Map(init); + this[kHeadersSortedMap] = null; + } + } + // https://fetch.spec.whatwg.org/#header-list-contains + contains(name) { + name = name.toLowerCase(); + return this[kHeadersMap].has(name); + } + clear() { + this[kHeadersMap].clear(); + this[kHeadersSortedMap] = null; + this.cookies = null; + } + // https://fetch.spec.whatwg.org/#concept-header-list-append + append(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + const exists = this[kHeadersMap].get(lowercaseName); + if (exists) { + const delimiter = lowercaseName === "cookie" ? "; " : ", "; + this[kHeadersMap].set(lowercaseName, { + name: exists.name, + value: `${exists.value}${delimiter}${value}` + }); + } else { + this[kHeadersMap].set(lowercaseName, { name, value }); + } + if (lowercaseName === "set-cookie") { + this.cookies ??= []; + this.cookies.push(value); + } + } + // https://fetch.spec.whatwg.org/#concept-header-list-set + set(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + if (lowercaseName === "set-cookie") { + this.cookies = [value]; + } + this[kHeadersMap].set(lowercaseName, { name, value }); + } + // https://fetch.spec.whatwg.org/#concept-header-list-delete + delete(name) { + this[kHeadersSortedMap] = null; + name = name.toLowerCase(); + if (name === "set-cookie") { + this.cookies = null; + } + this[kHeadersMap].delete(name); + } + // https://fetch.spec.whatwg.org/#concept-header-list-get + get(name) { + const value = this[kHeadersMap].get(name.toLowerCase()); + return value === void 0 ? null : value.value; + } + *[Symbol.iterator]() { + for (const [name, { value }] of this[kHeadersMap]) { + yield [name, value]; + } + } + get entries() { + const headers = {}; + if (this[kHeadersMap].size) { + for (const { name, value } of this[kHeadersMap].values()) { + headers[name] = value; + } + } + return headers; + } + }; + var Headers2 = class _Headers { + constructor(init = void 0) { + if (init === kConstruct) { + return; + } + this[kHeadersList] = new HeadersList(); + this[kGuard] = "none"; + if (init !== void 0) { + init = webidl.converters.HeadersInit(init); + fill(this, init); + } + } + // https://fetch.spec.whatwg.org/#dom-headers-append + append(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + return appendHeader(this, name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-delete + delete(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.delete", + value: name, + type: "header name" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + if (!this[kHeadersList].contains(name)) { + return; + } + this[kHeadersList].delete(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-get + get(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.get", + value: name, + type: "header name" + }); + } + return this[kHeadersList].get(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-has + has(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.has", + value: name, + type: "header name" + }); + } + return this[kHeadersList].contains(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-set + set(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value, + type: "header value" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + this[kHeadersList].set(name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie + getSetCookie() { + webidl.brandCheck(this, _Headers); + const list = this[kHeadersList].cookies; + if (list) { + return [...list]; + } + return []; + } + // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine + get [kHeadersSortedMap]() { + if (this[kHeadersList][kHeadersSortedMap]) { + return this[kHeadersList][kHeadersSortedMap]; + } + const headers = []; + const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1); + const cookies = this[kHeadersList].cookies; + for (let i = 0; i < names.length; ++i) { + const [name, value] = names[i]; + if (name === "set-cookie") { + for (let j = 0; j < cookies.length; ++j) { + headers.push([name, cookies[j]]); + } + } else { + assert(value !== null); + headers.push([name, value]); + } + } + this[kHeadersList][kHeadersSortedMap] = headers; + return headers; + } + keys() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key" + ); + } + values() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "value" + ); + } + entries() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key+value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key+value" + ); + } + /** + * @param {(value: string, key: string, self: Headers) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'." + ); + } + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); + } + } + [Symbol.for("nodejs.util.inspect.custom")]() { + webidl.brandCheck(this, _Headers); + return this[kHeadersList]; + } + }; + Headers2.prototype[Symbol.iterator] = Headers2.prototype.entries; + Object.defineProperties(Headers2.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + getSetCookie: kEnumerableProperty, + keys: kEnumerableProperty, + values: kEnumerableProperty, + entries: kEnumerableProperty, + forEach: kEnumerableProperty, + [Symbol.iterator]: { enumerable: false }, + [Symbol.toStringTag]: { + value: "Headers", + configurable: true + }, + [util.inspect.custom]: { + enumerable: false + } + }); + webidl.converters.HeadersInit = function(V) { + if (webidl.util.Type(V) === "Object") { + if (V[Symbol.iterator]) { + return webidl.converters["sequence>"](V); + } + return webidl.converters["record"](V); + } + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + }; + module2.exports = { + fill, + Headers: Headers2, + HeadersList + }; + } +}); + +// node_modules/undici/lib/fetch/response.js +var require_response = __commonJS({ + "node_modules/undici/lib/fetch/response.js"(exports2, module2) { + "use strict"; + var { Headers: Headers2, HeadersList, fill } = require_headers(); + var { extractBody, cloneBody, mixinBody } = require_body(); + var util = require_util(); + var { kEnumerableProperty } = util; + var { + isValidReasonPhrase, + isCancelled, + isAborted, + isBlobLike: isBlobLike2, + serializeJavascriptValueToJSONString, + isErrorLike, + isomorphicEncode + } = require_util2(); + var { + redirectStatusSet, + nullBodyStatus, + DOMException: DOMException2 + } = require_constants2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { FormData: FormData2 } = require_formdata(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { types } = require("util"); + var ReadableStream = globalThis.ReadableStream || require("stream/web").ReadableStream; + var textEncoder = new TextEncoder("utf-8"); + var Response2 = class _Response { + // Creates network error Response. + static error() { + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kState] = makeNetworkError(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response-json + static json(data, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" }); + if (init !== null) { + init = webidl.converters.ResponseInit(init); + } + const bytes = textEncoder.encode( + serializeJavascriptValueToJSONString(data) + ); + const body = extractBody(bytes); + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "response"; + responseObject[kHeaders][kRealm] = relevantRealm; + initializeResponse(responseObject, init, { body: body[0], type: "application/json" }); + return responseObject; + } + // Creates a redirect Response that redirects to url with status status. + static redirect(url, status = 302) { + const relevantRealm = { settingsObject: {} }; + webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" }); + url = webidl.converters.USVString(url); + status = webidl.converters["unsigned short"](status); + let parsedURL; + try { + parsedURL = new URL(url, getGlobalOrigin()); + } catch (err) { + throw Object.assign(new TypeError("Failed to parse URL from " + url), { + cause: err + }); + } + if (!redirectStatusSet.has(status)) { + throw new RangeError("Invalid status code " + status); + } + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + responseObject[kState].status = status; + const value = isomorphicEncode(URLSerializer(parsedURL)); + responseObject[kState].headersList.append("location", value); + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response + constructor(body = null, init = {}) { + if (body !== null) { + body = webidl.converters.BodyInit(body); + } + init = webidl.converters.ResponseInit(init); + this[kRealm] = { settingsObject: {} }; + this[kState] = makeResponse({}); + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kGuard] = "response"; + this[kHeaders][kHeadersList] = this[kState].headersList; + this[kHeaders][kRealm] = this[kRealm]; + let bodyWithType = null; + if (body != null) { + const [extractedBody, type] = extractBody(body); + bodyWithType = { body: extractedBody, type }; + } + initializeResponse(this, init, bodyWithType); + } + // Returns response’s type, e.g., "cors". + get type() { + webidl.brandCheck(this, _Response); + return this[kState].type; + } + // Returns response’s URL, if it has one; otherwise the empty string. + get url() { + webidl.brandCheck(this, _Response); + const urlList = this[kState].urlList; + const url = urlList[urlList.length - 1] ?? null; + if (url === null) { + return ""; + } + return URLSerializer(url, true); + } + // Returns whether response was obtained through a redirect. + get redirected() { + webidl.brandCheck(this, _Response); + return this[kState].urlList.length > 1; + } + // Returns response’s status. + get status() { + webidl.brandCheck(this, _Response); + return this[kState].status; + } + // Returns whether response’s status is an ok status. + get ok() { + webidl.brandCheck(this, _Response); + return this[kState].status >= 200 && this[kState].status <= 299; + } + // Returns response’s status message. + get statusText() { + webidl.brandCheck(this, _Response); + return this[kState].statusText; + } + // Returns response’s headers as Headers. + get headers() { + webidl.brandCheck(this, _Response); + return this[kHeaders]; + } + get body() { + webidl.brandCheck(this, _Response); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Response); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + // Returns a clone of response. + clone() { + webidl.brandCheck(this, _Response); + if (this.bodyUsed || this.body && this.body.locked) { + throw webidl.errors.exception({ + header: "Response.clone", + message: "Body has already been consumed." + }); + } + const clonedResponse = cloneResponse(this[kState]); + const clonedResponseObject = new _Response(); + clonedResponseObject[kState] = clonedResponse; + clonedResponseObject[kRealm] = this[kRealm]; + clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList; + clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + return clonedResponseObject; + } + }; + mixinBody(Response2); + Object.defineProperties(Response2.prototype, { + type: kEnumerableProperty, + url: kEnumerableProperty, + status: kEnumerableProperty, + ok: kEnumerableProperty, + redirected: kEnumerableProperty, + statusText: kEnumerableProperty, + headers: kEnumerableProperty, + clone: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Response", + configurable: true + } + }); + Object.defineProperties(Response2, { + json: kEnumerableProperty, + redirect: kEnumerableProperty, + error: kEnumerableProperty + }); + function cloneResponse(response) { + if (response.internalResponse) { + return filterResponse( + cloneResponse(response.internalResponse), + response.type + ); + } + const newResponse = makeResponse({ ...response, body: null }); + if (response.body != null) { + newResponse.body = cloneBody(response.body); + } + return newResponse; + } + function makeResponse(init) { + return { + aborted: false, + rangeRequested: false, + timingAllowPassed: false, + requestIncludesCredentials: false, + type: "default", + status: 200, + timingInfo: null, + cacheState: "", + statusText: "", + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList(), + urlList: init.urlList ? [...init.urlList] : [] + }; + } + function makeNetworkError(reason) { + const isError = isErrorLike(reason); + return makeResponse({ + type: "error", + status: 0, + error: isError ? reason : new Error(reason ? String(reason) : reason), + aborted: reason && reason.name === "AbortError" + }); + } + function makeFilteredResponse(response, state) { + state = { + internalResponse: response, + ...state + }; + return new Proxy(response, { + get(target, p) { + return p in state ? state[p] : target[p]; + }, + set(target, p, value) { + assert(!(p in state)); + target[p] = value; + return true; + } + }); + } + function filterResponse(response, type) { + if (type === "basic") { + return makeFilteredResponse(response, { + type: "basic", + headersList: response.headersList + }); + } else if (type === "cors") { + return makeFilteredResponse(response, { + type: "cors", + headersList: response.headersList + }); + } else if (type === "opaque") { + return makeFilteredResponse(response, { + type: "opaque", + urlList: Object.freeze([]), + status: 0, + statusText: "", + body: null + }); + } else if (type === "opaqueredirect") { + return makeFilteredResponse(response, { + type: "opaqueredirect", + status: 0, + statusText: "", + headersList: [], + body: null + }); + } else { + assert(false); + } + } + function makeAppropriateNetworkError(fetchParams, err = null) { + assert(isCancelled(fetchParams)); + return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException2("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException2("Request was cancelled."), { cause: err })); + } + function initializeResponse(response, init, body) { + if (init.status !== null && (init.status < 200 || init.status > 599)) { + throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.'); + } + if ("statusText" in init && init.statusText != null) { + if (!isValidReasonPhrase(String(init.statusText))) { + throw new TypeError("Invalid statusText"); + } + } + if ("status" in init && init.status != null) { + response[kState].status = init.status; + } + if ("statusText" in init && init.statusText != null) { + response[kState].statusText = init.statusText; + } + if ("headers" in init && init.headers != null) { + fill(response[kHeaders], init.headers); + } + if (body) { + if (nullBodyStatus.includes(response.status)) { + throw webidl.errors.exception({ + header: "Response constructor", + message: "Invalid response status code " + response.status + }); + } + response[kState].body = body.body; + if (body.type != null && !response[kState].headersList.contains("Content-Type")) { + response[kState].headersList.append("content-type", body.type); + } + } + } + webidl.converters.ReadableStream = webidl.interfaceConverter( + ReadableStream + ); + webidl.converters.FormData = webidl.interfaceConverter( + FormData2 + ); + webidl.converters.URLSearchParams = webidl.interfaceConverter( + URLSearchParams + ); + webidl.converters.XMLHttpRequestBodyInit = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (types.isArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) { + return webidl.converters.BufferSource(V); + } + if (util.isFormDataLike(V)) { + return webidl.converters.FormData(V, { strict: false }); + } + if (V instanceof URLSearchParams) { + return webidl.converters.URLSearchParams(V); + } + return webidl.converters.DOMString(V); + }; + webidl.converters.BodyInit = function(V) { + if (V instanceof ReadableStream) { + return webidl.converters.ReadableStream(V); + } + if (V?.[Symbol.asyncIterator]) { + return V; + } + return webidl.converters.XMLHttpRequestBodyInit(V); + }; + webidl.converters.ResponseInit = webidl.dictionaryConverter([ + { + key: "status", + converter: webidl.converters["unsigned short"], + defaultValue: 200 + }, + { + key: "statusText", + converter: webidl.converters.ByteString, + defaultValue: "" + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + } + ]); + module2.exports = { + makeNetworkError, + makeResponse, + makeAppropriateNetworkError, + filterResponse, + Response: Response2, + cloneResponse + }; + } +}); + +// node_modules/undici/lib/fetch/request.js +var require_request2 = __commonJS({ + "node_modules/undici/lib/fetch/request.js"(exports2, module2) { + "use strict"; + var { extractBody, mixinBody, cloneBody } = require_body(); + var { Headers: Headers2, fill: fillHeaders, HeadersList } = require_headers(); + var { FinalizationRegistry } = require_dispatcher_weakref()(); + var util = require_util(); + var { + isValidHTTPToken, + sameOrigin, + normalizeMethod, + makePolicyContainer, + normalizeMethodRecord + } = require_util2(); + var { + forbiddenMethodsSet, + corsSafeListedMethodsSet, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + requestDuplex + } = require_constants2(); + var { kEnumerableProperty } = util; + var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events"); + var TransformStream = globalThis.TransformStream; + var kAbortController = Symbol("abortController"); + var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => { + signal.removeEventListener("abort", abort); + }); + var Request = class _Request { + // https://fetch.spec.whatwg.org/#dom-request + constructor(input, init = {}) { + if (input === kConstruct) { + return; + } + webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" }); + input = webidl.converters.RequestInfo(input); + init = webidl.converters.RequestInit(init); + this[kRealm] = { + settingsObject: { + baseUrl: getGlobalOrigin(), + get origin() { + return this.baseUrl?.origin; + }, + policyContainer: makePolicyContainer() + } + }; + let request = null; + let fallbackMode = null; + const baseUrl = this[kRealm].settingsObject.baseUrl; + let signal = null; + if (typeof input === "string") { + let parsedURL; + try { + parsedURL = new URL(input, baseUrl); + } catch (err) { + throw new TypeError("Failed to parse URL from " + input, { cause: err }); + } + if (parsedURL.username || parsedURL.password) { + throw new TypeError( + "Request cannot be constructed from a URL that includes credentials: " + input + ); + } + request = makeRequest({ urlList: [parsedURL] }); + fallbackMode = "cors"; + } else { + assert(input instanceof _Request); + request = input[kState]; + signal = input[kSignal]; + } + const origin = this[kRealm].settingsObject.origin; + let window2 = "client"; + if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) { + window2 = request.window; + } + if (init.window != null) { + throw new TypeError(`'window' option '${window2}' must be null`); + } + if ("window" in init) { + window2 = "no-window"; + } + request = makeRequest({ + // URL request’s URL. + // undici implementation note: this is set as the first item in request's urlList in makeRequest + // method request’s method. + method: request.method, + // header list A copy of request’s header list. + // undici implementation note: headersList is cloned in makeRequest + headersList: request.headersList, + // unsafe-request flag Set. + unsafeRequest: request.unsafeRequest, + // client This’s relevant settings object. + client: this[kRealm].settingsObject, + // window window. + window: window2, + // priority request’s priority. + priority: request.priority, + // origin request’s origin. The propagation of the origin is only significant for navigation requests + // being handled by a service worker. In this scenario a request can have an origin that is different + // from the current client. + origin: request.origin, + // referrer request’s referrer. + referrer: request.referrer, + // referrer policy request’s referrer policy. + referrerPolicy: request.referrerPolicy, + // mode request’s mode. + mode: request.mode, + // credentials mode request’s credentials mode. + credentials: request.credentials, + // cache mode request’s cache mode. + cache: request.cache, + // redirect mode request’s redirect mode. + redirect: request.redirect, + // integrity metadata request’s integrity metadata. + integrity: request.integrity, + // keepalive request’s keepalive. + keepalive: request.keepalive, + // reload-navigation flag request’s reload-navigation flag. + reloadNavigation: request.reloadNavigation, + // history-navigation flag request’s history-navigation flag. + historyNavigation: request.historyNavigation, + // URL list A clone of request’s URL list. + urlList: [...request.urlList] + }); + const initHasKey = Object.keys(init).length !== 0; + if (initHasKey) { + if (request.mode === "navigate") { + request.mode = "same-origin"; + } + request.reloadNavigation = false; + request.historyNavigation = false; + request.origin = "client"; + request.referrer = "client"; + request.referrerPolicy = ""; + request.url = request.urlList[request.urlList.length - 1]; + request.urlList = [request.url]; + } + if (init.referrer !== void 0) { + const referrer = init.referrer; + if (referrer === "") { + request.referrer = "no-referrer"; + } else { + let parsedReferrer; + try { + parsedReferrer = new URL(referrer, baseUrl); + } catch (err) { + throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err }); + } + if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) { + request.referrer = "client"; + } else { + request.referrer = parsedReferrer; + } + } + } + if (init.referrerPolicy !== void 0) { + request.referrerPolicy = init.referrerPolicy; + } + let mode; + if (init.mode !== void 0) { + mode = init.mode; + } else { + mode = fallbackMode; + } + if (mode === "navigate") { + throw webidl.errors.exception({ + header: "Request constructor", + message: "invalid request mode navigate." + }); + } + if (mode != null) { + request.mode = mode; + } + if (init.credentials !== void 0) { + request.credentials = init.credentials; + } + if (init.cache !== void 0) { + request.cache = init.cache; + } + if (request.cache === "only-if-cached" && request.mode !== "same-origin") { + throw new TypeError( + "'only-if-cached' can be set only with 'same-origin' mode" + ); + } + if (init.redirect !== void 0) { + request.redirect = init.redirect; + } + if (init.integrity != null) { + request.integrity = String(init.integrity); + } + if (init.keepalive !== void 0) { + request.keepalive = Boolean(init.keepalive); + } + if (init.method !== void 0) { + let method = init.method; + if (!isValidHTTPToken(method)) { + throw new TypeError(`'${method}' is not a valid HTTP method.`); + } + if (forbiddenMethodsSet.has(method.toUpperCase())) { + throw new TypeError(`'${method}' HTTP method is unsupported.`); + } + method = normalizeMethodRecord[method] ?? normalizeMethod(method); + request.method = method; + } + if (init.signal !== void 0) { + signal = init.signal; + } + this[kState] = request; + const ac = new AbortController(); + this[kSignal] = ac.signal; + this[kSignal][kRealm] = this[kRealm]; + if (signal != null) { + if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") { + throw new TypeError( + "Failed to construct 'Request': member signal is not of type AbortSignal." + ); + } + if (signal.aborted) { + ac.abort(signal.reason); + } else { + this[kAbortController] = ac; + const acRef = new WeakRef(ac); + const abort = function() { + const ac2 = acRef.deref(); + if (ac2 !== void 0) { + ac2.abort(this.reason); + } + }; + try { + if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) { + setMaxListeners(100, signal); + } else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) { + setMaxListeners(100, signal); + } + } catch { + } + util.addAbortListener(signal, abort); + requestFinalizer.register(ac, { signal, abort }); + } + } + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kHeadersList] = request.headersList; + this[kHeaders][kGuard] = "request"; + this[kHeaders][kRealm] = this[kRealm]; + if (mode === "no-cors") { + if (!corsSafeListedMethodsSet.has(request.method)) { + throw new TypeError( + `'${request.method} is unsupported in no-cors mode.` + ); + } + this[kHeaders][kGuard] = "request-no-cors"; + } + if (initHasKey) { + const headersList = this[kHeaders][kHeadersList]; + const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList); + headersList.clear(); + if (headers instanceof HeadersList) { + for (const [key, val] of headers) { + headersList.append(key, val); + } + headersList.cookies = headers.cookies; + } else { + fillHeaders(this[kHeaders], headers); + } + } + const inputBody = input instanceof _Request ? input[kState].body : null; + if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) { + throw new TypeError("Request with GET/HEAD method cannot have body."); + } + let initBody = null; + if (init.body != null) { + const [extractedBody, contentType] = extractBody( + init.body, + request.keepalive + ); + initBody = extractedBody; + if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) { + this[kHeaders].append("content-type", contentType); + } + } + const inputOrInitBody = initBody ?? inputBody; + if (inputOrInitBody != null && inputOrInitBody.source == null) { + if (initBody != null && init.duplex == null) { + throw new TypeError("RequestInit: duplex option is required when sending a body."); + } + if (request.mode !== "same-origin" && request.mode !== "cors") { + throw new TypeError( + 'If request is made from ReadableStream, mode should be "same-origin" or "cors"' + ); + } + request.useCORSPreflightFlag = true; + } + let finalBody = inputOrInitBody; + if (initBody == null && inputBody != null) { + if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) { + throw new TypeError( + "Cannot construct a Request with a Request object that has already been used." + ); + } + if (!TransformStream) { + TransformStream = require("stream/web").TransformStream; + } + const identityTransform = new TransformStream(); + inputBody.stream.pipeThrough(identityTransform); + finalBody = { + source: inputBody.source, + length: inputBody.length, + stream: identityTransform.readable + }; + } + this[kState].body = finalBody; + } + // Returns request’s HTTP method, which is "GET" by default. + get method() { + webidl.brandCheck(this, _Request); + return this[kState].method; + } + // Returns the URL of request as a string. + get url() { + webidl.brandCheck(this, _Request); + return URLSerializer(this[kState].url); + } + // Returns a Headers object consisting of the headers associated with request. + // Note that headers added in the network layer by the user agent will not + // be accounted for in this object, e.g., the "Host" header. + get headers() { + webidl.brandCheck(this, _Request); + return this[kHeaders]; + } + // Returns the kind of resource requested by request, e.g., "document" + // or "script". + get destination() { + webidl.brandCheck(this, _Request); + return this[kState].destination; + } + // Returns the referrer of request. Its value can be a same-origin URL if + // explicitly set in init, the empty string to indicate no referrer, and + // "about:client" when defaulting to the global’s default. This is used + // during fetching to determine the value of the `Referer` header of the + // request being made. + get referrer() { + webidl.brandCheck(this, _Request); + if (this[kState].referrer === "no-referrer") { + return ""; + } + if (this[kState].referrer === "client") { + return "about:client"; + } + return this[kState].referrer.toString(); + } + // Returns the referrer policy associated with request. + // This is used during fetching to compute the value of the request’s + // referrer. + get referrerPolicy() { + webidl.brandCheck(this, _Request); + return this[kState].referrerPolicy; + } + // Returns the mode associated with request, which is a string indicating + // whether the request will use CORS, or will be restricted to same-origin + // URLs. + get mode() { + webidl.brandCheck(this, _Request); + return this[kState].mode; + } + // Returns the credentials mode associated with request, + // which is a string indicating whether credentials will be sent with the + // request always, never, or only when sent to a same-origin URL. + get credentials() { + return this[kState].credentials; + } + // Returns the cache mode associated with request, + // which is a string indicating how the request will + // interact with the browser’s cache when fetching. + get cache() { + webidl.brandCheck(this, _Request); + return this[kState].cache; + } + // Returns the redirect mode associated with request, + // which is a string indicating how redirects for the + // request will be handled during fetching. A request + // will follow redirects by default. + get redirect() { + webidl.brandCheck(this, _Request); + return this[kState].redirect; + } + // Returns request’s subresource integrity metadata, which is a + // cryptographic hash of the resource being fetched. Its value + // consists of multiple hashes separated by whitespace. [SRI] + get integrity() { + webidl.brandCheck(this, _Request); + return this[kState].integrity; + } + // Returns a boolean indicating whether or not request can outlive the + // global in which it was created. + get keepalive() { + webidl.brandCheck(this, _Request); + return this[kState].keepalive; + } + // Returns a boolean indicating whether or not request is for a reload + // navigation. + get isReloadNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].reloadNavigation; + } + // Returns a boolean indicating whether or not request is for a history + // navigation (a.k.a. back-foward navigation). + get isHistoryNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].historyNavigation; + } + // Returns the signal associated with request, which is an AbortSignal + // object indicating whether or not request has been aborted, and its + // abort event handler. + get signal() { + webidl.brandCheck(this, _Request); + return this[kSignal]; + } + get body() { + webidl.brandCheck(this, _Request); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Request); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + get duplex() { + webidl.brandCheck(this, _Request); + return "half"; + } + // Returns a clone of request. + clone() { + webidl.brandCheck(this, _Request); + if (this.bodyUsed || this.body?.locked) { + throw new TypeError("unusable"); + } + const clonedRequest = cloneRequest(this[kState]); + const clonedRequestObject = new _Request(kConstruct); + clonedRequestObject[kState] = clonedRequest; + clonedRequestObject[kRealm] = this[kRealm]; + clonedRequestObject[kHeaders] = new Headers2(kConstruct); + clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList; + clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + const ac = new AbortController(); + if (this.signal.aborted) { + ac.abort(this.signal.reason); + } else { + util.addAbortListener( + this.signal, + () => { + ac.abort(this.signal.reason); + } + ); + } + clonedRequestObject[kSignal] = ac.signal; + return clonedRequestObject; + } + }; + mixinBody(Request); + function makeRequest(init) { + const request = { + method: "GET", + localURLsOnly: false, + unsafeRequest: false, + body: null, + client: null, + reservedClient: null, + replacesClientId: "", + window: "client", + keepalive: false, + serviceWorkers: "all", + initiator: "", + destination: "", + priority: null, + origin: "client", + policyContainer: "client", + referrer: "client", + referrerPolicy: "", + mode: "no-cors", + useCORSPreflightFlag: false, + credentials: "same-origin", + useCredentials: false, + cache: "default", + redirect: "follow", + integrity: "", + cryptoGraphicsNonceMetadata: "", + parserMetadata: "", + reloadNavigation: false, + historyNavigation: false, + userActivation: false, + taintedOrigin: false, + redirectCount: 0, + responseTainting: "basic", + preventNoCacheCacheControlHeaderModification: false, + done: false, + timingAllowFailed: false, + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList() + }; + request.url = request.urlList[0]; + return request; + } + function cloneRequest(request) { + const newRequest = makeRequest({ ...request, body: null }); + if (request.body != null) { + newRequest.body = cloneBody(request.body); + } + return newRequest; + } + Object.defineProperties(Request.prototype, { + method: kEnumerableProperty, + url: kEnumerableProperty, + headers: kEnumerableProperty, + redirect: kEnumerableProperty, + clone: kEnumerableProperty, + signal: kEnumerableProperty, + duplex: kEnumerableProperty, + destination: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + isHistoryNavigation: kEnumerableProperty, + isReloadNavigation: kEnumerableProperty, + keepalive: kEnumerableProperty, + integrity: kEnumerableProperty, + cache: kEnumerableProperty, + credentials: kEnumerableProperty, + attribute: kEnumerableProperty, + referrerPolicy: kEnumerableProperty, + referrer: kEnumerableProperty, + mode: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Request", + configurable: true + } + }); + webidl.converters.Request = webidl.interfaceConverter( + Request + ); + webidl.converters.RequestInfo = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (V instanceof Request) { + return webidl.converters.Request(V); + } + return webidl.converters.USVString(V); + }; + webidl.converters.AbortSignal = webidl.interfaceConverter( + AbortSignal + ); + webidl.converters.RequestInit = webidl.dictionaryConverter([ + { + key: "method", + converter: webidl.converters.ByteString + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + }, + { + key: "body", + converter: webidl.nullableConverter( + webidl.converters.BodyInit + ) + }, + { + key: "referrer", + converter: webidl.converters.USVString + }, + { + key: "referrerPolicy", + converter: webidl.converters.DOMString, + // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy + allowedValues: referrerPolicy + }, + { + key: "mode", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#concept-request-mode + allowedValues: requestMode + }, + { + key: "credentials", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcredentials + allowedValues: requestCredentials + }, + { + key: "cache", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcache + allowedValues: requestCache + }, + { + key: "redirect", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestredirect + allowedValues: requestRedirect + }, + { + key: "integrity", + converter: webidl.converters.DOMString + }, + { + key: "keepalive", + converter: webidl.converters.boolean + }, + { + key: "signal", + converter: webidl.nullableConverter( + (signal) => webidl.converters.AbortSignal( + signal, + { strict: false } + ) + ) + }, + { + key: "window", + converter: webidl.converters.any + }, + { + key: "duplex", + converter: webidl.converters.DOMString, + allowedValues: requestDuplex + } + ]); + module2.exports = { Request, makeRequest }; + } +}); + +// node_modules/undici/lib/fetch/index.js +var require_fetch = __commonJS({ + "node_modules/undici/lib/fetch/index.js"(exports2, module2) { + "use strict"; + var { + Response: Response2, + makeNetworkError, + makeAppropriateNetworkError, + filterResponse, + makeResponse + } = require_response(); + var { Headers: Headers2 } = require_headers(); + var { Request, makeRequest } = require_request2(); + var zlib = require("zlib"); + var { + bytesMatch, + makePolicyContainer, + clonePolicyContainer, + requestBadPort, + TAOCheck, + appendRequestOriginHeader, + responseLocationURL, + requestCurrentURL, + setRequestReferrerPolicyOnRedirect, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + createOpaqueTimingInfo, + appendFetchMetadata, + corsCheck, + crossOriginResourcePolicyCheck, + determineRequestsReferrer, + coarsenedSharedCurrentTime, + createDeferredPromise, + isBlobLike: isBlobLike2, + sameOrigin, + isCancelled, + isAborted, + isErrorLike, + fullyReadBody, + readableStreamClose, + isomorphicEncode, + urlIsLocal, + urlIsHttpHttpsScheme, + urlHasHttpsScheme + } = require_util2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var assert = require("assert"); + var { safelyExtractBody } = require_body(); + var { + redirectStatusSet, + nullBodyStatus, + safeMethodsSet, + requestBodyHeader, + subresourceSet, + DOMException: DOMException2 + } = require_constants2(); + var { kHeadersList } = require_symbols(); + var EE = require("events"); + var { Readable, pipeline } = require("stream"); + var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util(); + var { dataURLProcessor, serializeAMimeType } = require_dataURL(); + var { TransformStream } = require("stream/web"); + var { getGlobalDispatcher } = require_global2(); + var { webidl } = require_webidl(); + var { STATUS_CODES } = require("http"); + var GET_OR_HEAD = ["GET", "HEAD"]; + var resolveObjectURL; + var ReadableStream = globalThis.ReadableStream; + var Fetch = class extends EE { + constructor(dispatcher) { + super(); + this.dispatcher = dispatcher; + this.connection = null; + this.dump = false; + this.state = "ongoing"; + this.setMaxListeners(21); + } + terminate(reason) { + if (this.state !== "ongoing") { + return; + } + this.state = "terminated"; + this.connection?.destroy(reason); + this.emit("terminated", reason); + } + // https://fetch.spec.whatwg.org/#fetch-controller-abort + abort(error) { + if (this.state !== "ongoing") { + return; + } + this.state = "aborted"; + if (!error) { + error = new DOMException2("The operation was aborted.", "AbortError"); + } + this.serializedAbortReason = error; + this.connection?.destroy(error); + this.emit("terminated", error); + } + }; + function fetch2(input, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" }); + const p = createDeferredPromise(); + let requestObject; + try { + requestObject = new Request(input, init); + } catch (e) { + p.reject(e); + return p.promise; + } + const request = requestObject[kState]; + if (requestObject.signal.aborted) { + abortFetch(p, request, null, requestObject.signal.reason); + return p.promise; + } + const globalObject = request.client.globalObject; + if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") { + request.serviceWorkers = "none"; + } + let responseObject = null; + const relevantRealm = null; + let locallyAborted = false; + let controller = null; + addAbortListener( + requestObject.signal, + () => { + locallyAborted = true; + assert(controller != null); + controller.abort(requestObject.signal.reason); + abortFetch(p, request, responseObject, requestObject.signal.reason); + } + ); + const handleFetchDone = (response) => finalizeAndReportTiming(response, "fetch"); + const processResponse = (response) => { + if (locallyAborted) { + return Promise.resolve(); + } + if (response.aborted) { + abortFetch(p, request, responseObject, controller.serializedAbortReason); + return Promise.resolve(); + } + if (response.type === "error") { + p.reject( + Object.assign(new TypeError("fetch failed"), { cause: response.error }) + ); + return Promise.resolve(); + } + responseObject = new Response2(); + responseObject[kState] = response; + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + p.resolve(responseObject); + }; + controller = fetching({ + request, + processResponseEndOfBody: handleFetchDone, + processResponse, + dispatcher: init.dispatcher ?? getGlobalDispatcher() + // undici + }); + return p.promise; + } + function finalizeAndReportTiming(response, initiatorType = "other") { + if (response.type === "error" && response.aborted) { + return; + } + if (!response.urlList?.length) { + return; + } + const originalURL = response.urlList[0]; + let timingInfo = response.timingInfo; + let cacheState = response.cacheState; + if (!urlIsHttpHttpsScheme(originalURL)) { + return; + } + if (timingInfo === null) { + return; + } + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo({ + startTime: timingInfo.startTime + }); + cacheState = ""; + } + timingInfo.endTime = coarsenedSharedCurrentTime(); + response.timingInfo = timingInfo; + markResourceTiming( + timingInfo, + originalURL, + initiatorType, + globalThis, + cacheState + ); + } + function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) { + if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) { + performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState); + } + } + function abortFetch(p, request, responseObject, error) { + if (!error) { + error = new DOMException2("The operation was aborted.", "AbortError"); + } + p.reject(error); + if (request.body != null && isReadable(request.body?.stream)) { + request.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + if (responseObject == null) { + return; + } + const response = responseObject[kState]; + if (response.body != null && isReadable(response.body?.stream)) { + response.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + } + function fetching({ + request, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseEndOfBody, + processResponseConsumeBody, + useParallelQueue = false, + dispatcher + // undici + }) { + let taskDestination = null; + let crossOriginIsolatedCapability = false; + if (request.client != null) { + taskDestination = request.client.globalObject; + crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability; + } + const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability); + const timingInfo = createOpaqueTimingInfo({ + startTime: currenTime + }); + const fetchParams = { + controller: new Fetch(dispatcher), + request, + timingInfo, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseConsumeBody, + processResponseEndOfBody, + taskDestination, + crossOriginIsolatedCapability + }; + assert(!request.body || request.body.stream); + if (request.window === "client") { + request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window"; + } + if (request.origin === "client") { + request.origin = request.client?.origin; + } + if (request.policyContainer === "client") { + if (request.client != null) { + request.policyContainer = clonePolicyContainer( + request.client.policyContainer + ); + } else { + request.policyContainer = makePolicyContainer(); + } + } + if (!request.headersList.contains("accept")) { + const value = "*/*"; + request.headersList.append("accept", value); + } + if (!request.headersList.contains("accept-language")) { + request.headersList.append("accept-language", "*"); + } + if (request.priority === null) { + } + if (subresourceSet.has(request.destination)) { + } + mainFetch(fetchParams).catch((err) => { + fetchParams.controller.terminate(err); + }); + return fetchParams.controller; + } + async function mainFetch(fetchParams, recursive = false) { + const request = fetchParams.request; + let response = null; + if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) { + response = makeNetworkError("local URLs only"); + } + tryUpgradeRequestToAPotentiallyTrustworthyURL(request); + if (requestBadPort(request) === "blocked") { + response = makeNetworkError("bad port"); + } + if (request.referrerPolicy === "") { + request.referrerPolicy = request.policyContainer.referrerPolicy; + } + if (request.referrer !== "no-referrer") { + request.referrer = determineRequestsReferrer(request); + } + if (response === null) { + response = await (async () => { + const currentURL = requestCurrentURL(request); + if ( + // - request’s current URL’s origin is same origin with request’s origin, + // and request’s response tainting is "basic" + sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data" + currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket" + (request.mode === "navigate" || request.mode === "websocket") + ) { + request.responseTainting = "basic"; + return await schemeFetch(fetchParams); + } + if (request.mode === "same-origin") { + return makeNetworkError('request mode cannot be "same-origin"'); + } + if (request.mode === "no-cors") { + if (request.redirect !== "follow") { + return makeNetworkError( + 'redirect mode cannot be "follow" for "no-cors" request' + ); + } + request.responseTainting = "opaque"; + return await schemeFetch(fetchParams); + } + if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) { + return makeNetworkError("URL scheme must be a HTTP(S) scheme"); + } + request.responseTainting = "cors"; + return await httpFetch(fetchParams); + })(); + } + if (recursive) { + return response; + } + if (response.status !== 0 && !response.internalResponse) { + if (request.responseTainting === "cors") { + } + if (request.responseTainting === "basic") { + response = filterResponse(response, "basic"); + } else if (request.responseTainting === "cors") { + response = filterResponse(response, "cors"); + } else if (request.responseTainting === "opaque") { + response = filterResponse(response, "opaque"); + } else { + assert(false); + } + } + let internalResponse = response.status === 0 ? response : response.internalResponse; + if (internalResponse.urlList.length === 0) { + internalResponse.urlList.push(...request.urlList); + } + if (!request.timingAllowFailed) { + response.timingAllowPassed = true; + } + if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range")) { + response = internalResponse = makeNetworkError(); + } + if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) { + internalResponse.body = null; + fetchParams.controller.dump = true; + } + if (request.integrity) { + const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason)); + if (request.responseTainting === "opaque" || response.body == null) { + processBodyError(response.error); + return; + } + const processBody = (bytes) => { + if (!bytesMatch(bytes, request.integrity)) { + processBodyError("integrity mismatch"); + return; + } + response.body = safelyExtractBody(bytes)[0]; + fetchFinale(fetchParams, response); + }; + await fullyReadBody(response.body, processBody, processBodyError); + } else { + fetchFinale(fetchParams, response); + } + } + function schemeFetch(fetchParams) { + if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) { + return Promise.resolve(makeAppropriateNetworkError(fetchParams)); + } + const { request } = fetchParams; + const { protocol: scheme } = requestCurrentURL(request); + switch (scheme) { + case "about:": { + return Promise.resolve(makeNetworkError("about scheme is not supported")); + } + case "blob:": { + if (!resolveObjectURL) { + resolveObjectURL = require("buffer").resolveObjectURL; + } + const blobURLEntry = requestCurrentURL(request); + if (blobURLEntry.search.length !== 0) { + return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource.")); + } + const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString()); + if (request.method !== "GET" || !isBlobLike2(blobURLEntryObject)) { + return Promise.resolve(makeNetworkError("invalid method")); + } + const bodyWithType = safelyExtractBody(blobURLEntryObject); + const body = bodyWithType[0]; + const length = isomorphicEncode(`${body.length}`); + const type = bodyWithType[1] ?? ""; + const response = makeResponse({ + statusText: "OK", + headersList: [ + ["content-length", { name: "Content-Length", value: length }], + ["content-type", { name: "Content-Type", value: type }] + ] + }); + response.body = body; + return Promise.resolve(response); + } + case "data:": { + const currentURL = requestCurrentURL(request); + const dataURLStruct = dataURLProcessor(currentURL); + if (dataURLStruct === "failure") { + return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + } + const mimeType = serializeAMimeType(dataURLStruct.mimeType); + return Promise.resolve(makeResponse({ + statusText: "OK", + headersList: [ + ["content-type", { name: "Content-Type", value: mimeType }] + ], + body: safelyExtractBody(dataURLStruct.body)[0] + })); + } + case "file:": { + return Promise.resolve(makeNetworkError("not implemented... yet...")); + } + case "http:": + case "https:": { + return httpFetch(fetchParams).catch((err) => makeNetworkError(err)); + } + default: { + return Promise.resolve(makeNetworkError("unknown scheme")); + } + } + } + function finalizeResponse(fetchParams, response) { + fetchParams.request.done = true; + if (fetchParams.processResponseDone != null) { + queueMicrotask(() => fetchParams.processResponseDone(response)); + } + } + function fetchFinale(fetchParams, response) { + if (response.type === "error") { + response.urlList = [fetchParams.request.urlList[0]]; + response.timingInfo = createOpaqueTimingInfo({ + startTime: fetchParams.timingInfo.startTime + }); + } + const processResponseEndOfBody = () => { + fetchParams.request.done = true; + if (fetchParams.processResponseEndOfBody != null) { + queueMicrotask(() => fetchParams.processResponseEndOfBody(response)); + } + }; + if (fetchParams.processResponse != null) { + queueMicrotask(() => fetchParams.processResponse(response)); + } + if (response.body == null) { + processResponseEndOfBody(); + } else { + const identityTransformAlgorithm = (chunk, controller) => { + controller.enqueue(chunk); + }; + const transformStream = new TransformStream({ + start() { + }, + transform: identityTransformAlgorithm, + flush: processResponseEndOfBody + }, { + size() { + return 1; + } + }, { + size() { + return 1; + } + }); + response.body = { stream: response.body.stream.pipeThrough(transformStream) }; + } + if (fetchParams.processResponseConsumeBody != null) { + const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes); + const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure); + if (response.body == null) { + queueMicrotask(() => processBody(null)); + } else { + return fullyReadBody(response.body, processBody, processBodyError); + } + return Promise.resolve(); + } + } + async function httpFetch(fetchParams) { + const request = fetchParams.request; + let response = null; + let actualResponse = null; + const timingInfo = fetchParams.timingInfo; + if (request.serviceWorkers === "all") { + } + if (response === null) { + if (request.redirect === "follow") { + request.serviceWorkers = "none"; + } + actualResponse = response = await httpNetworkOrCacheFetch(fetchParams); + if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") { + return makeNetworkError("cors failure"); + } + if (TAOCheck(request, response) === "failure") { + request.timingAllowFailed = true; + } + } + if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck( + request.origin, + request.client, + request.destination, + actualResponse + ) === "blocked") { + return makeNetworkError("blocked"); + } + if (redirectStatusSet.has(actualResponse.status)) { + if (request.redirect !== "manual") { + fetchParams.controller.connection.destroy(); + } + if (request.redirect === "error") { + response = makeNetworkError("unexpected redirect"); + } else if (request.redirect === "manual") { + response = actualResponse; + } else if (request.redirect === "follow") { + response = await httpRedirectFetch(fetchParams, response); + } else { + assert(false); + } + } + response.timingInfo = timingInfo; + return response; + } + function httpRedirectFetch(fetchParams, response) { + const request = fetchParams.request; + const actualResponse = response.internalResponse ? response.internalResponse : response; + let locationURL; + try { + locationURL = responseLocationURL( + actualResponse, + requestCurrentURL(request).hash + ); + if (locationURL == null) { + return response; + } + } catch (err) { + return Promise.resolve(makeNetworkError(err)); + } + if (!urlIsHttpHttpsScheme(locationURL)) { + return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme")); + } + if (request.redirectCount === 20) { + return Promise.resolve(makeNetworkError("redirect count exceeded")); + } + request.redirectCount += 1; + if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) { + return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"')); + } + if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) { + return Promise.resolve(makeNetworkError( + 'URL cannot contain credentials for request mode "cors"' + )); + } + if (actualResponse.status !== 303 && request.body != null && request.body.source == null) { + return Promise.resolve(makeNetworkError()); + } + if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) { + request.method = "GET"; + request.body = null; + for (const headerName of requestBodyHeader) { + request.headersList.delete(headerName); + } + } + if (!sameOrigin(requestCurrentURL(request), locationURL)) { + request.headersList.delete("authorization"); + request.headersList.delete("proxy-authorization", true); + request.headersList.delete("cookie"); + request.headersList.delete("host"); + } + if (request.body != null) { + assert(request.body.source != null); + request.body = safelyExtractBody(request.body.source)[0]; + } + const timingInfo = fetchParams.timingInfo; + timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + if (timingInfo.redirectStartTime === 0) { + timingInfo.redirectStartTime = timingInfo.startTime; + } + request.urlList.push(locationURL); + setRequestReferrerPolicyOnRedirect(request, actualResponse); + return mainFetch(fetchParams, true); + } + async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) { + const request = fetchParams.request; + let httpFetchParams = null; + let httpRequest = null; + let response = null; + const httpCache = null; + const revalidatingFlag = false; + if (request.window === "no-window" && request.redirect === "error") { + httpFetchParams = fetchParams; + httpRequest = request; + } else { + httpRequest = makeRequest(request); + httpFetchParams = { ...fetchParams }; + httpFetchParams.request = httpRequest; + } + const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic"; + const contentLength = httpRequest.body ? httpRequest.body.length : null; + let contentLengthHeaderValue = null; + if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) { + contentLengthHeaderValue = "0"; + } + if (contentLength != null) { + contentLengthHeaderValue = isomorphicEncode(`${contentLength}`); + } + if (contentLengthHeaderValue != null) { + httpRequest.headersList.append("content-length", contentLengthHeaderValue); + } + if (contentLength != null && httpRequest.keepalive) { + } + if (httpRequest.referrer instanceof URL) { + httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href)); + } + appendRequestOriginHeader(httpRequest); + appendFetchMetadata(httpRequest); + if (!httpRequest.headersList.contains("user-agent")) { + httpRequest.headersList.append("user-agent", typeof esbuildDetection === "undefined" ? "undici" : "node"); + } + if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) { + httpRequest.cache = "no-store"; + } + if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "max-age=0"); + } + if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") { + if (!httpRequest.headersList.contains("pragma")) { + httpRequest.headersList.append("pragma", "no-cache"); + } + if (!httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "no-cache"); + } + } + if (httpRequest.headersList.contains("range")) { + httpRequest.headersList.append("accept-encoding", "identity"); + } + if (!httpRequest.headersList.contains("accept-encoding")) { + if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) { + httpRequest.headersList.append("accept-encoding", "br, gzip, deflate"); + } else { + httpRequest.headersList.append("accept-encoding", "gzip, deflate"); + } + } + httpRequest.headersList.delete("host"); + if (includeCredentials) { + } + if (httpCache == null) { + httpRequest.cache = "no-store"; + } + if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") { + } + if (response == null) { + if (httpRequest.mode === "only-if-cached") { + return makeNetworkError("only if cached"); + } + const forwardResponse = await httpNetworkFetch( + httpFetchParams, + includeCredentials, + isNewConnectionFetch + ); + if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) { + } + if (revalidatingFlag && forwardResponse.status === 304) { + } + if (response == null) { + response = forwardResponse; + } + } + response.urlList = [...httpRequest.urlList]; + if (httpRequest.headersList.contains("range")) { + response.rangeRequested = true; + } + response.requestIncludesCredentials = includeCredentials; + if (response.status === 407) { + if (request.window === "no-window") { + return makeNetworkError(); + } + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + return makeNetworkError("proxy authentication required"); + } + if ( + // response’s status is 421 + response.status === 421 && // isNewConnectionFetch is false + !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null + (request.body == null || request.body.source != null) + ) { + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + fetchParams.controller.connection.destroy(); + response = await httpNetworkOrCacheFetch( + fetchParams, + isAuthenticationFetch, + true + ); + } + if (isAuthenticationFetch) { + } + return response; + } + async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) { + assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed); + fetchParams.controller.connection = { + abort: null, + destroyed: false, + destroy(err) { + if (!this.destroyed) { + this.destroyed = true; + this.abort?.(err ?? new DOMException2("The operation was aborted.", "AbortError")); + } + } + }; + const request = fetchParams.request; + let response = null; + const timingInfo = fetchParams.timingInfo; + const httpCache = null; + if (httpCache == null) { + request.cache = "no-store"; + } + const newConnection = forceNewConnection ? "yes" : "no"; + if (request.mode === "websocket") { + } else { + } + let requestBody = null; + if (request.body == null && fetchParams.processRequestEndOfBody) { + queueMicrotask(() => fetchParams.processRequestEndOfBody()); + } else if (request.body != null) { + const processBodyChunk = async function* (bytes) { + if (isCancelled(fetchParams)) { + return; + } + yield bytes; + fetchParams.processRequestBodyChunkLength?.(bytes.byteLength); + }; + const processEndOfBody = () => { + if (isCancelled(fetchParams)) { + return; + } + if (fetchParams.processRequestEndOfBody) { + fetchParams.processRequestEndOfBody(); + } + }; + const processBodyError = (e) => { + if (isCancelled(fetchParams)) { + return; + } + if (e.name === "AbortError") { + fetchParams.controller.abort(); + } else { + fetchParams.controller.terminate(e); + } + }; + requestBody = async function* () { + try { + for await (const bytes of request.body.stream) { + yield* processBodyChunk(bytes); + } + processEndOfBody(); + } catch (err) { + processBodyError(err); + } + }(); + } + try { + const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody }); + if (socket) { + response = makeResponse({ status, statusText, headersList, socket }); + } else { + const iterator = body[Symbol.asyncIterator](); + fetchParams.controller.next = () => iterator.next(); + response = makeResponse({ status, statusText, headersList }); + } + } catch (err) { + if (err.name === "AbortError") { + fetchParams.controller.connection.destroy(); + return makeAppropriateNetworkError(fetchParams, err); + } + return makeNetworkError(err); + } + const pullAlgorithm = () => { + fetchParams.controller.resume(); + }; + const cancelAlgorithm = (reason) => { + fetchParams.controller.abort(reason); + }; + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + const stream = new ReadableStream( + { + async start(controller) { + fetchParams.controller.controller = controller; + }, + async pull(controller) { + await pullAlgorithm(controller); + }, + async cancel(reason) { + await cancelAlgorithm(reason); + } + }, + { + highWaterMark: 0, + size() { + return 1; + } + } + ); + response.body = { stream }; + fetchParams.controller.on("terminated", onAborted); + fetchParams.controller.resume = async () => { + while (true) { + let bytes; + let isFailure; + try { + const { done, value } = await fetchParams.controller.next(); + if (isAborted(fetchParams)) { + break; + } + bytes = done ? void 0 : value; + } catch (err) { + if (fetchParams.controller.ended && !timingInfo.encodedBodySize) { + bytes = void 0; + } else { + bytes = err; + isFailure = true; + } + } + if (bytes === void 0) { + readableStreamClose(fetchParams.controller.controller); + finalizeResponse(fetchParams, response); + return; + } + timingInfo.decodedBodySize += bytes?.byteLength ?? 0; + if (isFailure) { + fetchParams.controller.terminate(bytes); + return; + } + fetchParams.controller.controller.enqueue(new Uint8Array(bytes)); + if (isErrored(stream)) { + fetchParams.controller.terminate(); + return; + } + if (!fetchParams.controller.controller.desiredSize) { + return; + } + } + }; + function onAborted(reason) { + if (isAborted(fetchParams)) { + response.aborted = true; + if (isReadable(stream)) { + fetchParams.controller.controller.error( + fetchParams.controller.serializedAbortReason + ); + } + } else { + if (isReadable(stream)) { + fetchParams.controller.controller.error(new TypeError("terminated", { + cause: isErrorLike(reason) ? reason : void 0 + })); + } + } + fetchParams.controller.connection.destroy(); + } + return response; + async function dispatch({ body }) { + const url = requestCurrentURL(request); + const agent = fetchParams.controller.dispatcher; + return new Promise((resolve, reject) => agent.dispatch( + { + path: url.pathname + url.search, + origin: url.origin, + method: request.method, + body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body, + headers: request.headersList.entries, + maxRedirections: 0, + upgrade: request.mode === "websocket" ? "websocket" : void 0 + }, + { + body: null, + abort: null, + onConnect(abort) { + const { connection } = fetchParams.controller; + if (connection.destroyed) { + abort(new DOMException2("The operation was aborted.", "AbortError")); + } else { + fetchParams.controller.on("terminated", abort); + this.abort = connection.abort = abort; + } + }, + onHeaders(status, headersList, resume, statusText) { + if (status < 200) { + return; + } + let codings = []; + let location = ""; + const headers = new Headers2(); + if (Array.isArray(headersList)) { + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } else { + const keys = Object.keys(headersList); + for (const key of keys) { + const val = headersList[key]; + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()).reverse(); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } + this.body = new Readable({ read: resume }); + const decoders = []; + const willFollow = request.redirect === "follow" && location && redirectStatusSet.has(status); + if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) { + for (const coding of codings) { + if (coding === "x-gzip" || coding === "gzip") { + decoders.push(zlib.createGunzip({ + // 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. + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + } else if (coding === "deflate") { + decoders.push(zlib.createInflate()); + } else if (coding === "br") { + decoders.push(zlib.createBrotliDecompress()); + } else { + decoders.length = 0; + break; + } + } + } + resolve({ + status, + statusText, + headersList: headers[kHeadersList], + body: decoders.length ? pipeline(this.body, ...decoders, () => { + }) : this.body.on("error", () => { + }) + }); + return true; + }, + onData(chunk) { + if (fetchParams.controller.dump) { + return; + } + const bytes = chunk; + timingInfo.encodedBodySize += bytes.byteLength; + return this.body.push(bytes); + }, + onComplete() { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + fetchParams.controller.ended = true; + this.body.push(null); + }, + onError(error) { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + this.body?.destroy(error); + fetchParams.controller.terminate(error); + reject(error); + }, + onUpgrade(status, headersList, socket) { + if (status !== 101) { + return; + } + const headers = new Headers2(); + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + headers[kHeadersList].append(key, val); + } + resolve({ + status, + statusText: STATUS_CODES[status], + headersList: headers[kHeadersList], + socket + }); + return true; + } + } + )); + } + } + module2.exports = { + fetch: fetch2, + Fetch, + fetching, + finalizeAndReportTiming + }; + } +}); + +// node_modules/undici/lib/fileapi/symbols.js +var require_symbols3 = __commonJS({ + "node_modules/undici/lib/fileapi/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kState: Symbol("FileReader state"), + kResult: Symbol("FileReader result"), + kError: Symbol("FileReader error"), + kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"), + kEvents: Symbol("FileReader events"), + kAborted: Symbol("FileReader aborted") + }; + } +}); + +// node_modules/undici/lib/fileapi/progressevent.js +var require_progressevent = __commonJS({ + "node_modules/undici/lib/fileapi/progressevent.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var kState = Symbol("ProgressEvent state"); + var ProgressEvent = class _ProgressEvent extends Event { + constructor(type, eventInitDict = {}) { + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {}); + super(type, eventInitDict); + this[kState] = { + lengthComputable: eventInitDict.lengthComputable, + loaded: eventInitDict.loaded, + total: eventInitDict.total + }; + } + get lengthComputable() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].lengthComputable; + } + get loaded() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].loaded; + } + get total() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].total; + } + }; + webidl.converters.ProgressEventInit = webidl.dictionaryConverter([ + { + key: "lengthComputable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "loaded", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "total", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]); + module2.exports = { + ProgressEvent + }; + } +}); + +// node_modules/undici/lib/fileapi/encoding.js +var require_encoding = __commonJS({ + "node_modules/undici/lib/fileapi/encoding.js"(exports2, module2) { + "use strict"; + function getEncoding(label) { + if (!label) { + return "failure"; + } + switch (label.trim().toLowerCase()) { + case "unicode-1-1-utf-8": + case "unicode11utf8": + case "unicode20utf8": + case "utf-8": + case "utf8": + case "x-unicode20utf8": + return "UTF-8"; + case "866": + case "cp866": + case "csibm866": + case "ibm866": + return "IBM866"; + case "csisolatin2": + case "iso-8859-2": + case "iso-ir-101": + case "iso8859-2": + case "iso88592": + case "iso_8859-2": + case "iso_8859-2:1987": + case "l2": + case "latin2": + return "ISO-8859-2"; + case "csisolatin3": + case "iso-8859-3": + case "iso-ir-109": + case "iso8859-3": + case "iso88593": + case "iso_8859-3": + case "iso_8859-3:1988": + case "l3": + case "latin3": + return "ISO-8859-3"; + case "csisolatin4": + case "iso-8859-4": + case "iso-ir-110": + case "iso8859-4": + case "iso88594": + case "iso_8859-4": + case "iso_8859-4:1988": + case "l4": + case "latin4": + return "ISO-8859-4"; + case "csisolatincyrillic": + case "cyrillic": + case "iso-8859-5": + case "iso-ir-144": + case "iso8859-5": + case "iso88595": + case "iso_8859-5": + case "iso_8859-5:1988": + return "ISO-8859-5"; + case "arabic": + case "asmo-708": + case "csiso88596e": + case "csiso88596i": + case "csisolatinarabic": + case "ecma-114": + case "iso-8859-6": + case "iso-8859-6-e": + case "iso-8859-6-i": + case "iso-ir-127": + case "iso8859-6": + case "iso88596": + case "iso_8859-6": + case "iso_8859-6:1987": + return "ISO-8859-6"; + case "csisolatingreek": + case "ecma-118": + case "elot_928": + case "greek": + case "greek8": + case "iso-8859-7": + case "iso-ir-126": + case "iso8859-7": + case "iso88597": + case "iso_8859-7": + case "iso_8859-7:1987": + case "sun_eu_greek": + return "ISO-8859-7"; + case "csiso88598e": + case "csisolatinhebrew": + case "hebrew": + case "iso-8859-8": + case "iso-8859-8-e": + case "iso-ir-138": + case "iso8859-8": + case "iso88598": + case "iso_8859-8": + case "iso_8859-8:1988": + case "visual": + return "ISO-8859-8"; + case "csiso88598i": + case "iso-8859-8-i": + case "logical": + return "ISO-8859-8-I"; + case "csisolatin6": + case "iso-8859-10": + case "iso-ir-157": + case "iso8859-10": + case "iso885910": + case "l6": + case "latin6": + return "ISO-8859-10"; + case "iso-8859-13": + case "iso8859-13": + case "iso885913": + return "ISO-8859-13"; + case "iso-8859-14": + case "iso8859-14": + case "iso885914": + return "ISO-8859-14"; + case "csisolatin9": + case "iso-8859-15": + case "iso8859-15": + case "iso885915": + case "iso_8859-15": + case "l9": + return "ISO-8859-15"; + case "iso-8859-16": + return "ISO-8859-16"; + case "cskoi8r": + case "koi": + case "koi8": + case "koi8-r": + case "koi8_r": + return "KOI8-R"; + case "koi8-ru": + case "koi8-u": + return "KOI8-U"; + case "csmacintosh": + case "mac": + case "macintosh": + case "x-mac-roman": + return "macintosh"; + case "iso-8859-11": + case "iso8859-11": + case "iso885911": + case "tis-620": + case "windows-874": + return "windows-874"; + case "cp1250": + case "windows-1250": + case "x-cp1250": + return "windows-1250"; + case "cp1251": + case "windows-1251": + case "x-cp1251": + return "windows-1251"; + case "ansi_x3.4-1968": + case "ascii": + case "cp1252": + case "cp819": + case "csisolatin1": + case "ibm819": + case "iso-8859-1": + case "iso-ir-100": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "iso_8859-1:1987": + case "l1": + case "latin1": + case "us-ascii": + case "windows-1252": + case "x-cp1252": + return "windows-1252"; + case "cp1253": + case "windows-1253": + case "x-cp1253": + return "windows-1253"; + case "cp1254": + case "csisolatin5": + case "iso-8859-9": + case "iso-ir-148": + case "iso8859-9": + case "iso88599": + case "iso_8859-9": + case "iso_8859-9:1989": + case "l5": + case "latin5": + case "windows-1254": + case "x-cp1254": + return "windows-1254"; + case "cp1255": + case "windows-1255": + case "x-cp1255": + return "windows-1255"; + case "cp1256": + case "windows-1256": + case "x-cp1256": + return "windows-1256"; + case "cp1257": + case "windows-1257": + case "x-cp1257": + return "windows-1257"; + case "cp1258": + case "windows-1258": + case "x-cp1258": + return "windows-1258"; + case "x-mac-cyrillic": + case "x-mac-ukrainian": + return "x-mac-cyrillic"; + case "chinese": + case "csgb2312": + case "csiso58gb231280": + case "gb2312": + case "gb_2312": + case "gb_2312-80": + case "gbk": + case "iso-ir-58": + case "x-gbk": + return "GBK"; + case "gb18030": + return "gb18030"; + case "big5": + case "big5-hkscs": + case "cn-big5": + case "csbig5": + case "x-x-big5": + return "Big5"; + case "cseucpkdfmtjapanese": + case "euc-jp": + case "x-euc-jp": + return "EUC-JP"; + case "csiso2022jp": + case "iso-2022-jp": + return "ISO-2022-JP"; + case "csshiftjis": + case "ms932": + case "ms_kanji": + case "shift-jis": + case "shift_jis": + case "sjis": + case "windows-31j": + case "x-sjis": + return "Shift_JIS"; + case "cseuckr": + case "csksc56011987": + case "euc-kr": + case "iso-ir-149": + case "korean": + case "ks_c_5601-1987": + case "ks_c_5601-1989": + case "ksc5601": + case "ksc_5601": + case "windows-949": + return "EUC-KR"; + case "csiso2022kr": + case "hz-gb-2312": + case "iso-2022-cn": + case "iso-2022-cn-ext": + case "iso-2022-kr": + case "replacement": + return "replacement"; + case "unicodefffe": + case "utf-16be": + return "UTF-16BE"; + case "csunicode": + case "iso-10646-ucs-2": + case "ucs-2": + case "unicode": + case "unicodefeff": + case "utf-16": + case "utf-16le": + return "UTF-16LE"; + case "x-user-defined": + return "x-user-defined"; + default: + return "failure"; + } + } + module2.exports = { + getEncoding + }; + } +}); + +// node_modules/undici/lib/fileapi/util.js +var require_util4 = __commonJS({ + "node_modules/undici/lib/fileapi/util.js"(exports2, module2) { + "use strict"; + var { + kState, + kError, + kResult, + kAborted, + kLastProgressEventFired + } = require_symbols3(); + var { ProgressEvent } = require_progressevent(); + var { getEncoding } = require_encoding(); + var { DOMException: DOMException2 } = require_constants2(); + var { serializeAMimeType, parseMIMEType } = require_dataURL(); + var { types } = require("util"); + var { StringDecoder } = require("string_decoder"); + var { btoa } = require("buffer"); + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + function readOperation(fr, blob, type, encodingName) { + if (fr[kState] === "loading") { + throw new DOMException2("Invalid state", "InvalidStateError"); + } + fr[kState] = "loading"; + fr[kResult] = null; + fr[kError] = null; + const stream = blob.stream(); + const reader = stream.getReader(); + const bytes = []; + let chunkPromise = reader.read(); + let isFirstChunk = true; + (async () => { + while (!fr[kAborted]) { + try { + const { done, value } = await chunkPromise; + if (isFirstChunk && !fr[kAborted]) { + queueMicrotask(() => { + fireAProgressEvent("loadstart", fr); + }); + } + isFirstChunk = false; + if (!done && types.isUint8Array(value)) { + bytes.push(value); + if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) { + fr[kLastProgressEventFired] = Date.now(); + queueMicrotask(() => { + fireAProgressEvent("progress", fr); + }); + } + chunkPromise = reader.read(); + } else if (done) { + queueMicrotask(() => { + fr[kState] = "done"; + try { + const result = packageData(bytes, type, blob.type, encodingName); + if (fr[kAborted]) { + return; + } + fr[kResult] = result; + fireAProgressEvent("load", fr); + } catch (error) { + fr[kError] = error; + fireAProgressEvent("error", fr); + } + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } catch (error) { + if (fr[kAborted]) { + return; + } + queueMicrotask(() => { + fr[kState] = "done"; + fr[kError] = error; + fireAProgressEvent("error", fr); + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } + })(); + } + function fireAProgressEvent(e, reader) { + const event = new ProgressEvent(e, { + bubbles: false, + cancelable: false + }); + reader.dispatchEvent(event); + } + function packageData(bytes, type, mimeType, encodingName) { + switch (type) { + case "DataURL": { + let dataURL = "data:"; + const parsed = parseMIMEType(mimeType || "application/octet-stream"); + if (parsed !== "failure") { + dataURL += serializeAMimeType(parsed); + } + dataURL += ";base64,"; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + dataURL += btoa(decoder.write(chunk)); + } + dataURL += btoa(decoder.end()); + return dataURL; + } + case "Text": { + let encoding = "failure"; + if (encodingName) { + encoding = getEncoding(encodingName); + } + if (encoding === "failure" && mimeType) { + const type2 = parseMIMEType(mimeType); + if (type2 !== "failure") { + encoding = getEncoding(type2.parameters.get("charset")); + } + } + if (encoding === "failure") { + encoding = "UTF-8"; + } + return decode(bytes, encoding); + } + case "ArrayBuffer": { + const sequence = combineByteSequences(bytes); + return sequence.buffer; + } + case "BinaryString": { + let binaryString = ""; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + binaryString += decoder.write(chunk); + } + binaryString += decoder.end(); + return binaryString; + } + } + } + function decode(ioQueue, encoding) { + const bytes = combineByteSequences(ioQueue); + const BOMEncoding = BOMSniffing(bytes); + let slice = 0; + if (BOMEncoding !== null) { + encoding = BOMEncoding; + slice = BOMEncoding === "UTF-8" ? 3 : 2; + } + const sliced = bytes.slice(slice); + return new TextDecoder(encoding).decode(sliced); + } + function BOMSniffing(ioQueue) { + const [a, b, c] = ioQueue; + if (a === 239 && b === 187 && c === 191) { + return "UTF-8"; + } else if (a === 254 && b === 255) { + return "UTF-16BE"; + } else if (a === 255 && b === 254) { + return "UTF-16LE"; + } + return null; + } + function combineByteSequences(sequences) { + const size = sequences.reduce((a, b) => { + return a + b.byteLength; + }, 0); + let offset = 0; + return sequences.reduce((a, b) => { + a.set(b, offset); + offset += b.byteLength; + return a; + }, new Uint8Array(size)); + } + module2.exports = { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + }; + } +}); + +// node_modules/undici/lib/fileapi/filereader.js +var require_filereader = __commonJS({ + "node_modules/undici/lib/fileapi/filereader.js"(exports2, module2) { + "use strict"; + var { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + } = require_util4(); + var { + kState, + kError, + kResult, + kEvents, + kAborted + } = require_symbols3(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var FileReader = class _FileReader extends EventTarget { + constructor() { + super(); + this[kState] = "empty"; + this[kResult] = null; + this[kError] = null; + this[kEvents] = { + loadend: null, + error: null, + abort: null, + load: null, + progress: null, + loadstart: null + }; + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer + * @param {import('buffer').Blob} blob + */ + readAsArrayBuffer(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "ArrayBuffer"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsBinaryString + * @param {import('buffer').Blob} blob + */ + readAsBinaryString(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "BinaryString"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsDataText + * @param {import('buffer').Blob} blob + * @param {string?} encoding + */ + readAsText(blob, encoding = void 0) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" }); + blob = webidl.converters.Blob(blob, { strict: false }); + if (encoding !== void 0) { + encoding = webidl.converters.DOMString(encoding); + } + readOperation(this, blob, "Text", encoding); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL + * @param {import('buffer').Blob} blob + */ + readAsDataURL(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "DataURL"); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-abort + */ + abort() { + if (this[kState] === "empty" || this[kState] === "done") { + this[kResult] = null; + return; + } + if (this[kState] === "loading") { + this[kState] = "done"; + this[kResult] = null; + } + this[kAborted] = true; + fireAProgressEvent("abort", this); + if (this[kState] !== "loading") { + fireAProgressEvent("loadend", this); + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate + */ + get readyState() { + webidl.brandCheck(this, _FileReader); + switch (this[kState]) { + case "empty": + return this.EMPTY; + case "loading": + return this.LOADING; + case "done": + return this.DONE; + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-result + */ + get result() { + webidl.brandCheck(this, _FileReader); + return this[kResult]; + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-error + */ + get error() { + webidl.brandCheck(this, _FileReader); + return this[kError]; + } + get onloadend() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadend; + } + set onloadend(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadend) { + this.removeEventListener("loadend", this[kEvents].loadend); + } + if (typeof fn === "function") { + this[kEvents].loadend = fn; + this.addEventListener("loadend", fn); + } else { + this[kEvents].loadend = null; + } + } + get onerror() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].error; + } + set onerror(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].error) { + this.removeEventListener("error", this[kEvents].error); + } + if (typeof fn === "function") { + this[kEvents].error = fn; + this.addEventListener("error", fn); + } else { + this[kEvents].error = null; + } + } + get onloadstart() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadstart; + } + set onloadstart(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadstart) { + this.removeEventListener("loadstart", this[kEvents].loadstart); + } + if (typeof fn === "function") { + this[kEvents].loadstart = fn; + this.addEventListener("loadstart", fn); + } else { + this[kEvents].loadstart = null; + } + } + get onprogress() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].progress; + } + set onprogress(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].progress) { + this.removeEventListener("progress", this[kEvents].progress); + } + if (typeof fn === "function") { + this[kEvents].progress = fn; + this.addEventListener("progress", fn); + } else { + this[kEvents].progress = null; + } + } + get onload() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].load; + } + set onload(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].load) { + this.removeEventListener("load", this[kEvents].load); + } + if (typeof fn === "function") { + this[kEvents].load = fn; + this.addEventListener("load", fn); + } else { + this[kEvents].load = null; + } + } + get onabort() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].abort; + } + set onabort(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].abort) { + this.removeEventListener("abort", this[kEvents].abort); + } + if (typeof fn === "function") { + this[kEvents].abort = fn; + this.addEventListener("abort", fn); + } else { + this[kEvents].abort = null; + } + } + }; + FileReader.EMPTY = FileReader.prototype.EMPTY = 0; + FileReader.LOADING = FileReader.prototype.LOADING = 1; + FileReader.DONE = FileReader.prototype.DONE = 2; + Object.defineProperties(FileReader.prototype, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors, + readAsArrayBuffer: kEnumerableProperty, + readAsBinaryString: kEnumerableProperty, + readAsText: kEnumerableProperty, + readAsDataURL: kEnumerableProperty, + abort: kEnumerableProperty, + readyState: kEnumerableProperty, + result: kEnumerableProperty, + error: kEnumerableProperty, + onloadstart: kEnumerableProperty, + onprogress: kEnumerableProperty, + onload: kEnumerableProperty, + onabort: kEnumerableProperty, + onerror: kEnumerableProperty, + onloadend: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FileReader", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(FileReader, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors + }); + module2.exports = { + FileReader + }; + } +}); + +// node_modules/undici/lib/cache/symbols.js +var require_symbols4 = __commonJS({ + "node_modules/undici/lib/cache/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kConstruct: require_symbols().kConstruct + }; + } +}); + +// node_modules/undici/lib/cache/util.js +var require_util5 = __commonJS({ + "node_modules/undici/lib/cache/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { URLSerializer } = require_dataURL(); + var { isValidHeaderName } = require_util2(); + function urlEquals(A, B, excludeFragment = false) { + const serializedA = URLSerializer(A, excludeFragment); + const serializedB = URLSerializer(B, excludeFragment); + return serializedA === serializedB; + } + function fieldValues(header) { + assert(header !== null); + const values = []; + for (let value of header.split(",")) { + value = value.trim(); + if (!value.length) { + continue; + } else if (!isValidHeaderName(value)) { + continue; + } + values.push(value); + } + return values; + } + module2.exports = { + urlEquals, + fieldValues + }; + } +}); + +// node_modules/undici/lib/cache/cache.js +var require_cache = __commonJS({ + "node_modules/undici/lib/cache/cache.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { urlEquals, fieldValues: getFieldValues } = require_util5(); + var { kEnumerableProperty, isDisturbed } = require_util(); + var { kHeadersList } = require_symbols(); + var { webidl } = require_webidl(); + var { Response: Response2, cloneResponse } = require_response(); + var { Request } = require_request2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { fetching } = require_fetch(); + var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util2(); + var assert = require("assert"); + var { getGlobalDispatcher } = require_global2(); + var Cache = class _Cache { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list + * @type {requestResponseList} + */ + #relevantRequestResponseList; + constructor() { + if (arguments[0] !== kConstruct) { + webidl.illegalConstructor(); + } + this.#relevantRequestResponseList = arguments[1]; + } + async match(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.match" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + const p = await this.matchAll(request, options); + if (p.length === 0) { + return; + } + return p[0]; + } + async matchAll(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } + } + const responses = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + responses.push(requestResponse[1]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + responses.push(requestResponse[1]); + } + } + const responseList = []; + for (const response of responses) { + const responseObject = new Response2(response.body?.source ?? null); + const body = responseObject[kState].body; + responseObject[kState] = response; + responseObject[kState].body = body; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseList.push(responseObject); + } + return Object.freeze(responseList); + } + async add(request) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.add" }); + request = webidl.converters.RequestInfo(request); + const requests = [request]; + const responseArrayPromise = this.addAll(requests); + return await responseArrayPromise; + } + async addAll(requests) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.addAll" }); + requests = webidl.converters["sequence"](requests); + const responsePromises = []; + const requestList = []; + for (const request of requests) { + if (typeof request === "string") { + continue; + } + const r = request[kState]; + if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme when method is not GET." + }); + } + } + const fetchControllers = []; + for (const request of requests) { + const r = new Request(request)[kState]; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme." + }); + } + r.initiator = "fetch"; + r.destination = "subresource"; + requestList.push(r); + const responsePromise = createDeferredPromise(); + fetchControllers.push(fetching({ + request: r, + dispatcher: getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "Received an invalid status code or the request failed." + })); + } else if (response.headersList.contains("vary")) { + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "invalid vary field value" + })); + for (const controller of fetchControllers) { + controller.abort(); + } + return; + } + } + } + }, + processResponseEndOfBody(response) { + if (response.aborted) { + responsePromise.reject(new DOMException("aborted", "AbortError")); + return; + } + responsePromise.resolve(response); + } + })); + responsePromises.push(responsePromise.promise); + } + const p = Promise.all(responsePromises); + const responses = await p; + const operations = []; + let index = 0; + for (const response of responses) { + const operation = { + type: "put", + // 7.3.2 + request: requestList[index], + // 7.3.3 + response + // 7.3.4 + }; + operations.push(operation); + index++; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(void 0); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async put(request, response) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 2, { header: "Cache.put" }); + request = webidl.converters.RequestInfo(request); + response = webidl.converters.Response(response); + let innerRequest = null; + if (request instanceof Request) { + innerRequest = request[kState]; + } else { + innerRequest = new Request(request)[kState]; + } + if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Expected an http/s scheme when method is not GET" + }); + } + const innerResponse = response[kState]; + if (innerResponse.status === 206) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got 206 status" + }); + } + if (innerResponse.headersList.contains("vary")) { + const fieldValues = getFieldValues(innerResponse.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got * vary field value" + }); + } + } + } + if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Response body is locked or disturbed" + }); + } + const clonedResponse = cloneResponse(innerResponse); + const bodyReadPromise = createDeferredPromise(); + if (innerResponse.body != null) { + const stream = innerResponse.body.stream; + const reader = stream.getReader(); + readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject); + } else { + bodyReadPromise.resolve(void 0); + } + const operations = []; + const operation = { + type: "put", + // 14. + request: innerRequest, + // 15. + response: clonedResponse + // 16. + }; + operations.push(operation); + const bytes = await bodyReadPromise.promise; + if (clonedResponse.body != null) { + clonedResponse.body.source = bytes; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async delete(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.delete" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return false; + } + } else { + assert(typeof request === "string"); + r = new Request(request)[kState]; + } + const operations = []; + const operation = { + type: "delete", + request: r, + options + }; + operations.push(operation); + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + let requestResponses; + try { + requestResponses = this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(!!requestResponses?.length); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys + * @param {any} request + * @param {import('../../types/cache').CacheQueryOptions} options + * @returns {readonly Request[]} + */ + async keys(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } + } + const promise = createDeferredPromise(); + const requests = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + requests.push(requestResponse[0]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + requests.push(requestResponse[0]); + } + } + queueMicrotask(() => { + const requestList = []; + for (const request2 of requests) { + const requestObject = new Request("https://a"); + requestObject[kState] = request2; + requestObject[kHeaders][kHeadersList] = request2.headersList; + requestObject[kHeaders][kGuard] = "immutable"; + requestObject[kRealm] = request2.client; + requestList.push(requestObject); + } + promise.resolve(Object.freeze(requestList)); + }); + return promise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm + * @param {CacheBatchOperation[]} operations + * @returns {requestResponseList} + */ + #batchCacheOperations(operations) { + const cache = this.#relevantRequestResponseList; + const backupCache = [...cache]; + const addedItems = []; + const resultList = []; + try { + for (const operation of operations) { + if (operation.type !== "delete" && operation.type !== "put") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: 'operation type does not match "delete" or "put"' + }); + } + if (operation.type === "delete" && operation.response != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "delete operation should not have an associated response" + }); + } + if (this.#queryCache(operation.request, operation.options, addedItems).length) { + throw new DOMException("???", "InvalidStateError"); + } + let requestResponses; + if (operation.type === "delete") { + requestResponses = this.#queryCache(operation.request, operation.options); + if (requestResponses.length === 0) { + return []; + } + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + } else if (operation.type === "put") { + if (operation.response == null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "put operation should have an associated response" + }); + } + const r = operation.request; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "expected http or https scheme" + }); + } + if (r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "not get method" + }); + } + if (operation.options != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "options must not be defined" + }); + } + requestResponses = this.#queryCache(operation.request); + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + cache.push([operation.request, operation.response]); + addedItems.push([operation.request, operation.response]); + } + resultList.push([operation.request, operation.response]); + } + return resultList; + } catch (e) { + this.#relevantRequestResponseList.length = 0; + this.#relevantRequestResponseList = backupCache; + throw e; + } + } + /** + * @see https://w3c.github.io/ServiceWorker/#query-cache + * @param {any} requestQuery + * @param {import('../../types/cache').CacheQueryOptions} options + * @param {requestResponseList} targetStorage + * @returns {requestResponseList} + */ + #queryCache(requestQuery, options, targetStorage) { + const resultList = []; + const storage = targetStorage ?? this.#relevantRequestResponseList; + for (const requestResponse of storage) { + const [cachedRequest, cachedResponse] = requestResponse; + if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) { + resultList.push(requestResponse); + } + } + return resultList; + } + /** + * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm + * @param {any} requestQuery + * @param {any} request + * @param {any | null} response + * @param {import('../../types/cache').CacheQueryOptions | undefined} options + * @returns {boolean} + */ + #requestMatchesCachedItem(requestQuery, request, response = null, options) { + const queryURL = new URL(requestQuery.url); + const cachedURL = new URL(request.url); + if (options?.ignoreSearch) { + cachedURL.search = ""; + queryURL.search = ""; + } + if (!urlEquals(queryURL, cachedURL, true)) { + return false; + } + if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) { + return true; + } + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + return false; + } + const requestValue = request.headersList.get(fieldValue); + const queryValue = requestQuery.headersList.get(fieldValue); + if (requestValue !== queryValue) { + return false; + } + } + return true; + } + }; + Object.defineProperties(Cache.prototype, { + [Symbol.toStringTag]: { + value: "Cache", + configurable: true + }, + match: kEnumerableProperty, + matchAll: kEnumerableProperty, + add: kEnumerableProperty, + addAll: kEnumerableProperty, + put: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + var cacheQueryOptionConverters = [ + { + key: "ignoreSearch", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreMethod", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreVary", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters); + webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([ + ...cacheQueryOptionConverters, + { + key: "cacheName", + converter: webidl.converters.DOMString + } + ]); + webidl.converters.Response = webidl.interfaceConverter(Response2); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.RequestInfo + ); + module2.exports = { + Cache + }; + } +}); + +// node_modules/undici/lib/cache/cachestorage.js +var require_cachestorage = __commonJS({ + "node_modules/undici/lib/cache/cachestorage.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { Cache } = require_cache(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var CacheStorage = class _CacheStorage { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map + * @type {Map} + */ + async has(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.has" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.has(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open + * @param {string} cacheName + * @returns {Promise} + */ + async open(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.open" }); + cacheName = webidl.converters.DOMString(cacheName); + if (this.#caches.has(cacheName)) { + const cache2 = this.#caches.get(cacheName); + return new Cache(kConstruct, cache2); + } + const cache = []; + this.#caches.set(cacheName, cache); + return new Cache(kConstruct, cache); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete + * @param {string} cacheName + * @returns {Promise} + */ + async delete(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.delete" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.delete(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys + * @returns {string[]} + */ + async keys() { + webidl.brandCheck(this, _CacheStorage); + const keys = this.#caches.keys(); + return [...keys]; + } + }; + Object.defineProperties(CacheStorage.prototype, { + [Symbol.toStringTag]: { + value: "CacheStorage", + configurable: true + }, + match: kEnumerableProperty, + has: kEnumerableProperty, + open: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + module2.exports = { + CacheStorage + }; + } +}); + +// node_modules/undici/lib/cookies/constants.js +var require_constants4 = __commonJS({ + "node_modules/undici/lib/cookies/constants.js"(exports2, module2) { + "use strict"; + var maxAttributeValueSize = 1024; + var maxNameValuePairSize = 4096; + module2.exports = { + maxAttributeValueSize, + maxNameValuePairSize + }; + } +}); + +// node_modules/undici/lib/cookies/util.js +var require_util6 = __commonJS({ + "node_modules/undici/lib/cookies/util.js"(exports2, module2) { + "use strict"; + function isCTLExcludingHtab(value) { + if (value.length === 0) { + return false; + } + for (const char of value) { + const code = char.charCodeAt(0); + if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) { + return false; + } + } + } + function validateCookieName(name) { + for (const char of name) { + const code = char.charCodeAt(0); + if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") { + throw new Error("Invalid cookie name"); + } + } + } + function validateCookieValue(value) { + for (const char of value) { + const code = char.charCodeAt(0); + if (code < 33 || // exclude CTLs (0-31) + code === 34 || code === 44 || code === 59 || code === 92 || code > 126) { + throw new Error("Invalid header value"); + } + } + } + function validateCookiePath(path2) { + for (const char of path2) { + const code = char.charCodeAt(0); + if (code < 33 || char === ";") { + throw new Error("Invalid cookie path"); + } + } + } + function validateCookieDomain(domain) { + if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) { + throw new Error("Invalid cookie domain"); + } + } + function toIMFDate(date) { + if (typeof date === "number") { + date = new Date(date); + } + const days = [ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat" + ]; + const months = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + const dayName = days[date.getUTCDay()]; + const day = date.getUTCDate().toString().padStart(2, "0"); + const month = months[date.getUTCMonth()]; + const year = date.getUTCFullYear(); + const hour = date.getUTCHours().toString().padStart(2, "0"); + const minute = date.getUTCMinutes().toString().padStart(2, "0"); + const second = date.getUTCSeconds().toString().padStart(2, "0"); + return `${dayName}, ${day} ${month} ${year} ${hour}:${minute}:${second} GMT`; + } + function validateCookieMaxAge(maxAge) { + if (maxAge < 0) { + throw new Error("Invalid cookie max-age"); + } + } + function stringify2(cookie) { + if (cookie.name.length === 0) { + return null; + } + validateCookieName(cookie.name); + validateCookieValue(cookie.value); + const out = [`${cookie.name}=${cookie.value}`]; + if (cookie.name.startsWith("__Secure-")) { + cookie.secure = true; + } + if (cookie.name.startsWith("__Host-")) { + cookie.secure = true; + cookie.domain = null; + cookie.path = "/"; + } + if (cookie.secure) { + out.push("Secure"); + } + if (cookie.httpOnly) { + out.push("HttpOnly"); + } + if (typeof cookie.maxAge === "number") { + validateCookieMaxAge(cookie.maxAge); + out.push(`Max-Age=${cookie.maxAge}`); + } + if (cookie.domain) { + validateCookieDomain(cookie.domain); + out.push(`Domain=${cookie.domain}`); + } + if (cookie.path) { + validateCookiePath(cookie.path); + out.push(`Path=${cookie.path}`); + } + if (cookie.expires && cookie.expires.toString() !== "Invalid Date") { + out.push(`Expires=${toIMFDate(cookie.expires)}`); + } + if (cookie.sameSite) { + out.push(`SameSite=${cookie.sameSite}`); + } + for (const part of cookie.unparsed) { + if (!part.includes("=")) { + throw new Error("Invalid unparsed"); + } + const [key, ...value] = part.split("="); + out.push(`${key.trim()}=${value.join("=")}`); + } + return out.join("; "); + } + module2.exports = { + isCTLExcludingHtab, + validateCookieName, + validateCookiePath, + validateCookieValue, + toIMFDate, + stringify: stringify2 + }; + } +}); + +// node_modules/undici/lib/cookies/parse.js +var require_parse = __commonJS({ + "node_modules/undici/lib/cookies/parse.js"(exports2, module2) { + "use strict"; + var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4(); + var { isCTLExcludingHtab } = require_util6(); + var { collectASequenceOfCodePointsFast } = require_dataURL(); + var assert = require("assert"); + function parseSetCookie(header) { + if (isCTLExcludingHtab(header)) { + return null; + } + let nameValuePair = ""; + let unparsedAttributes = ""; + let name = ""; + let value = ""; + if (header.includes(";")) { + const position = { position: 0 }; + nameValuePair = collectASequenceOfCodePointsFast(";", header, position); + unparsedAttributes = header.slice(position.position); + } else { + nameValuePair = header; + } + if (!nameValuePair.includes("=")) { + value = nameValuePair; + } else { + const position = { position: 0 }; + name = collectASequenceOfCodePointsFast( + "=", + nameValuePair, + position + ); + value = nameValuePair.slice(position.position + 1); + } + name = name.trim(); + value = value.trim(); + if (name.length + value.length > maxNameValuePairSize) { + return null; + } + return { + name, + value, + ...parseUnparsedAttributes(unparsedAttributes) + }; + } + function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) { + if (unparsedAttributes.length === 0) { + return cookieAttributeList; + } + assert(unparsedAttributes[0] === ";"); + unparsedAttributes = unparsedAttributes.slice(1); + let cookieAv = ""; + if (unparsedAttributes.includes(";")) { + cookieAv = collectASequenceOfCodePointsFast( + ";", + unparsedAttributes, + { position: 0 } + ); + unparsedAttributes = unparsedAttributes.slice(cookieAv.length); + } else { + cookieAv = unparsedAttributes; + unparsedAttributes = ""; + } + let attributeName = ""; + let attributeValue = ""; + if (cookieAv.includes("=")) { + const position = { position: 0 }; + attributeName = collectASequenceOfCodePointsFast( + "=", + cookieAv, + position + ); + attributeValue = cookieAv.slice(position.position + 1); + } else { + attributeName = cookieAv; + } + attributeName = attributeName.trim(); + attributeValue = attributeValue.trim(); + if (attributeValue.length > maxAttributeValueSize) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const attributeNameLowercase = attributeName.toLowerCase(); + if (attributeNameLowercase === "expires") { + const expiryTime = new Date(attributeValue); + cookieAttributeList.expires = expiryTime; + } else if (attributeNameLowercase === "max-age") { + const charCode = attributeValue.charCodeAt(0); + if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + if (!/^\d+$/.test(attributeValue)) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const deltaSeconds = Number(attributeValue); + cookieAttributeList.maxAge = deltaSeconds; + } else if (attributeNameLowercase === "domain") { + let cookieDomain = attributeValue; + if (cookieDomain[0] === ".") { + cookieDomain = cookieDomain.slice(1); + } + cookieDomain = cookieDomain.toLowerCase(); + cookieAttributeList.domain = cookieDomain; + } else if (attributeNameLowercase === "path") { + let cookiePath = ""; + if (attributeValue.length === 0 || attributeValue[0] !== "/") { + cookiePath = "/"; + } else { + cookiePath = attributeValue; + } + cookieAttributeList.path = cookiePath; + } else if (attributeNameLowercase === "secure") { + cookieAttributeList.secure = true; + } else if (attributeNameLowercase === "httponly") { + cookieAttributeList.httpOnly = true; + } else if (attributeNameLowercase === "samesite") { + let enforcement = "Default"; + const attributeValueLowercase = attributeValue.toLowerCase(); + if (attributeValueLowercase.includes("none")) { + enforcement = "None"; + } + if (attributeValueLowercase.includes("strict")) { + enforcement = "Strict"; + } + if (attributeValueLowercase.includes("lax")) { + enforcement = "Lax"; + } + cookieAttributeList.sameSite = enforcement; + } else { + cookieAttributeList.unparsed ??= []; + cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`); + } + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + module2.exports = { + parseSetCookie, + parseUnparsedAttributes + }; + } +}); + +// node_modules/undici/lib/cookies/index.js +var require_cookies = __commonJS({ + "node_modules/undici/lib/cookies/index.js"(exports2, module2) { + "use strict"; + var { parseSetCookie } = require_parse(); + var { stringify: stringify2 } = require_util6(); + var { webidl } = require_webidl(); + var { Headers: Headers2 } = require_headers(); + function getCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookie = headers.get("cookie"); + const out = {}; + if (!cookie) { + return out; + } + for (const piece of cookie.split(";")) { + const [name, ...value] = piece.split("="); + out[name.trim()] = value.join("="); + } + return out; + } + function deleteCookie(headers, name, attributes) { + webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + name = webidl.converters.DOMString(name); + attributes = webidl.converters.DeleteCookieAttributes(attributes); + setCookie(headers, { + name, + value: "", + expires: /* @__PURE__ */ new Date(0), + ...attributes + }); + } + function getSetCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookies = headers.getSetCookie(); + if (!cookies) { + return []; + } + return cookies.map((pair) => parseSetCookie(pair)); + } + function setCookie(headers, cookie) { + webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + cookie = webidl.converters.Cookie(cookie); + const str = stringify2(cookie); + if (str) { + headers.append("Set-Cookie", stringify2(cookie)); + } + } + webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([ + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + } + ]); + webidl.converters.Cookie = webidl.dictionaryConverter([ + { + converter: webidl.converters.DOMString, + key: "name" + }, + { + converter: webidl.converters.DOMString, + key: "value" + }, + { + converter: webidl.nullableConverter((value) => { + if (typeof value === "number") { + return webidl.converters["unsigned long long"](value); + } + return new Date(value); + }), + key: "expires", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters["long long"]), + key: "maxAge", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "secure", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "httpOnly", + defaultValue: null + }, + { + converter: webidl.converters.USVString, + key: "sameSite", + allowedValues: ["Strict", "Lax", "None"] + }, + { + converter: webidl.sequenceConverter(webidl.converters.DOMString), + key: "unparsed", + defaultValue: [] + } + ]); + module2.exports = { + getCookies, + deleteCookie, + getSetCookies, + setCookie + }; + } +}); + +// node_modules/undici/lib/websocket/constants.js +var require_constants5 = __commonJS({ + "node_modules/undici/lib/websocket/constants.js"(exports2, module2) { + "use strict"; + var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + var states = { + CONNECTING: 0, + OPEN: 1, + CLOSING: 2, + CLOSED: 3 + }; + var opcodes = { + CONTINUATION: 0, + TEXT: 1, + BINARY: 2, + CLOSE: 8, + PING: 9, + PONG: 10 + }; + var maxUnsigned16Bit = 2 ** 16 - 1; + var parserStates = { + INFO: 0, + PAYLOADLENGTH_16: 2, + PAYLOADLENGTH_64: 3, + READ_DATA: 4 + }; + var emptyBuffer = Buffer.allocUnsafe(0); + module2.exports = { + uid, + staticPropertyDescriptors, + states, + opcodes, + maxUnsigned16Bit, + parserStates, + emptyBuffer + }; + } +}); + +// node_modules/undici/lib/websocket/symbols.js +var require_symbols5 = __commonJS({ + "node_modules/undici/lib/websocket/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kWebSocketURL: Symbol("url"), + kReadyState: Symbol("ready state"), + kController: Symbol("controller"), + kResponse: Symbol("response"), + kBinaryType: Symbol("binary type"), + kSentClose: Symbol("sent close"), + kReceivedClose: Symbol("received close"), + kByteParser: Symbol("byte parser") + }; + } +}); + +// node_modules/undici/lib/websocket/events.js +var require_events = __commonJS({ + "node_modules/undici/lib/websocket/events.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var { MessagePort } = require("worker_threads"); + var MessageEvent = class _MessageEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.MessageEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get data() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.data; + } + get origin() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.origin; + } + get lastEventId() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.lastEventId; + } + get source() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.source; + } + get ports() { + webidl.brandCheck(this, _MessageEvent); + if (!Object.isFrozen(this.#eventInit.ports)) { + Object.freeze(this.#eventInit.ports); + } + return this.#eventInit.ports; + } + initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) { + webidl.brandCheck(this, _MessageEvent); + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" }); + return new _MessageEvent(type, { + bubbles, + cancelable, + data, + origin, + lastEventId, + source, + ports + }); + } + }; + var CloseEvent = class _CloseEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.CloseEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get wasClean() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.wasClean; + } + get code() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.code; + } + get reason() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.reason; + } + }; + var ErrorEvent = class _ErrorEvent extends Event { + #eventInit; + constructor(type, eventInitDict) { + webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" }); + super(type, eventInitDict); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {}); + this.#eventInit = eventInitDict; + } + get message() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.message; + } + get filename() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.filename; + } + get lineno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.lineno; + } + get colno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.colno; + } + get error() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.error; + } + }; + Object.defineProperties(MessageEvent.prototype, { + [Symbol.toStringTag]: { + value: "MessageEvent", + configurable: true + }, + data: kEnumerableProperty, + origin: kEnumerableProperty, + lastEventId: kEnumerableProperty, + source: kEnumerableProperty, + ports: kEnumerableProperty, + initMessageEvent: kEnumerableProperty + }); + Object.defineProperties(CloseEvent.prototype, { + [Symbol.toStringTag]: { + value: "CloseEvent", + configurable: true + }, + reason: kEnumerableProperty, + code: kEnumerableProperty, + wasClean: kEnumerableProperty + }); + Object.defineProperties(ErrorEvent.prototype, { + [Symbol.toStringTag]: { + value: "ErrorEvent", + configurable: true + }, + message: kEnumerableProperty, + filename: kEnumerableProperty, + lineno: kEnumerableProperty, + colno: kEnumerableProperty, + error: kEnumerableProperty + }); + webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.MessagePort + ); + var eventInit = [ + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.MessageEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "data", + converter: webidl.converters.any, + defaultValue: null + }, + { + key: "origin", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lastEventId", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "source", + // Node doesn't implement WindowProxy or ServiceWorker, so the only + // valid value for source is a MessagePort. + converter: webidl.nullableConverter(webidl.converters.MessagePort), + defaultValue: null + }, + { + key: "ports", + converter: webidl.converters["sequence"], + get defaultValue() { + return []; + } + } + ]); + webidl.converters.CloseEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "wasClean", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "code", + converter: webidl.converters["unsigned short"], + defaultValue: 0 + }, + { + key: "reason", + converter: webidl.converters.USVString, + defaultValue: "" + } + ]); + webidl.converters.ErrorEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "message", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "filename", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lineno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "colno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "error", + converter: webidl.converters.any + } + ]); + module2.exports = { + MessageEvent, + CloseEvent, + ErrorEvent + }; + } +}); + +// node_modules/undici/lib/websocket/util.js +var require_util7 = __commonJS({ + "node_modules/undici/lib/websocket/util.js"(exports2, module2) { + "use strict"; + var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5(); + var { states, opcodes } = require_constants5(); + var { MessageEvent, ErrorEvent } = require_events(); + function isEstablished(ws) { + return ws[kReadyState] === states.OPEN; + } + function isClosing(ws) { + return ws[kReadyState] === states.CLOSING; + } + function isClosed(ws) { + return ws[kReadyState] === states.CLOSED; + } + function fireEvent(e, target, eventConstructor = Event, eventInitDict) { + const event = new eventConstructor(e, eventInitDict); + target.dispatchEvent(event); + } + function websocketMessageReceived(ws, type, data) { + if (ws[kReadyState] !== states.OPEN) { + return; + } + let dataForEvent; + if (type === opcodes.TEXT) { + try { + dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data); + } catch { + failWebsocketConnection(ws, "Received invalid UTF-8 in text frame."); + return; + } + } else if (type === opcodes.BINARY) { + if (ws[kBinaryType] === "blob") { + dataForEvent = new Blob([data]); + } else { + dataForEvent = new Uint8Array(data).buffer; + } + } + fireEvent("message", ws, MessageEvent, { + origin: ws[kWebSocketURL].origin, + data: dataForEvent + }); + } + function isValidSubprotocol(protocol) { + if (protocol.length === 0) { + return false; + } + for (const char of protocol) { + const code = char.charCodeAt(0); + if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP + code === 9) { + return false; + } + } + return true; + } + function isValidStatusCode(code) { + if (code >= 1e3 && code < 1015) { + return code !== 1004 && // reserved + code !== 1005 && // "MUST NOT be set as a status code" + code !== 1006; + } + return code >= 3e3 && code <= 4999; + } + function failWebsocketConnection(ws, reason) { + const { [kController]: controller, [kResponse]: response } = ws; + controller.abort(); + if (response?.socket && !response.socket.destroyed) { + response.socket.destroy(); + } + if (reason) { + fireEvent("error", ws, ErrorEvent, { + error: new Error(reason) + }); + } + } + module2.exports = { + isEstablished, + isClosing, + isClosed, + fireEvent, + isValidSubprotocol, + isValidStatusCode, + failWebsocketConnection, + websocketMessageReceived + }; + } +}); + +// node_modules/undici/lib/websocket/connection.js +var require_connection = __commonJS({ + "node_modules/undici/lib/websocket/connection.js"(exports2, module2) { + "use strict"; + var diagnosticsChannel = require("diagnostics_channel"); + var { uid, states } = require_constants5(); + var { + kReadyState, + kSentClose, + kByteParser, + kReceivedClose + } = require_symbols5(); + var { fireEvent, failWebsocketConnection } = require_util7(); + var { CloseEvent } = require_events(); + var { makeRequest } = require_request2(); + var { fetching } = require_fetch(); + var { Headers: Headers2 } = require_headers(); + var { getGlobalDispatcher } = require_global2(); + var { kHeadersList } = require_symbols(); + var channels = {}; + channels.open = diagnosticsChannel.channel("undici:websocket:open"); + channels.close = diagnosticsChannel.channel("undici:websocket:close"); + channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error"); + var crypto; + try { + crypto = require("crypto"); + } catch { + } + function establishWebSocketConnection(url, protocols, ws, onEstablish, options) { + const requestURL = url; + requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:"; + const request = makeRequest({ + urlList: [requestURL], + serviceWorkers: "none", + referrer: "no-referrer", + mode: "websocket", + credentials: "include", + cache: "no-store", + redirect: "error" + }); + if (options.headers) { + const headersList = new Headers2(options.headers)[kHeadersList]; + request.headersList = headersList; + } + const keyValue = crypto.randomBytes(16).toString("base64"); + request.headersList.append("sec-websocket-key", keyValue); + request.headersList.append("sec-websocket-version", "13"); + for (const protocol of protocols) { + request.headersList.append("sec-websocket-protocol", protocol); + } + const permessageDeflate = ""; + const controller = fetching({ + request, + useParallelQueue: true, + dispatcher: options.dispatcher ?? getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status !== 101) { + failWebsocketConnection(ws, "Received network error or non-101 status code."); + return; + } + if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Server did not respond with sent protocols."); + return; + } + if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") { + failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".'); + return; + } + if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") { + failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".'); + return; + } + const secWSAccept = response.headersList.get("Sec-WebSocket-Accept"); + const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64"); + if (secWSAccept !== digest) { + failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header."); + return; + } + const secExtension = response.headersList.get("Sec-WebSocket-Extensions"); + if (secExtension !== null && secExtension !== permessageDeflate) { + failWebsocketConnection(ws, "Received different permessage-deflate than the one set."); + return; + } + const secProtocol = response.headersList.get("Sec-WebSocket-Protocol"); + if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Protocol was not set in the opening handshake."); + return; + } + response.socket.on("data", onSocketData); + response.socket.on("close", onSocketClose); + response.socket.on("error", onSocketError); + if (channels.open.hasSubscribers) { + channels.open.publish({ + address: response.socket.address(), + protocol: secProtocol, + extensions: secExtension + }); + } + onEstablish(response); + } + }); + return controller; + } + function onSocketData(chunk) { + if (!this.ws[kByteParser].write(chunk)) { + this.pause(); + } + } + function onSocketClose() { + const { ws } = this; + const wasClean = ws[kSentClose] && ws[kReceivedClose]; + let code = 1005; + let reason = ""; + const result = ws[kByteParser].closingInfo; + if (result) { + code = result.code ?? 1005; + reason = result.reason; + } else if (!ws[kSentClose]) { + code = 1006; + } + ws[kReadyState] = states.CLOSED; + fireEvent("close", ws, CloseEvent, { + wasClean, + code, + reason + }); + if (channels.close.hasSubscribers) { + channels.close.publish({ + websocket: ws, + code, + reason + }); + } + } + function onSocketError(error) { + const { ws } = this; + ws[kReadyState] = states.CLOSING; + if (channels.socketError.hasSubscribers) { + channels.socketError.publish(error); + } + this.destroy(); + } + module2.exports = { + establishWebSocketConnection + }; + } +}); + +// node_modules/undici/lib/websocket/frame.js +var require_frame = __commonJS({ + "node_modules/undici/lib/websocket/frame.js"(exports2, module2) { + "use strict"; + var { maxUnsigned16Bit } = require_constants5(); + var crypto; + try { + crypto = require("crypto"); + } catch { + } + var WebsocketFrameSend = class { + /** + * @param {Buffer|undefined} data + */ + constructor(data) { + this.frameData = data; + this.maskKey = crypto.randomBytes(4); + } + createFrame(opcode) { + const bodyLength = this.frameData?.byteLength ?? 0; + let payloadLength = bodyLength; + let offset = 6; + if (bodyLength > maxUnsigned16Bit) { + offset += 8; + payloadLength = 127; + } else if (bodyLength > 125) { + offset += 2; + payloadLength = 126; + } + const buffer = Buffer.allocUnsafe(bodyLength + offset); + buffer[0] = buffer[1] = 0; + buffer[0] |= 128; + buffer[0] = (buffer[0] & 240) + opcode; + buffer[offset - 4] = this.maskKey[0]; + buffer[offset - 3] = this.maskKey[1]; + buffer[offset - 2] = this.maskKey[2]; + buffer[offset - 1] = this.maskKey[3]; + buffer[1] = payloadLength; + if (payloadLength === 126) { + buffer.writeUInt16BE(bodyLength, 2); + } else if (payloadLength === 127) { + buffer[2] = buffer[3] = 0; + buffer.writeUIntBE(bodyLength, 4, 6); + } + buffer[1] |= 128; + for (let i = 0; i < bodyLength; i++) { + buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4]; + } + return buffer; + } + }; + module2.exports = { + WebsocketFrameSend + }; + } +}); + +// node_modules/undici/lib/websocket/receiver.js +var require_receiver = __commonJS({ + "node_modules/undici/lib/websocket/receiver.js"(exports2, module2) { + "use strict"; + var { Writable } = require("stream"); + var diagnosticsChannel = require("diagnostics_channel"); + var { parserStates, opcodes, states, emptyBuffer } = require_constants5(); + var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5(); + var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util7(); + var { WebsocketFrameSend } = require_frame(); + var channels = {}; + channels.ping = diagnosticsChannel.channel("undici:websocket:ping"); + channels.pong = diagnosticsChannel.channel("undici:websocket:pong"); + var ByteParser = class extends Writable { + #buffers = []; + #byteOffset = 0; + #state = parserStates.INFO; + #info = {}; + #fragments = []; + constructor(ws) { + super(); + this.ws = ws; + } + /** + * @param {Buffer} chunk + * @param {() => void} callback + */ + _write(chunk, _, callback) { + this.#buffers.push(chunk); + this.#byteOffset += chunk.length; + this.run(callback); + } + /** + * Runs whenever a new chunk is received. + * Callback is called whenever there are no more chunks buffering, + * or not enough bytes are buffered to parse. + */ + run(callback) { + while (true) { + if (this.#state === parserStates.INFO) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.fin = (buffer[0] & 128) !== 0; + this.#info.opcode = buffer[0] & 15; + this.#info.originalOpcode ??= this.#info.opcode; + this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION; + if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) { + failWebsocketConnection(this.ws, "Invalid frame type was fragmented."); + return; + } + const payloadLength = buffer[1] & 127; + if (payloadLength <= 125) { + this.#info.payloadLength = payloadLength; + this.#state = parserStates.READ_DATA; + } else if (payloadLength === 126) { + this.#state = parserStates.PAYLOADLENGTH_16; + } else if (payloadLength === 127) { + this.#state = parserStates.PAYLOADLENGTH_64; + } + if (this.#info.fragmented && payloadLength > 125) { + failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes."); + return; + } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) { + failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes."); + return; + } else if (this.#info.opcode === opcodes.CLOSE) { + if (payloadLength === 1) { + failWebsocketConnection(this.ws, "Received close frame with a 1-byte body."); + return; + } + const body = this.consume(payloadLength); + this.#info.closeInfo = this.parseCloseBody(false, body); + if (!this.ws[kSentClose]) { + const body2 = Buffer.allocUnsafe(2); + body2.writeUInt16BE(this.#info.closeInfo.code, 0); + const closeFrame = new WebsocketFrameSend(body2); + this.ws[kResponse].socket.write( + closeFrame.createFrame(opcodes.CLOSE), + (err) => { + if (!err) { + this.ws[kSentClose] = true; + } + } + ); + } + this.ws[kReadyState] = states.CLOSING; + this.ws[kReceivedClose] = true; + this.end(); + return; + } else if (this.#info.opcode === opcodes.PING) { + const body = this.consume(payloadLength); + if (!this.ws[kReceivedClose]) { + const frame = new WebsocketFrameSend(body); + this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG)); + if (channels.ping.hasSubscribers) { + channels.ping.publish({ + payload: body + }); + } + } + this.#state = parserStates.INFO; + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } + } else if (this.#info.opcode === opcodes.PONG) { + const body = this.consume(payloadLength); + if (channels.pong.hasSubscribers) { + channels.pong.publish({ + payload: body + }); + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } + } + } else if (this.#state === parserStates.PAYLOADLENGTH_16) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.payloadLength = buffer.readUInt16BE(0); + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.PAYLOADLENGTH_64) { + if (this.#byteOffset < 8) { + return callback(); + } + const buffer = this.consume(8); + const upper = buffer.readUInt32BE(0); + if (upper > 2 ** 31 - 1) { + failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes."); + return; + } + const lower = buffer.readUInt32BE(4); + this.#info.payloadLength = (upper << 8) + lower; + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.READ_DATA) { + if (this.#byteOffset < this.#info.payloadLength) { + return callback(); + } else if (this.#byteOffset >= this.#info.payloadLength) { + const body = this.consume(this.#info.payloadLength); + this.#fragments.push(body); + if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) { + const fullMessage = Buffer.concat(this.#fragments); + websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage); + this.#info = {}; + this.#fragments.length = 0; + } + this.#state = parserStates.INFO; + } + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + break; + } + } + } + /** + * Take n bytes from the buffered Buffers + * @param {number} n + * @returns {Buffer|null} + */ + consume(n) { + if (n > this.#byteOffset) { + return null; + } else if (n === 0) { + return emptyBuffer; + } + if (this.#buffers[0].length === n) { + this.#byteOffset -= this.#buffers[0].length; + return this.#buffers.shift(); + } + const buffer = Buffer.allocUnsafe(n); + let offset = 0; + while (offset !== n) { + const next = this.#buffers[0]; + const { length } = next; + if (length + offset === n) { + buffer.set(this.#buffers.shift(), offset); + break; + } else if (length + offset > n) { + buffer.set(next.subarray(0, n - offset), offset); + this.#buffers[0] = next.subarray(n - offset); + break; + } else { + buffer.set(this.#buffers.shift(), offset); + offset += next.length; + } + } + this.#byteOffset -= n; + return buffer; + } + parseCloseBody(onlyCode, data) { + let code; + if (data.length >= 2) { + code = data.readUInt16BE(0); + } + if (onlyCode) { + if (!isValidStatusCode(code)) { + return null; + } + return { code }; + } + let reason = data.subarray(2); + if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) { + reason = reason.subarray(3); + } + if (code !== void 0 && !isValidStatusCode(code)) { + return null; + } + try { + reason = new TextDecoder("utf-8", { fatal: true }).decode(reason); + } catch { + return null; + } + return { code, reason }; + } + get closingInfo() { + return this.#info.closeInfo; + } + }; + module2.exports = { + ByteParser + }; + } +}); + +// node_modules/undici/lib/websocket/websocket.js +var require_websocket = __commonJS({ + "node_modules/undici/lib/websocket/websocket.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { DOMException: DOMException2 } = require_constants2(); + var { URLSerializer } = require_dataURL(); + var { getGlobalOrigin } = require_global(); + var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants5(); + var { + kWebSocketURL, + kReadyState, + kController, + kBinaryType, + kResponse, + kSentClose, + kByteParser + } = require_symbols5(); + var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util7(); + var { establishWebSocketConnection } = require_connection(); + var { WebsocketFrameSend } = require_frame(); + var { ByteParser } = require_receiver(); + var { kEnumerableProperty, isBlobLike: isBlobLike2 } = require_util(); + var { getGlobalDispatcher } = require_global2(); + var { types } = require("util"); + var experimentalWarned = false; + var WebSocket = class _WebSocket extends EventTarget { + #events = { + open: null, + error: null, + close: null, + message: null + }; + #bufferedAmount = 0; + #protocol = ""; + #extensions = ""; + /** + * @param {string} url + * @param {string|string[]} protocols + */ + constructor(url, protocols = []) { + super(); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" }); + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("WebSockets are experimental, expect them to change at any time.", { + code: "UNDICI-WS" + }); + } + const options = webidl.converters["DOMString or sequence or WebSocketInit"](protocols); + url = webidl.converters.USVString(url); + protocols = options.protocols; + const baseURL = getGlobalOrigin(); + let urlRecord; + try { + urlRecord = new URL(url, baseURL); + } catch (e) { + throw new DOMException2(e, "SyntaxError"); + } + if (urlRecord.protocol === "http:") { + urlRecord.protocol = "ws:"; + } else if (urlRecord.protocol === "https:") { + urlRecord.protocol = "wss:"; + } + if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") { + throw new DOMException2( + `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, + "SyntaxError" + ); + } + if (urlRecord.hash || urlRecord.href.endsWith("#")) { + throw new DOMException2("Got fragment", "SyntaxError"); + } + if (typeof protocols === "string") { + protocols = [protocols]; + } + if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + this[kWebSocketURL] = new URL(urlRecord.href); + this[kController] = establishWebSocketConnection( + urlRecord, + protocols, + this, + (response) => this.#onConnectionEstablished(response), + options + ); + this[kReadyState] = _WebSocket.CONNECTING; + this[kBinaryType] = "blob"; + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-close + * @param {number|undefined} code + * @param {string|undefined} reason + */ + close(code = void 0, reason = void 0) { + webidl.brandCheck(this, _WebSocket); + if (code !== void 0) { + code = webidl.converters["unsigned short"](code, { clamp: true }); + } + if (reason !== void 0) { + reason = webidl.converters.USVString(reason); + } + if (code !== void 0) { + if (code !== 1e3 && (code < 3e3 || code > 4999)) { + throw new DOMException2("invalid code", "InvalidAccessError"); + } + } + let reasonByteLength = 0; + if (reason !== void 0) { + reasonByteLength = Buffer.byteLength(reason); + if (reasonByteLength > 123) { + throw new DOMException2( + `Reason must be less than 123 bytes; received ${reasonByteLength}`, + "SyntaxError" + ); + } + } + if (this[kReadyState] === _WebSocket.CLOSING || this[kReadyState] === _WebSocket.CLOSED) { + } else if (!isEstablished(this)) { + failWebsocketConnection(this, "Connection was closed before it was established."); + this[kReadyState] = _WebSocket.CLOSING; + } else if (!isClosing(this)) { + const frame = new WebsocketFrameSend(); + if (code !== void 0 && reason === void 0) { + frame.frameData = Buffer.allocUnsafe(2); + frame.frameData.writeUInt16BE(code, 0); + } else if (code !== void 0 && reason !== void 0) { + frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength); + frame.frameData.writeUInt16BE(code, 0); + frame.frameData.write(reason, 2, "utf-8"); + } else { + frame.frameData = emptyBuffer; + } + const socket = this[kResponse].socket; + socket.write(frame.createFrame(opcodes.CLOSE), (err) => { + if (!err) { + this[kSentClose] = true; + } + }); + this[kReadyState] = states.CLOSING; + } else { + this[kReadyState] = _WebSocket.CLOSING; + } + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-send + * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data + */ + send(data) { + webidl.brandCheck(this, _WebSocket); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" }); + data = webidl.converters.WebSocketSendData(data); + if (this[kReadyState] === _WebSocket.CONNECTING) { + throw new DOMException2("Sent before connected.", "InvalidStateError"); + } + if (!isEstablished(this) || isClosing(this)) { + return; + } + const socket = this[kResponse].socket; + if (typeof data === "string") { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.TEXT); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (types.isArrayBuffer(data)) { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (ArrayBuffer.isView(data)) { + const ab = Buffer.from(data, data.byteOffset, data.byteLength); + const frame = new WebsocketFrameSend(ab); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += ab.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= ab.byteLength; + }); + } else if (isBlobLike2(data)) { + const frame = new WebsocketFrameSend(); + data.arrayBuffer().then((ab) => { + const value = Buffer.from(ab); + frame.frameData = value; + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + }); + } + } + get readyState() { + webidl.brandCheck(this, _WebSocket); + return this[kReadyState]; + } + get bufferedAmount() { + webidl.brandCheck(this, _WebSocket); + return this.#bufferedAmount; + } + get url() { + webidl.brandCheck(this, _WebSocket); + return URLSerializer(this[kWebSocketURL]); + } + get extensions() { + webidl.brandCheck(this, _WebSocket); + return this.#extensions; + } + get protocol() { + webidl.brandCheck(this, _WebSocket); + return this.#protocol; + } + get onopen() { + webidl.brandCheck(this, _WebSocket); + return this.#events.open; + } + set onopen(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.open) { + this.removeEventListener("open", this.#events.open); + } + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else { + this.#events.open = null; + } + } + get onerror() { + webidl.brandCheck(this, _WebSocket); + return this.#events.error; + } + set onerror(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.error) { + this.removeEventListener("error", this.#events.error); + } + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else { + this.#events.error = null; + } + } + get onclose() { + webidl.brandCheck(this, _WebSocket); + return this.#events.close; + } + set onclose(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.close) { + this.removeEventListener("close", this.#events.close); + } + if (typeof fn === "function") { + this.#events.close = fn; + this.addEventListener("close", fn); + } else { + this.#events.close = null; + } + } + get onmessage() { + webidl.brandCheck(this, _WebSocket); + return this.#events.message; + } + set onmessage(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.message) { + this.removeEventListener("message", this.#events.message); + } + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else { + this.#events.message = null; + } + } + get binaryType() { + webidl.brandCheck(this, _WebSocket); + return this[kBinaryType]; + } + set binaryType(type) { + webidl.brandCheck(this, _WebSocket); + if (type !== "blob" && type !== "arraybuffer") { + this[kBinaryType] = "blob"; + } else { + this[kBinaryType] = type; + } + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + */ + #onConnectionEstablished(response) { + this[kResponse] = response; + const parser = new ByteParser(this); + parser.on("drain", function onParserDrain() { + this.ws[kResponse].socket.resume(); + }); + response.socket.ws = this; + this[kByteParser] = parser; + this[kReadyState] = states.OPEN; + const extensions = response.headersList.get("sec-websocket-extensions"); + if (extensions !== null) { + this.#extensions = extensions; + } + const protocol = response.headersList.get("sec-websocket-protocol"); + if (protocol !== null) { + this.#protocol = protocol; + } + fireEvent("open", this); + } + }; + WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING; + WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN; + WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING; + WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED; + Object.defineProperties(WebSocket.prototype, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors, + url: kEnumerableProperty, + readyState: kEnumerableProperty, + bufferedAmount: kEnumerableProperty, + onopen: kEnumerableProperty, + onerror: kEnumerableProperty, + onclose: kEnumerableProperty, + close: kEnumerableProperty, + onmessage: kEnumerableProperty, + binaryType: kEnumerableProperty, + send: kEnumerableProperty, + extensions: kEnumerableProperty, + protocol: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "WebSocket", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(WebSocket, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors + }); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.DOMString + ); + webidl.converters["DOMString or sequence"] = function(V) { + if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) { + return webidl.converters["sequence"](V); + } + return webidl.converters.DOMString(V); + }; + webidl.converters.WebSocketInit = webidl.dictionaryConverter([ + { + key: "protocols", + converter: webidl.converters["DOMString or sequence"], + get defaultValue() { + return []; + } + }, + { + key: "dispatcher", + converter: (V) => V, + get defaultValue() { + return getGlobalDispatcher(); + } + }, + { + key: "headers", + converter: webidl.nullableConverter(webidl.converters.HeadersInit) + } + ]); + webidl.converters["DOMString or sequence or WebSocketInit"] = function(V) { + if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) { + return webidl.converters.WebSocketInit(V); + } + return { protocols: webidl.converters["DOMString or sequence"](V) }; + }; + webidl.converters.WebSocketSendData = function(V) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V); + } + } + return webidl.converters.USVString(V); + }; + module2.exports = { + WebSocket + }; + } +}); + +// node_modules/undici/index.js +var require_undici = __commonJS({ + "node_modules/undici/index.js"(exports2, module2) { + "use strict"; + var Client = require_client(); + var Dispatcher = require_dispatcher(); + var errors = require_errors(); + var Pool = require_pool(); + var BalancedPool = require_balanced_pool(); + var Agent = require_agent(); + var util = require_util(); + var { InvalidArgumentError } = errors; + var api = require_api(); + var buildConnector = require_connect(); + var MockClient = require_mock_client(); + var MockAgent = require_mock_agent(); + var MockPool = require_mock_pool(); + var mockErrors = require_mock_errors(); + var ProxyAgent = require_proxy_agent(); + var RetryHandler = require_RetryHandler(); + var { getGlobalDispatcher, setGlobalDispatcher } = require_global2(); + var DecoratorHandler = require_DecoratorHandler(); + var RedirectHandler = require_RedirectHandler(); + var createRedirectInterceptor = require_redirectInterceptor(); + var hasCrypto; + try { + require("crypto"); + hasCrypto = true; + } catch { + hasCrypto = false; + } + Object.assign(Dispatcher.prototype, api); + module2.exports.Dispatcher = Dispatcher; + module2.exports.Client = Client; + module2.exports.Pool = Pool; + module2.exports.BalancedPool = BalancedPool; + module2.exports.Agent = Agent; + module2.exports.ProxyAgent = ProxyAgent; + module2.exports.RetryHandler = RetryHandler; + module2.exports.DecoratorHandler = DecoratorHandler; + module2.exports.RedirectHandler = RedirectHandler; + module2.exports.createRedirectInterceptor = createRedirectInterceptor; + module2.exports.buildConnector = buildConnector; + module2.exports.errors = errors; + function makeDispatcher(fn) { + return (url, opts, handler) => { + if (typeof opts === "function") { + handler = opts; + opts = null; + } + if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) { + throw new InvalidArgumentError("invalid url"); + } + if (opts != null && typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (opts && opts.path != null) { + if (typeof opts.path !== "string") { + throw new InvalidArgumentError("invalid opts.path"); + } + let path2 = opts.path; + if (!opts.path.startsWith("/")) { + path2 = `/${path2}`; + } + url = new URL(util.parseOrigin(url).origin + path2); + } else { + if (!opts) { + opts = typeof url === "object" ? url : {}; + } + url = util.parseURL(url); + } + const { agent, dispatcher = getGlobalDispatcher() } = opts; + if (agent) { + throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?"); + } + return fn.call(dispatcher, { + ...opts, + origin: url.origin, + path: url.search ? `${url.pathname}${url.search}` : url.pathname, + method: opts.method || (opts.body ? "PUT" : "GET") + }, handler); + }; + } + module2.exports.setGlobalDispatcher = setGlobalDispatcher; + module2.exports.getGlobalDispatcher = getGlobalDispatcher; + if (util.nodeMajor > 16 || util.nodeMajor === 16 && util.nodeMinor >= 8) { + let fetchImpl = null; + module2.exports.fetch = async function fetch2(resource) { + if (!fetchImpl) { + fetchImpl = require_fetch().fetch; + } + try { + return await fetchImpl(...arguments); + } catch (err) { + if (typeof err === "object") { + Error.captureStackTrace(err, this); + } + throw err; + } + }; + module2.exports.Headers = require_headers().Headers; + module2.exports.Response = require_response().Response; + module2.exports.Request = require_request2().Request; + module2.exports.FormData = require_formdata().FormData; + module2.exports.File = require_file().File; + module2.exports.FileReader = require_filereader().FileReader; + const { setGlobalOrigin, getGlobalOrigin } = require_global(); + module2.exports.setGlobalOrigin = setGlobalOrigin; + module2.exports.getGlobalOrigin = getGlobalOrigin; + const { CacheStorage } = require_cachestorage(); + const { kConstruct } = require_symbols4(); + module2.exports.caches = new CacheStorage(kConstruct); + } + if (util.nodeMajor >= 16) { + const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies(); + module2.exports.deleteCookie = deleteCookie; + module2.exports.getCookies = getCookies; + module2.exports.getSetCookies = getSetCookies; + module2.exports.setCookie = setCookie; + const { parseMIMEType, serializeAMimeType } = require_dataURL(); + module2.exports.parseMIMEType = parseMIMEType; + module2.exports.serializeAMimeType = serializeAMimeType; + } + if (util.nodeMajor >= 18 && hasCrypto) { + const { WebSocket } = require_websocket(); + module2.exports.WebSocket = WebSocket; + } + module2.exports.request = makeDispatcher(api.request); + module2.exports.stream = makeDispatcher(api.stream); + module2.exports.pipeline = makeDispatcher(api.pipeline); + module2.exports.connect = makeDispatcher(api.connect); + module2.exports.upgrade = makeDispatcher(api.upgrade); + module2.exports.MockClient = MockClient; + module2.exports.MockPool = MockPool; + module2.exports.MockAgent = MockAgent; + module2.exports.mockErrors = mockErrors; + } +}); + +// node_modules/@actions/http-client/lib/index.js +var require_lib = __commonJS({ + "node_modules/@actions/http-client/lib/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.HttpClient = exports2.isHttps = exports2.HttpClientResponse = exports2.HttpClientError = exports2.getProxyUrl = exports2.MediaTypes = exports2.Headers = exports2.HttpCodes = void 0; + var http = __importStar(require("http")); + var https = __importStar(require("https")); + var pm = __importStar(require_proxy()); + var tunnel = __importStar(require_tunnel2()); + var undici_1 = require_undici(); + var HttpCodes; + (function(HttpCodes2) { + HttpCodes2[HttpCodes2["OK"] = 200] = "OK"; + HttpCodes2[HttpCodes2["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes2[HttpCodes2["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes2[HttpCodes2["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes2[HttpCodes2["SeeOther"] = 303] = "SeeOther"; + HttpCodes2[HttpCodes2["NotModified"] = 304] = "NotModified"; + HttpCodes2[HttpCodes2["UseProxy"] = 305] = "UseProxy"; + HttpCodes2[HttpCodes2["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes2[HttpCodes2["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes2[HttpCodes2["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes2[HttpCodes2["BadRequest"] = 400] = "BadRequest"; + HttpCodes2[HttpCodes2["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes2[HttpCodes2["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes2[HttpCodes2["Forbidden"] = 403] = "Forbidden"; + HttpCodes2[HttpCodes2["NotFound"] = 404] = "NotFound"; + HttpCodes2[HttpCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes2[HttpCodes2["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes2[HttpCodes2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes2[HttpCodes2["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes2[HttpCodes2["Conflict"] = 409] = "Conflict"; + HttpCodes2[HttpCodes2["Gone"] = 410] = "Gone"; + HttpCodes2[HttpCodes2["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes2[HttpCodes2["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes2[HttpCodes2["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes2[HttpCodes2["BadGateway"] = 502] = "BadGateway"; + HttpCodes2[HttpCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes2[HttpCodes2["GatewayTimeout"] = 504] = "GatewayTimeout"; + })(HttpCodes || (exports2.HttpCodes = HttpCodes = {})); + var Headers2; + (function(Headers3) { + Headers3["Accept"] = "accept"; + Headers3["ContentType"] = "content-type"; + })(Headers2 || (exports2.Headers = Headers2 = {})); + var MediaTypes; + (function(MediaTypes2) { + MediaTypes2["ApplicationJson"] = "application/json"; + })(MediaTypes || (exports2.MediaTypes = MediaTypes = {})); + function getProxyUrl(serverUrl) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ""; + } + exports2.getProxyUrl = getProxyUrl; + var HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect + ]; + var HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout + ]; + var RetryableHttpVerbs = ["OPTIONS", "GET", "DELETE", "HEAD"]; + var ExponentialBackoffCeiling = 10; + var ExponentialBackoffTimeSlice = 5; + var HttpClientError = class _HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = "HttpClientError"; + this.statusCode = statusCode; + Object.setPrototypeOf(this, _HttpClientError.prototype); + } + }; + exports2.HttpClientError = HttpClientError; + var HttpClientResponse = class { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + let output = Buffer.alloc(0); + this.message.on("data", (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on("end", () => { + resolve(output.toString()); + }); + })); + }); + } + readBodyBuffer() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + const chunks = []; + this.message.on("data", (chunk) => { + chunks.push(chunk); + }); + this.message.on("end", () => { + resolve(Buffer.concat(chunks)); + }); + })); + }); + } + }; + exports2.HttpClientResponse = HttpClientResponse; + function isHttps(requestUrl) { + const parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === "https:"; + } + exports2.isHttps = isHttps; + var HttpClient = class { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("OPTIONS", requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("GET", requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("DELETE", requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("POST", requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PATCH", requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PUT", requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("HEAD", requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request(verb, requestUrl, stream, additionalHeaders); + }); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + getJson(requestUrl, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error("Client has already been disposed."); + } + const parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info, data); + if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) { + if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } else { + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) { + const redirectUrl = response.message.headers["location"]; + if (!redirectUrl) { + break; + } + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) { + throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true."); + } + yield response.readBody(); + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) { + if (header.toLowerCase() === "authorization") { + delete headers[header]; + } + } + } + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) { + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) { + reject(err); + } else if (!res) { + reject(new Error("Unknown error")); + } else { + resolve(res); + } + } + this.requestRawWithCallback(info, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + if (typeof data === "string") { + if (!info.options.headers) { + info.options.headers = {}; + } + info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8"); + } + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + } + const req = info.httpModule.request(info.options, (msg) => { + const res = new HttpClientResponse(msg); + handleResult(void 0, res); + }); + let socket; + req.on("socket", (sock) => { + socket = sock; + }); + req.setTimeout(this._socketTimeout || 3 * 6e4, () => { + if (socket) { + socket.end(); + } + handleResult(new Error(`Request timeout: ${info.options.path}`)); + }); + req.on("error", function(err) { + handleResult(err); + }); + if (data && typeof data === "string") { + req.write(data, "utf8"); + } + if (data && typeof data !== "string") { + data.on("close", function() { + req.end(); + }); + data.pipe(req); + } else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + getAgentDispatcher(serverUrl) { + const parsedUrl = new URL(serverUrl); + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (!useProxy) { + return; + } + return this._getProxyAgentDispatcher(parsedUrl, proxyUrl); + } + _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); + if (this.handlers) { + for (const handler of this.handlers) { + handler.prepareRequest(info.options); + } + } + return info; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (!useProxy) { + agent = this._agent; + } + if (agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === "https:"; + let maxSockets = 100; + if (this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + }), { host: proxyUrl.hostname, port: proxyUrl.port }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === "https:"; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + if (!agent) { + const options = { keepAlive: this._keepAlive, maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + if (usingSsl && this._ignoreSslError) { + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _getProxyAgentDispatcher(parsedUrl, proxyUrl) { + let proxyAgent; + if (this._keepAlive) { + proxyAgent = this._proxyAgentDispatcher; + } + if (proxyAgent) { + return proxyAgent; + } + const usingSsl = parsedUrl.protocol === "https:"; + proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, (proxyUrl.username || proxyUrl.password) && { + token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}` + })); + this._proxyAgentDispatcher = proxyAgent; + if (usingSsl && this._ignoreSslError) { + proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { + rejectUnauthorized: false + }); + } + return proxyAgent; + } + _performExponentialBackoff(retryNumber) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise((resolve) => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + if (statusCode === HttpCodes.NotFound) { + resolve(response); + } + function dateTimeDeserializer(key, value) { + if (typeof value === "string") { + const a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, dateTimeDeserializer); + } else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } catch (err) { + } + if (statusCode > 299) { + let msg; + if (obj && obj.message) { + msg = obj.message; + } else if (contents && contents.length > 0) { + msg = contents; + } else { + msg = `Failed request: (${statusCode})`; + } + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } else { + resolve(response); + } + })); + }); + } + }; + exports2.HttpClient = HttpClient; + var lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); + } +}); + +// node_modules/@actions/http-client/lib/auth.js +var require_auth = __commonJS({ + "node_modules/@actions/http-client/lib/auth.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.PersonalAccessTokenCredentialHandler = exports2.BearerCredentialHandler = exports2.BasicCredentialHandler = void 0; + var BasicCredentialHandler = class { + constructor(username, password) { + this.username = username; + this.password = password; + } + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BasicCredentialHandler = BasicCredentialHandler; + var BearerCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Bearer ${this.token}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BearerCredentialHandler = BearerCredentialHandler; + var PersonalAccessTokenCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Basic ${Buffer.from(`PAT:${this.token}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; + } +}); + +// node_modules/@actions/core/lib/oidc-utils.js +var require_oidc_utils = __commonJS({ + "node_modules/@actions/core/lib/oidc-utils.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.OidcClient = void 0; + var http_client_1 = require_lib(); + var auth_1 = require_auth(); + var core_1 = require_core(); + var OidcClient = class _OidcClient { + static createHttpClient(allowRetry = true, maxRetry = 10) { + const requestOptions = { + allowRetries: allowRetry, + maxRetries: maxRetry + }; + return new http_client_1.HttpClient("actions/oidc-client", [new auth_1.BearerCredentialHandler(_OidcClient.getRequestToken())], requestOptions); + } + static getRequestToken() { + const token = process.env["ACTIONS_ID_TOKEN_REQUEST_TOKEN"]; + if (!token) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable"); + } + return token; + } + static getIDTokenUrl() { + const runtimeUrl = process.env["ACTIONS_ID_TOKEN_REQUEST_URL"]; + if (!runtimeUrl) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable"); + } + return runtimeUrl; + } + static getCall(id_token_url) { + var _a2; + return __awaiter(this, void 0, void 0, function* () { + const httpclient = _OidcClient.createHttpClient(); + const res = yield httpclient.getJson(id_token_url).catch((error) => { + throw new Error(`Failed to get ID Token. + + Error Code : ${error.statusCode} + + Error Message: ${error.message}`); + }); + const id_token = (_a2 = res.result) === null || _a2 === void 0 ? void 0 : _a2.value; + if (!id_token) { + throw new Error("Response json body do not have ID Token field"); + } + return id_token; + }); + } + static getIDToken(audience) { + return __awaiter(this, void 0, void 0, function* () { + try { + let id_token_url = _OidcClient.getIDTokenUrl(); + if (audience) { + const encodedAudience = encodeURIComponent(audience); + id_token_url = `${id_token_url}&audience=${encodedAudience}`; + } + (0, core_1.debug)(`ID token url is ${id_token_url}`); + const id_token = yield _OidcClient.getCall(id_token_url); + (0, core_1.setSecret)(id_token); + return id_token; + } catch (error) { + throw new Error(`Error message: ${error.message}`); + } + }); + } + }; + exports2.OidcClient = OidcClient; + } +}); + +// node_modules/@actions/core/lib/summary.js +var require_summary = __commonJS({ + "node_modules/@actions/core/lib/summary.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.summary = exports2.markdownSummary = exports2.SUMMARY_DOCS_URL = exports2.SUMMARY_ENV_VAR = void 0; + var os_1 = require("os"); + var fs_1 = require("fs"); + var { access, appendFile, writeFile } = fs_1.promises; + exports2.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY"; + exports2.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary"; + var Summary = class { + constructor() { + this._buffer = ""; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[exports2.SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${exports2.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); + } catch (_a2) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join(""); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance + */ + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: "utf8" }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ""; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(os_1.EOL); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, lang && { lang }); + const element = this.wrap("pre", this.wrap("code", code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? "ol" : "ul"; + const listItems = items.map((item) => this.wrap("li", item)).join(""); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows.map((row) => { + const cells = row.map((cell) => { + if (typeof cell === "string") { + return this.wrap("td", cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? "th" : "td"; + const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan }); + return this.wrap(tag, data, attrs); + }).join(""); + return this.wrap("tr", cells); + }).join(""); + const element = this.wrap("table", tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap("details", this.wrap("summary", label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, width && { width }), height && { height }); + const element = this.wrap("img", null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) ? tag : "h1"; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap("hr", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap("br", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, cite && { cite }); + const element = this.wrap("blockquote", text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap("a", text, { href }); + return this.addRaw(element).addEOL(); + } + }; + var _summary = new Summary(); + exports2.markdownSummary = _summary; + exports2.summary = _summary; + } +}); + +// node_modules/@actions/core/lib/path-utils.js +var require_path_utils = __commonJS({ + "node_modules/@actions/core/lib/path-utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = void 0; + var path2 = __importStar(require("path")); + function toPosixPath(pth) { + return pth.replace(/[\\]/g, "/"); + } + exports2.toPosixPath = toPosixPath; + function toWin32Path(pth) { + return pth.replace(/[/]/g, "\\"); + } + exports2.toWin32Path = toWin32Path; + function toPlatformPath(pth) { + return pth.replace(/[/\\]/g, path2.sep); + } + exports2.toPlatformPath = toPlatformPath; + } +}); + +// node_modules/@actions/io/lib/io-util.js +var require_io_util = __commonJS({ + "node_modules/@actions/io/lib/io-util.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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 _a2; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getCmdPath = exports2.tryGetExecutablePath = exports2.isRooted = exports2.isDirectory = exports2.exists = exports2.READONLY = exports2.UV_FS_O_EXLOCK = exports2.IS_WINDOWS = exports2.unlink = exports2.symlink = exports2.stat = exports2.rmdir = exports2.rm = exports2.rename = exports2.readlink = exports2.readdir = exports2.open = exports2.mkdir = exports2.lstat = exports2.copyFile = exports2.chmod = void 0; + var fs2 = __importStar(require("fs")); + var path2 = __importStar(require("path")); + _a2 = fs2.promises, exports2.chmod = _a2.chmod, exports2.copyFile = _a2.copyFile, exports2.lstat = _a2.lstat, exports2.mkdir = _a2.mkdir, exports2.open = _a2.open, exports2.readdir = _a2.readdir, exports2.readlink = _a2.readlink, exports2.rename = _a2.rename, exports2.rm = _a2.rm, exports2.rmdir = _a2.rmdir, exports2.stat = _a2.stat, exports2.symlink = _a2.symlink, exports2.unlink = _a2.unlink; + exports2.IS_WINDOWS = process.platform === "win32"; + exports2.UV_FS_O_EXLOCK = 268435456; + exports2.READONLY = fs2.constants.O_RDONLY; + function exists(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + try { + yield exports2.stat(fsPath); + } catch (err) { + if (err.code === "ENOENT") { + return false; + } + throw err; + } + return true; + }); + } + exports2.exists = exists; + function isDirectory(fsPath, useStat = false) { + return __awaiter(this, void 0, void 0, function* () { + const stats = useStat ? yield exports2.stat(fsPath) : yield exports2.lstat(fsPath); + return stats.isDirectory(); + }); + } + exports2.isDirectory = isDirectory; + function isRooted(p) { + p = normalizeSeparators(p); + if (!p) { + throw new Error('isRooted() parameter "p" cannot be empty'); + } + if (exports2.IS_WINDOWS) { + return p.startsWith("\\") || /^[A-Z]:/i.test(p); + } + return p.startsWith("/"); + } + exports2.isRooted = isRooted; + function tryGetExecutablePath(filePath, extensions) { + return __awaiter(this, void 0, void 0, function* () { + let stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + const upperExt = path2.extname(filePath).toUpperCase(); + if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) { + return filePath; + } + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + const originalFilePath = filePath; + for (const extension of extensions) { + filePath = originalFilePath + extension; + stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + try { + const directory = path2.dirname(filePath); + const upperName = path2.basename(filePath).toUpperCase(); + for (const actualName of yield exports2.readdir(directory)) { + if (upperName === actualName.toUpperCase()) { + filePath = path2.join(directory, actualName); + break; + } + } + } catch (err) { + console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); + } + return filePath; + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + } + return ""; + }); + } + exports2.tryGetExecutablePath = tryGetExecutablePath; + function normalizeSeparators(p) { + p = p || ""; + if (exports2.IS_WINDOWS) { + p = p.replace(/\//g, "\\"); + return p.replace(/\\\\+/g, "\\"); + } + return p.replace(/\/\/+/g, "/"); + } + function isUnixExecutable(stats) { + return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid(); + } + function getCmdPath() { + var _a3; + return (_a3 = process.env["COMSPEC"]) !== null && _a3 !== void 0 ? _a3 : `cmd.exe`; + } + exports2.getCmdPath = getCmdPath; + } +}); + +// node_modules/@actions/io/lib/io.js +var require_io = __commonJS({ + "node_modules/@actions/io/lib/io.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.findInPath = exports2.which = exports2.mkdirP = exports2.rmRF = exports2.mv = exports2.cp = void 0; + var assert_1 = require("assert"); + var path2 = __importStar(require("path")); + var ioUtil = __importStar(require_io_util()); + function cp(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + const { force, recursive, copySourceDirectory } = readCopyOptions(options); + const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; + if (destStat && destStat.isFile() && !force) { + return; + } + const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path2.join(dest, path2.basename(source)) : dest; + if (!(yield ioUtil.exists(source))) { + throw new Error(`no such file or directory: ${source}`); + } + const sourceStat = yield ioUtil.stat(source); + if (sourceStat.isDirectory()) { + if (!recursive) { + throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); + } else { + yield cpDirRecursive(source, newDest, 0, force); + } + } else { + if (path2.relative(source, newDest) === "") { + throw new Error(`'${newDest}' and '${source}' are the same file`); + } + yield copyFile(source, newDest, force); + } + }); + } + exports2.cp = cp; + function mv(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + if (yield ioUtil.exists(dest)) { + let destExists = true; + if (yield ioUtil.isDirectory(dest)) { + dest = path2.join(dest, path2.basename(source)); + destExists = yield ioUtil.exists(dest); + } + if (destExists) { + if (options.force == null || options.force) { + yield rmRF(dest); + } else { + throw new Error("Destination already exists"); + } + } + } + yield mkdirP(path2.dirname(dest)); + yield ioUtil.rename(source, dest); + }); + } + exports2.mv = mv; + function rmRF(inputPath) { + return __awaiter(this, void 0, void 0, function* () { + if (ioUtil.IS_WINDOWS) { + if (/[*"<>|]/.test(inputPath)) { + throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows'); + } + } + try { + yield ioUtil.rm(inputPath, { + force: true, + maxRetries: 3, + recursive: true, + retryDelay: 300 + }); + } catch (err) { + throw new Error(`File was unable to be removed ${err}`); + } + }); + } + exports2.rmRF = rmRF; + function mkdirP(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(fsPath, "a path argument must be provided"); + yield ioUtil.mkdir(fsPath, { recursive: true }); + }); + } + exports2.mkdirP = mkdirP; + function which(tool, check) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + if (check) { + const result = yield which(tool, false); + if (!result) { + if (ioUtil.IS_WINDOWS) { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); + } else { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); + } + } + return result; + } + const matches = yield findInPath(tool); + if (matches && matches.length > 0) { + return matches[0]; + } + return ""; + }); + } + exports2.which = which; + function findInPath(tool) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + const extensions = []; + if (ioUtil.IS_WINDOWS && process.env["PATHEXT"]) { + for (const extension of process.env["PATHEXT"].split(path2.delimiter)) { + if (extension) { + extensions.push(extension); + } + } + } + if (ioUtil.isRooted(tool)) { + const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); + if (filePath) { + return [filePath]; + } + return []; + } + if (tool.includes(path2.sep)) { + return []; + } + const directories = []; + if (process.env.PATH) { + for (const p of process.env.PATH.split(path2.delimiter)) { + if (p) { + directories.push(p); + } + } + } + const matches = []; + for (const directory of directories) { + const filePath = yield ioUtil.tryGetExecutablePath(path2.join(directory, tool), extensions); + if (filePath) { + matches.push(filePath); + } + } + return matches; + }); + } + exports2.findInPath = findInPath; + function readCopyOptions(options) { + const force = options.force == null ? true : options.force; + const recursive = Boolean(options.recursive); + const copySourceDirectory = options.copySourceDirectory == null ? true : Boolean(options.copySourceDirectory); + return { force, recursive, copySourceDirectory }; + } + function cpDirRecursive(sourceDir, destDir, currentDepth, force) { + return __awaiter(this, void 0, void 0, function* () { + if (currentDepth >= 255) + return; + currentDepth++; + yield mkdirP(destDir); + const files = yield ioUtil.readdir(sourceDir); + for (const fileName of files) { + const srcFile = `${sourceDir}/${fileName}`; + const destFile = `${destDir}/${fileName}`; + const srcFileStat = yield ioUtil.lstat(srcFile); + if (srcFileStat.isDirectory()) { + yield cpDirRecursive(srcFile, destFile, currentDepth, force); + } else { + yield copyFile(srcFile, destFile, force); + } + } + yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); + }); + } + function copyFile(srcFile, destFile, force) { + return __awaiter(this, void 0, void 0, function* () { + if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { + try { + yield ioUtil.lstat(destFile); + yield ioUtil.unlink(destFile); + } catch (e) { + if (e.code === "EPERM") { + yield ioUtil.chmod(destFile, "0666"); + yield ioUtil.unlink(destFile); + } + } + const symlinkFull = yield ioUtil.readlink(srcFile); + yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? "junction" : null); + } else if (!(yield ioUtil.exists(destFile)) || force) { + yield ioUtil.copyFile(srcFile, destFile); + } + }); + } + } +}); + +// node_modules/@actions/exec/lib/toolrunner.js +var require_toolrunner = __commonJS({ + "node_modules/@actions/exec/lib/toolrunner.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.argStringToArray = exports2.ToolRunner = void 0; + var os = __importStar(require("os")); + var events = __importStar(require("events")); + var child = __importStar(require("child_process")); + var path2 = __importStar(require("path")); + var io = __importStar(require_io()); + var ioUtil = __importStar(require_io_util()); + var timers_1 = require("timers"); + var IS_WINDOWS = process.platform === "win32"; + var ToolRunner = class extends events.EventEmitter { + constructor(toolPath, args, options) { + super(); + if (!toolPath) { + throw new Error("Parameter 'toolPath' cannot be null or empty."); + } + this.toolPath = toolPath; + this.args = args || []; + this.options = options || {}; + } + _debug(message) { + if (this.options.listeners && this.options.listeners.debug) { + this.options.listeners.debug(message); + } + } + _getCommandString(options, noPrefix) { + const toolPath = this._getSpawnFileName(); + const args = this._getSpawnArgs(options); + let cmd = noPrefix ? "" : "[command]"; + if (IS_WINDOWS) { + if (this._isCmdFile()) { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } else if (options.windowsVerbatimArguments) { + cmd += `"${toolPath}"`; + for (const a of args) { + cmd += ` ${a}`; + } + } else { + cmd += this._windowsQuoteCmdArg(toolPath); + for (const a of args) { + cmd += ` ${this._windowsQuoteCmdArg(a)}`; + } + } + } else { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } + return cmd; + } + _processLineBuffer(data, strBuffer, onLine) { + try { + let s = strBuffer + data.toString(); + let n = s.indexOf(os.EOL); + while (n > -1) { + const line = s.substring(0, n); + onLine(line); + s = s.substring(n + os.EOL.length); + n = s.indexOf(os.EOL); + } + return s; + } catch (err) { + this._debug(`error processing line. Failed with error ${err}`); + return ""; + } + } + _getSpawnFileName() { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + return process.env["COMSPEC"] || "cmd.exe"; + } + } + return this.toolPath; + } + _getSpawnArgs(options) { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; + for (const a of this.args) { + argline += " "; + argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a); + } + argline += '"'; + return [argline]; + } + } + return this.args; + } + _endsWith(str, end) { + return str.endsWith(end); + } + _isCmdFile() { + const upperToolPath = this.toolPath.toUpperCase(); + return this._endsWith(upperToolPath, ".CMD") || this._endsWith(upperToolPath, ".BAT"); + } + _windowsQuoteCmdArg(arg) { + if (!this._isCmdFile()) { + return this._uvQuoteCmdArg(arg); + } + if (!arg) { + return '""'; + } + const cmdSpecialChars = [ + " ", + " ", + "&", + "(", + ")", + "[", + "]", + "{", + "}", + "^", + "=", + ";", + "!", + "'", + "+", + ",", + "`", + "~", + "|", + "<", + ">", + '"' + ]; + let needsQuotes = false; + for (const char of arg) { + if (cmdSpecialChars.some((x) => x === char)) { + needsQuotes = true; + break; + } + } + if (!needsQuotes) { + return arg; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += '"'; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _uvQuoteCmdArg(arg) { + if (!arg) { + return '""'; + } + if (!arg.includes(" ") && !arg.includes(" ") && !arg.includes('"')) { + return arg; + } + if (!arg.includes('"') && !arg.includes("\\")) { + return `"${arg}"`; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += "\\"; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _cloneExecOptions(options) { + options = options || {}; + const result = { + cwd: options.cwd || process.cwd(), + env: options.env || process.env, + silent: options.silent || false, + windowsVerbatimArguments: options.windowsVerbatimArguments || false, + failOnStdErr: options.failOnStdErr || false, + ignoreReturnCode: options.ignoreReturnCode || false, + delay: options.delay || 1e4 + }; + result.outStream = options.outStream || process.stdout; + result.errStream = options.errStream || process.stderr; + return result; + } + _getSpawnOptions(options, toolPath) { + options = options || {}; + const result = {}; + result.cwd = options.cwd; + result.env = options.env; + result["windowsVerbatimArguments"] = options.windowsVerbatimArguments || this._isCmdFile(); + if (options.windowsVerbatimArguments) { + result.argv0 = `"${toolPath}"`; + } + return result; + } + /** + * Exec a tool. + * Output will be streamed to the live console. + * Returns promise with return code + * + * @param tool path to tool to exec + * @param options optional exec options. See ExecOptions + * @returns number + */ + exec() { + return __awaiter(this, void 0, void 0, function* () { + if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\"))) { + this.toolPath = path2.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); + } + this.toolPath = yield io.which(this.toolPath, true); + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + this._debug(`exec tool: ${this.toolPath}`); + this._debug("arguments:"); + for (const arg of this.args) { + this._debug(` ${arg}`); + } + const optionsNonNull = this._cloneExecOptions(this.options); + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); + } + const state = new ExecState(optionsNonNull, this.toolPath); + state.on("debug", (message) => { + this._debug(message); + }); + if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) { + return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); + } + const fileName = this._getSpawnFileName(); + const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); + let stdbuffer = ""; + if (cp.stdout) { + cp.stdout.on("data", (data) => { + if (this.options.listeners && this.options.listeners.stdout) { + this.options.listeners.stdout(data); + } + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(data); + } + stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { + if (this.options.listeners && this.options.listeners.stdline) { + this.options.listeners.stdline(line); + } + }); + }); + } + let errbuffer = ""; + if (cp.stderr) { + cp.stderr.on("data", (data) => { + state.processStderr = true; + if (this.options.listeners && this.options.listeners.stderr) { + this.options.listeners.stderr(data); + } + if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) { + const s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream; + s.write(data); + } + errbuffer = this._processLineBuffer(data, errbuffer, (line) => { + if (this.options.listeners && this.options.listeners.errline) { + this.options.listeners.errline(line); + } + }); + }); + } + cp.on("error", (err) => { + state.processError = err.message; + state.processExited = true; + state.processClosed = true; + state.CheckComplete(); + }); + cp.on("exit", (code) => { + state.processExitCode = code; + state.processExited = true; + this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); + state.CheckComplete(); + }); + cp.on("close", (code) => { + state.processExitCode = code; + state.processExited = true; + state.processClosed = true; + this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); + state.CheckComplete(); + }); + state.on("done", (error, exitCode) => { + if (stdbuffer.length > 0) { + this.emit("stdline", stdbuffer); + } + if (errbuffer.length > 0) { + this.emit("errline", errbuffer); + } + cp.removeAllListeners(); + if (error) { + reject(error); + } else { + resolve(exitCode); + } + }); + if (this.options.input) { + if (!cp.stdin) { + throw new Error("child process missing stdin"); + } + cp.stdin.end(this.options.input); + } + })); + }); + } + }; + exports2.ToolRunner = ToolRunner; + function argStringToArray(argString) { + const args = []; + let inQuotes = false; + let escaped = false; + let arg = ""; + function append(c) { + if (escaped && c !== '"') { + arg += "\\"; + } + arg += c; + escaped = false; + } + for (let i = 0; i < argString.length; i++) { + const c = argString.charAt(i); + if (c === '"') { + if (!escaped) { + inQuotes = !inQuotes; + } else { + append(c); + } + continue; + } + if (c === "\\" && escaped) { + append(c); + continue; + } + if (c === "\\" && inQuotes) { + escaped = true; + continue; + } + if (c === " " && !inQuotes) { + if (arg.length > 0) { + args.push(arg); + arg = ""; + } + continue; + } + append(c); + } + if (arg.length > 0) { + args.push(arg.trim()); + } + return args; + } + exports2.argStringToArray = argStringToArray; + var ExecState = class _ExecState extends events.EventEmitter { + constructor(options, toolPath) { + super(); + this.processClosed = false; + this.processError = ""; + this.processExitCode = 0; + this.processExited = false; + this.processStderr = false; + this.delay = 1e4; + this.done = false; + this.timeout = null; + if (!toolPath) { + throw new Error("toolPath must not be empty"); + } + this.options = options; + this.toolPath = toolPath; + if (options.delay) { + this.delay = options.delay; + } + } + CheckComplete() { + if (this.done) { + return; + } + if (this.processClosed) { + this._setResult(); + } else if (this.processExited) { + this.timeout = timers_1.setTimeout(_ExecState.HandleTimeout, this.delay, this); + } + } + _debug(message) { + this.emit("debug", message); + } + _setResult() { + let error; + if (this.processExited) { + if (this.processError) { + error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); + } else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { + error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); + } else if (this.processStderr && this.options.failOnStdErr) { + error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); + } + } + if (this.timeout) { + clearTimeout(this.timeout); + this.timeout = null; + } + this.done = true; + this.emit("done", error, this.processExitCode); + } + static HandleTimeout(state) { + if (state.done) { + return; + } + if (!state.processClosed && state.processExited) { + const message = `The STDIO streams did not close within ${state.delay / 1e3} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; + state._debug(message); + } + state._setResult(); + } + }; + } +}); + +// node_modules/@actions/exec/lib/exec.js +var require_exec = __commonJS({ + "node_modules/@actions/exec/lib/exec.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getExecOutput = exports2.exec = void 0; + var string_decoder_1 = require("string_decoder"); + var tr = __importStar(require_toolrunner()); + function exec(commandLine, args, options) { + return __awaiter(this, void 0, void 0, function* () { + const commandArgs = tr.argStringToArray(commandLine); + if (commandArgs.length === 0) { + throw new Error(`Parameter 'commandLine' cannot be null or empty.`); + } + const toolPath = commandArgs[0]; + args = commandArgs.slice(1).concat(args || []); + const runner = new tr.ToolRunner(toolPath, args, options); + return runner.exec(); + }); + } + exports2.exec = exec; + function getExecOutput(commandLine, args, options) { + var _a2, _b; + return __awaiter(this, void 0, void 0, function* () { + let stdout = ""; + let stderr = ""; + const stdoutDecoder = new string_decoder_1.StringDecoder("utf8"); + const stderrDecoder = new string_decoder_1.StringDecoder("utf8"); + const originalStdoutListener = (_a2 = options === null || options === void 0 ? void 0 : options.listeners) === null || _a2 === void 0 ? void 0 : _a2.stdout; + const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr; + const stdErrListener = (data) => { + stderr += stderrDecoder.write(data); + if (originalStdErrListener) { + originalStdErrListener(data); + } + }; + const stdOutListener = (data) => { + stdout += stdoutDecoder.write(data); + if (originalStdoutListener) { + originalStdoutListener(data); + } + }; + const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener }); + const exitCode = yield exec(commandLine, args, Object.assign(Object.assign({}, options), { listeners })); + stdout += stdoutDecoder.end(); + stderr += stderrDecoder.end(); + return { + exitCode, + stdout, + stderr + }; + }); + } + exports2.getExecOutput = getExecOutput; + } +}); + +// node_modules/@actions/core/lib/platform.js +var require_platform = __commonJS({ + "node_modules/@actions/core/lib/platform.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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 = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getDetails = exports2.isLinux = exports2.isMacOS = exports2.isWindows = exports2.arch = exports2.platform = void 0; + var os_1 = __importDefault(require("os")); + var exec = __importStar(require_exec()); + var getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout: version } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', void 0, { + silent: true + }); + const { stdout: name } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', void 0, { + silent: true + }); + return { + name: name.trim(), + version: version.trim() + }; + }); + var getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + var _a2, _b, _c, _d; + const { stdout } = yield exec.getExecOutput("sw_vers", void 0, { + silent: true + }); + const version = (_b = (_a2 = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a2 === void 0 ? void 0 : _a2[1]) !== null && _b !== void 0 ? _b : ""; + const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ""; + return { + name, + version + }; + }); + var getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout } = yield exec.getExecOutput("lsb_release", ["-i", "-r", "-s"], { + silent: true + }); + const [name, version] = stdout.trim().split("\n"); + return { + name, + version + }; + }); + exports2.platform = os_1.default.platform(); + exports2.arch = os_1.default.arch(); + exports2.isWindows = exports2.platform === "win32"; + exports2.isMacOS = exports2.platform === "darwin"; + exports2.isLinux = exports2.platform === "linux"; + function getDetails() { + return __awaiter(this, void 0, void 0, function* () { + return Object.assign(Object.assign({}, yield exports2.isWindows ? getWindowsInfo() : exports2.isMacOS ? getMacOsInfo() : getLinuxInfo()), { + platform: exports2.platform, + arch: exports2.arch, + isWindows: exports2.isWindows, + isMacOS: exports2.isMacOS, + isLinux: exports2.isLinux + }); + }); + } + exports2.getDetails = getDetails; + } +}); + +// node_modules/@actions/core/lib/core.js +var require_core = __commonJS({ + "node_modules/@actions/core/lib/core.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.platform = exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = exports2.markdownSummary = exports2.summary = exports2.getIDToken = exports2.getState = exports2.saveState = exports2.group = exports2.endGroup = exports2.startGroup = exports2.info = exports2.notice = exports2.warning = exports2.error = exports2.debug = exports2.isDebug = exports2.setFailed = exports2.setCommandEcho = exports2.setOutput = exports2.getBooleanInput = exports2.getMultilineInput = exports2.getInput = exports2.addPath = exports2.setSecret = exports2.exportVariable = exports2.ExitCode = void 0; + var command_1 = require_command(); + var file_command_1 = require_file_command(); + var utils_1 = require_utils(); + var os = __importStar(require("os")); + var path2 = __importStar(require("path")); + var oidc_utils_1 = require_oidc_utils(); + var ExitCode; + (function(ExitCode2) { + ExitCode2[ExitCode2["Success"] = 0] = "Success"; + ExitCode2[ExitCode2["Failure"] = 1] = "Failure"; + })(ExitCode || (exports2.ExitCode = ExitCode = {})); + function exportVariable(name, val) { + const convertedVal = (0, utils_1.toCommandValue)(val); + process.env[name] = convertedVal; + const filePath = process.env["GITHUB_ENV"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("ENV", (0, file_command_1.prepareKeyValueMessage)(name, val)); + } + (0, command_1.issueCommand)("set-env", { name }, convertedVal); + } + exports2.exportVariable = exportVariable; + function setSecret(secret) { + (0, command_1.issueCommand)("add-mask", {}, secret); + } + exports2.setSecret = setSecret; + function addPath(inputPath) { + const filePath = process.env["GITHUB_PATH"] || ""; + if (filePath) { + (0, file_command_1.issueFileCommand)("PATH", inputPath); + } else { + (0, command_1.issueCommand)("add-path", {}, inputPath); + } + process.env["PATH"] = `${inputPath}${path2.delimiter}${process.env["PATH"]}`; + } + exports2.addPath = addPath; + function getInput2(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || ""; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); + } + exports2.getInput = getInput2; + function getMultilineInput(name, options) { + const inputs = getInput2(name, options).split("\n").filter((x) => x !== ""); + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map((input) => input.trim()); + } + exports2.getMultilineInput = getMultilineInput; + function getBooleanInput2(name, options) { + const trueValue = ["true", "True", "TRUE"]; + const falseValue = ["false", "False", "FALSE"]; + const val = getInput2(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} +Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); + } + exports2.getBooleanInput = getBooleanInput2; + function setOutput2(name, value) { + const filePath = process.env["GITHUB_OUTPUT"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("OUTPUT", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + process.stdout.write(os.EOL); + (0, command_1.issueCommand)("set-output", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.setOutput = setOutput2; + function setCommandEcho(enabled) { + (0, command_1.issue)("echo", enabled ? "on" : "off"); + } + exports2.setCommandEcho = setCommandEcho; + function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); + } + exports2.setFailed = setFailed; + function isDebug() { + return process.env["RUNNER_DEBUG"] === "1"; + } + exports2.isDebug = isDebug; + function debug(message) { + (0, command_1.issueCommand)("debug", {}, message); + } + exports2.debug = debug; + function error(message, properties = {}) { + (0, command_1.issueCommand)("error", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.error = error; + function warning(message, properties = {}) { + (0, command_1.issueCommand)("warning", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.warning = warning; + function notice(message, properties = {}) { + (0, command_1.issueCommand)("notice", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.notice = notice; + function info(message) { + process.stdout.write(message + os.EOL); + } + exports2.info = info; + function startGroup(name) { + (0, command_1.issue)("group", name); + } + exports2.startGroup = startGroup; + function endGroup() { + (0, command_1.issue)("endgroup"); + } + exports2.endGroup = endGroup; + function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup(name); + let result; + try { + result = yield fn(); + } finally { + endGroup(); + } + return result; + }); + } + exports2.group = group; + function saveState(name, value) { + const filePath = process.env["GITHUB_STATE"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("STATE", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + (0, command_1.issueCommand)("save-state", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.saveState = saveState; + function getState(name) { + return process.env[`STATE_${name}`] || ""; + } + exports2.getState = getState; + function getIDToken(aud) { + return __awaiter(this, void 0, void 0, function* () { + return yield oidc_utils_1.OidcClient.getIDToken(aud); + }); + } + exports2.getIDToken = getIDToken; + var summary_1 = require_summary(); + Object.defineProperty(exports2, "summary", { enumerable: true, get: function() { + return summary_1.summary; + } }); + var summary_2 = require_summary(); + Object.defineProperty(exports2, "markdownSummary", { enumerable: true, get: function() { + return summary_2.markdownSummary; + } }); + var path_utils_1 = require_path_utils(); + Object.defineProperty(exports2, "toPosixPath", { enumerable: true, get: function() { + return path_utils_1.toPosixPath; + } }); + Object.defineProperty(exports2, "toWin32Path", { enumerable: true, get: function() { + return path_utils_1.toWin32Path; + } }); + Object.defineProperty(exports2, "toPlatformPath", { enumerable: true, get: function() { + return path_utils_1.toPlatformPath; + } }); + exports2.platform = __importStar(require_platform()); + } +}); + +// src/build.ts +var import_core = __toESM(require_core()); + +// node_modules/@stainless-api/sdk/internal/tslib.mjs +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +// node_modules/@stainless-api/sdk/internal/utils/uuid.mjs +var uuid4 = function() { + const { crypto } = globalThis; + if (crypto?.randomUUID) { + uuid4 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16)); +}; + +// node_modules/@stainless-api/sdk/internal/errors.mjs +function isAbortError(err) { + return typeof err === "object" && err !== null && // Spec-compliant fetch implementations + ("name" in err && err.name === "AbortError" || // Expo fetch + "message" in err && String(err.message).includes("FetchRequestCanceledException")); +} +var castToError = (err) => { + if (err instanceof Error) + return err; + if (typeof err === "object" && err !== null) { + try { + if (Object.prototype.toString.call(err) === "[object Error]") { + const error = new Error(err.message, err.cause ? { cause: err.cause } : {}); + if (err.stack) + error.stack = err.stack; + if (err.cause && !error.cause) + error.cause = err.cause; + if (err.name) + error.name = err.name; + return error; + } + } catch { + } + try { + return new Error(JSON.stringify(err)); + } catch { + } + } + return new Error(err); +}; + +// node_modules/@stainless-api/sdk/core/error.mjs +var StainlessError = class extends Error { +}; +var APIError = class _APIError extends StainlessError { + constructor(status, error, message, headers) { + super(`${_APIError.makeMessage(status, error, message)}`); + this.status = status; + this.headers = headers; + this.error = error; + } + static makeMessage(status, error, message) { + const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message; + if (status && msg) { + return `${status} ${msg}`; + } + if (status) { + return `${status} status code (no body)`; + } + if (msg) { + return msg; + } + return "(no status code or body)"; + } + static generate(status, errorResponse, message, headers) { + if (!status || !headers) { + return new APIConnectionError({ message, cause: castToError(errorResponse) }); + } + const error = errorResponse; + if (status === 400) { + return new BadRequestError(status, error, message, headers); + } + if (status === 401) { + return new AuthenticationError(status, error, message, headers); + } + if (status === 403) { + return new PermissionDeniedError(status, error, message, headers); + } + if (status === 404) { + return new NotFoundError(status, error, message, headers); + } + if (status === 409) { + return new ConflictError(status, error, message, headers); + } + if (status === 422) { + return new UnprocessableEntityError(status, error, message, headers); + } + if (status === 429) { + return new RateLimitError(status, error, message, headers); + } + if (status >= 500) { + return new InternalServerError(status, error, message, headers); + } + return new _APIError(status, error, message, headers); + } +}; +var APIUserAbortError = class extends APIError { + constructor({ message } = {}) { + super(void 0, void 0, message || "Request was aborted.", void 0); + } +}; +var APIConnectionError = class extends APIError { + constructor({ message, cause }) { + super(void 0, void 0, message || "Connection error.", void 0); + if (cause) + this.cause = cause; + } +}; +var APIConnectionTimeoutError = class extends APIConnectionError { + constructor({ message } = {}) { + super({ message: message ?? "Request timed out." }); + } +}; +var BadRequestError = class extends APIError { +}; +var AuthenticationError = class extends APIError { +}; +var PermissionDeniedError = class extends APIError { +}; +var NotFoundError = class extends APIError { +}; +var ConflictError = class extends APIError { +}; +var UnprocessableEntityError = class extends APIError { +}; +var RateLimitError = class extends APIError { +}; +var InternalServerError = class extends APIError { +}; + +// node_modules/@stainless-api/sdk/internal/utils/values.mjs +var startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i; +var isAbsoluteURL = (url) => { + return startsWithSchemeRegexp.test(url); +}; +var isArray = (val) => (isArray = Array.isArray, isArray(val)); +var isReadonlyArray = isArray; +function maybeObj(x) { + if (typeof x !== "object") { + return {}; + } + return x ?? {}; +} +function isEmptyObj(obj) { + if (!obj) + return true; + for (const _k in obj) + return false; + return true; +} +function hasOwn(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} +var validatePositiveInteger = (name, n) => { + if (typeof n !== "number" || !Number.isInteger(n)) { + throw new StainlessError(`${name} must be an integer`); + } + if (n < 0) { + throw new StainlessError(`${name} must be a positive integer`); + } + return n; +}; +var safeJSON = (text) => { + try { + return JSON.parse(text); + } catch (err) { + return void 0; + } +}; + +// node_modules/@stainless-api/sdk/internal/utils/sleep.mjs +var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); + +// node_modules/@stainless-api/sdk/version.mjs +var VERSION = "0.1.0-alpha.11"; + +// node_modules/@stainless-api/sdk/internal/detect-platform.mjs +function getDetectedPlatform() { + if (typeof Deno !== "undefined" && Deno.build != null) { + return "deno"; + } + if (typeof EdgeRuntime !== "undefined") { + return "edge"; + } + if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") { + return "node"; + } + return "unknown"; +} +var getPlatformProperties = () => { + const detectedPlatform = getDetectedPlatform(); + if (detectedPlatform === "deno") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(Deno.build.os), + "X-Stainless-Arch": normalizeArch(Deno.build.arch), + "X-Stainless-Runtime": "deno", + "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown" + }; + } + if (typeof EdgeRuntime !== "undefined") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": `other:${EdgeRuntime}`, + "X-Stainless-Runtime": "edge", + "X-Stainless-Runtime-Version": globalThis.process.version + }; + } + if (detectedPlatform === "node") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"), + "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"), + "X-Stainless-Runtime": "node", + "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown" + }; + } + const browserInfo = getBrowserInfo(); + if (browserInfo) { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": `browser:${browserInfo.browser}`, + "X-Stainless-Runtime-Version": browserInfo.version + }; + } + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": "unknown", + "X-Stainless-Runtime-Version": "unknown" + }; +}; +function getBrowserInfo() { + if (typeof navigator === "undefined" || !navigator) { + return null; + } + const browserPatterns = [ + { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ } + ]; + for (const { key, pattern } of browserPatterns) { + const match = pattern.exec(navigator.userAgent); + if (match) { + const major = match[1] || 0; + const minor = match[2] || 0; + const patch = match[3] || 0; + return { browser: key, version: `${major}.${minor}.${patch}` }; + } + } + return null; +} +var normalizeArch = (arch) => { + if (arch === "x32") + return "x32"; + if (arch === "x86_64" || arch === "x64") + return "x64"; + if (arch === "arm") + return "arm"; + if (arch === "aarch64" || arch === "arm64") + return "arm64"; + if (arch) + return `other:${arch}`; + return "unknown"; +}; +var normalizePlatform = (platform) => { + platform = platform.toLowerCase(); + if (platform.includes("ios")) + return "iOS"; + if (platform === "android") + return "Android"; + if (platform === "darwin") + return "MacOS"; + if (platform === "win32") + return "Windows"; + if (platform === "freebsd") + return "FreeBSD"; + if (platform === "openbsd") + return "OpenBSD"; + if (platform === "linux") + return "Linux"; + if (platform) + return `Other:${platform}`; + return "Unknown"; +}; +var _platformHeaders; +var getPlatformHeaders = () => { + return _platformHeaders ?? (_platformHeaders = getPlatformProperties()); +}; + +// node_modules/@stainless-api/sdk/internal/shims.mjs +function getDefaultFetch() { + if (typeof fetch !== "undefined") { + return fetch; + } + throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Stainless({ fetch })` or polyfill the global, `globalThis.fetch = fetch`"); +} +function makeReadableStream(...args) { + const ReadableStream = globalThis.ReadableStream; + if (typeof ReadableStream === "undefined") { + throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`"); + } + return new ReadableStream(...args); +} +function ReadableStreamFrom(iterable) { + let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); + return makeReadableStream({ + start() { + }, + async pull(controller) { + const { done, value } = await iter.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel() { + await iter.return?.(); + } + }); +} +async function CancelReadableStream(stream) { + if (stream === null || typeof stream !== "object") + return; + if (stream[Symbol.asyncIterator]) { + await stream[Symbol.asyncIterator]().return?.(); + return; + } + const reader = stream.getReader(); + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; +} + +// node_modules/@stainless-api/sdk/internal/request-options.mjs +var FallbackEncoder = ({ headers, body }) => { + return { + bodyHeaders: { + "content-type": "application/json" + }, + body: JSON.stringify(body) + }; +}; + +// node_modules/@stainless-api/sdk/internal/qs/formats.mjs +var default_format = "RFC3986"; +var default_formatter = (v) => String(v); +var formatters = { + RFC1738: (v) => String(v).replace(/%20/g, "+"), + RFC3986: default_formatter +}; +var RFC1738 = "RFC1738"; + +// node_modules/@stainless-api/sdk/internal/qs/utils.mjs +var has = (obj, key) => (has = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), has(obj, key)); +var hex_table = /* @__PURE__ */ (() => { + const array = []; + for (let i = 0; i < 256; ++i) { + array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + } + return array; +})(); +var limit = 1024; +var encode = (str, _defaultEncoder, charset, _kind, format) => { + if (str.length === 0) { + return str; + } + let string = str; + if (typeof str === "symbol") { + string = Symbol.prototype.toString.call(str); + } else if (typeof str !== "string") { + string = String(str); + } + if (charset === "iso-8859-1") { + return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) { + return "%26%23" + parseInt($0.slice(2), 16) + "%3B"; + }); + } + let out = ""; + for (let j = 0; j < string.length; j += limit) { + const segment = string.length >= limit ? string.slice(j, j + limit) : string; + const arr = []; + for (let i = 0; i < segment.length; ++i) { + let c = segment.charCodeAt(i); + if (c === 45 || // - + c === 46 || // . + c === 95 || // _ + c === 126 || // ~ + c >= 48 && c <= 57 || // 0-9 + c >= 65 && c <= 90 || // a-z + c >= 97 && c <= 122 || // A-Z + format === RFC1738 && (c === 40 || c === 41)) { + arr[arr.length] = segment.charAt(i); + continue; + } + if (c < 128) { + arr[arr.length] = hex_table[c]; + continue; + } + if (c < 2048) { + arr[arr.length] = hex_table[192 | c >> 6] + hex_table[128 | c & 63]; + continue; + } + if (c < 55296 || c >= 57344) { + arr[arr.length] = hex_table[224 | c >> 12] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + continue; + } + i += 1; + c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023); + arr[arr.length] = hex_table[240 | c >> 18] + hex_table[128 | c >> 12 & 63] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + } + out += arr.join(""); + } + return out; +}; +function is_buffer(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); +} +function maybe_map(val, fn) { + if (isArray(val)) { + const mapped = []; + for (let i = 0; i < val.length; i += 1) { + mapped.push(fn(val[i])); + } + return mapped; + } + return fn(val); +} + +// node_modules/@stainless-api/sdk/internal/qs/stringify.mjs +var array_prefix_generators = { + brackets(prefix) { + return String(prefix) + "[]"; + }, + comma: "comma", + indices(prefix, key) { + return String(prefix) + "[" + key + "]"; + }, + repeat(prefix) { + return String(prefix); + } +}; +var push_to_array = function(arr, value_or_array) { + Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]); +}; +var toISOString; +var defaults = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: encode, + encodeValuesOnly: false, + format: default_format, + formatter: default_formatter, + /** @deprecated */ + indices: false, + serializeDate(date) { + return (toISOString ?? (toISOString = Function.prototype.call.bind(Date.prototype.toISOString)))(date); + }, + skipNulls: false, + strictNullHandling: false +}; +function is_non_nullish_primitive(v) { + return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint"; +} +var sentinel = {}; +function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { + let obj = object; + let tmp_sc = sideChannel; + let step = 0; + let find_flag = false; + while ((tmp_sc = tmp_sc.get(sentinel)) !== void 0 && !find_flag) { + const pos = tmp_sc.get(object); + step += 1; + if (typeof pos !== "undefined") { + if (pos === step) { + throw new RangeError("Cyclic object value"); + } else { + find_flag = true; + } + } + if (typeof tmp_sc.get(sentinel) === "undefined") { + step = 0; + } + } + if (typeof filter === "function") { + obj = filter(prefix, obj); + } else if (obj instanceof Date) { + obj = serializeDate?.(obj); + } else if (generateArrayPrefix === "comma" && isArray(obj)) { + obj = maybe_map(obj, function(value) { + if (value instanceof Date) { + return serializeDate?.(value); + } + return value; + }); + } + if (obj === null) { + if (strictNullHandling) { + return encoder && !encodeValuesOnly ? ( + // @ts-expect-error + encoder(prefix, defaults.encoder, charset, "key", format) + ) : prefix; + } + obj = ""; + } + if (is_non_nullish_primitive(obj) || is_buffer(obj)) { + if (encoder) { + const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format); + return [ + formatter?.(key_value) + "=" + // @ts-expect-error + formatter?.(encoder(obj, defaults.encoder, charset, "value", format)) + ]; + } + return [formatter?.(prefix) + "=" + formatter?.(String(obj))]; + } + const values = []; + if (typeof obj === "undefined") { + return values; + } + let obj_keys; + if (generateArrayPrefix === "comma" && isArray(obj)) { + if (encodeValuesOnly && encoder) { + obj = maybe_map(obj, encoder); + } + obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray(filter)) { + obj_keys = filter; + } else { + const keys = Object.keys(obj); + obj_keys = sort ? keys.sort(sort) : keys; + } + const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + const adjusted_prefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix; + if (allowEmptyArrays && isArray(obj) && obj.length === 0) { + return adjusted_prefix + "[]"; + } + for (let j = 0; j < obj_keys.length; ++j) { + const key = obj_keys[j]; + const value = ( + // @ts-ignore + typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key] + ); + if (skipNulls && value === null) { + continue; + } + const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key; + const key_prefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]"); + sideChannel.set(object, step); + const valueSideChannel = /* @__PURE__ */ new WeakMap(); + valueSideChannel.set(sentinel, sideChannel); + push_to_array(values, inner_stringify( + value, + key_prefix, + generateArrayPrefix, + commaRoundTrip, + allowEmptyArrays, + strictNullHandling, + skipNulls, + encodeDotInKeys, + // @ts-ignore + generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, + filter, + sort, + allowDots, + serializeDate, + format, + formatter, + encodeValuesOnly, + charset, + valueSideChannel + )); + } + return values; +} +function normalize_stringify_options(opts = defaults) { + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") { + throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") { + throw new TypeError("Encoder has to be a function."); + } + const charset = opts.charset || defaults.charset; + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + let format = default_format; + if (typeof opts.format !== "undefined") { + if (!has(formatters, opts.format)) { + throw new TypeError("Unknown format option provided."); + } + format = opts.format; + } + const formatter = formatters[format]; + let filter = defaults.filter; + if (typeof opts.filter === "function" || isArray(opts.filter)) { + filter = opts.filter; + } + let arrayFormat; + if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) { + arrayFormat = opts.arrayFormat; + } else if ("indices" in opts) { + arrayFormat = opts.indices ? "indices" : "repeat"; + } else { + arrayFormat = defaults.arrayFormat; + } + if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") { + throw new TypeError("`commaRoundTrip` must be a boolean, or absent"); + } + const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix, + // @ts-ignore + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays, + arrayFormat, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel, + commaRoundTrip: !!opts.commaRoundTrip, + delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter, + encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode, + encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys, + encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder, + encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly, + filter, + format, + formatter, + serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate, + skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls, + // @ts-ignore + sort: typeof opts.sort === "function" ? opts.sort : null, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling + }; +} +function stringify(object, opts = {}) { + let obj = object; + const options = normalize_stringify_options(opts); + let obj_keys; + let filter; + if (typeof options.filter === "function") { + filter = options.filter; + obj = filter("", obj); + } else if (isArray(options.filter)) { + filter = options.filter; + obj_keys = filter; + } + const keys = []; + if (typeof obj !== "object" || obj === null) { + return ""; + } + const generateArrayPrefix = array_prefix_generators[options.arrayFormat]; + const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip; + if (!obj_keys) { + obj_keys = Object.keys(obj); + } + if (options.sort) { + obj_keys.sort(options.sort); + } + const sideChannel = /* @__PURE__ */ new WeakMap(); + for (let i = 0; i < obj_keys.length; ++i) { + const key = obj_keys[i]; + if (options.skipNulls && obj[key] === null) { + continue; + } + push_to_array(keys, inner_stringify( + obj[key], + key, + // @ts-expect-error + generateArrayPrefix, + commaRoundTrip, + options.allowEmptyArrays, + options.strictNullHandling, + options.skipNulls, + options.encodeDotInKeys, + options.encode ? options.encoder : null, + options.filter, + options.sort, + options.allowDots, + options.serializeDate, + options.format, + options.formatter, + options.encodeValuesOnly, + options.charset, + sideChannel + )); + } + const joined = keys.join(options.delimiter); + let prefix = options.addQueryPrefix === true ? "?" : ""; + if (options.charsetSentinel) { + if (options.charset === "iso-8859-1") { + prefix += "utf8=%26%2310003%3B&"; + } else { + prefix += "utf8=%E2%9C%93&"; + } + } + return joined.length > 0 ? prefix + joined : ""; +} + +// node_modules/@stainless-api/sdk/internal/utils/log.mjs +var levelNumbers = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500 +}; +var parseLogLevel = (maybeLevel, sourceName, client) => { + if (!maybeLevel) { + return void 0; + } + if (hasOwn(levelNumbers, maybeLevel)) { + return maybeLevel; + } + loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`); + return void 0; +}; +function noop() { +} +function makeLogFn(fnLevel, logger, logLevel) { + if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) { + return noop; + } else { + return logger[fnLevel].bind(logger); + } +} +var noopLogger = { + error: noop, + warn: noop, + info: noop, + debug: noop +}; +var cachedLoggers = /* @__PURE__ */ new WeakMap(); +function loggerFor(client) { + const logger = client.logger; + const logLevel = client.logLevel ?? "off"; + if (!logger) { + return noopLogger; + } + const cachedLogger = cachedLoggers.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) { + return cachedLogger[1]; + } + const levelLogger = { + error: makeLogFn("error", logger, logLevel), + warn: makeLogFn("warn", logger, logLevel), + info: makeLogFn("info", logger, logLevel), + debug: makeLogFn("debug", logger, logLevel) + }; + cachedLoggers.set(logger, [logLevel, levelLogger]); + return levelLogger; +} +var formatRequestDetails = (details) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options["headers"]; + } + if (details.headers) { + details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [ + name, + name.toLowerCase() === "authorization" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value + ])); + } + if ("retryOfRequestLogID" in details) { + if (details.retryOfRequestLogID) { + details.retryOf = details.retryOfRequestLogID; + } + delete details.retryOfRequestLogID; + } + return details; +}; + +// node_modules/@stainless-api/sdk/internal/parse.mjs +async function defaultParseResponse(client, props) { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + const body = await (async () => { + if (response.status === 204) { + return null; + } + if (props.options.__binaryResponse) { + return response; + } + const contentType = response.headers.get("content-type"); + const mediaType = contentType?.split(";")[0]?.trim(); + const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json"); + if (isJSON) { + const json = await response.json(); + return json; + } + const text = await response.text(); + return text; + })(); + loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body, + durationMs: Date.now() - startTime + })); + return body; +} + +// node_modules/@stainless-api/sdk/core/api-promise.mjs +var _APIPromise_client; +var APIPromise = class _APIPromise extends Promise { + constructor(client, responsePromise, parseResponse = defaultParseResponse) { + super((resolve) => { + resolve(null); + }); + this.responsePromise = responsePromise; + this.parseResponse = parseResponse; + _APIPromise_client.set(this, void 0); + __classPrivateFieldSet(this, _APIPromise_client, client, "f"); + } + _thenUnwrap(transform) { + return new _APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props)); + } + /** + * Gets the raw `Response` instance instead of parsing the response + * data. + * + * If you want to parse the response body but still get the `Response` + * instance, you can use {@link withResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + asResponse() { + return this.responsePromise.then((p) => p.response); + } + /** + * Gets the parsed response data and the raw `Response` instance. + * + * If you just want to get the raw `Response` instance without parsing it, + * you can use {@link asResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + async withResponse() { + const [data, response] = await Promise.all([this.parse(), this.asResponse()]); + return { data, response }; + } + parse() { + if (!this.parsedPromise) { + this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet(this, _APIPromise_client, "f"), data)); + } + return this.parsedPromise; + } + then(onfulfilled, onrejected) { + return this.parse().then(onfulfilled, onrejected); + } + catch(onrejected) { + return this.parse().catch(onrejected); + } + finally(onfinally) { + return this.parse().finally(onfinally); + } +}; +_APIPromise_client = /* @__PURE__ */ new WeakMap(); + +// node_modules/@stainless-api/sdk/core/pagination.mjs +var _AbstractPage_client; +var AbstractPage = class { + constructor(client, response, body, options) { + _AbstractPage_client.set(this, void 0); + __classPrivateFieldSet(this, _AbstractPage_client, client, "f"); + this.options = options; + this.response = response; + this.body = body; + } + hasNextPage() { + const items = this.getPaginatedItems(); + if (!items.length) + return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + const nextOptions = this.nextPageRequestOptions(); + if (!nextOptions) { + throw new StainlessError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); + } + return await __classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions); + } + async *iterPages() { + let page = this; + yield page; + while (page.hasNextPage()) { + page = await page.getNextPage(); + yield page; + } + } + async *[(_AbstractPage_client = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (const page of this.iterPages()) { + for (const item of page.getPaginatedItems()) { + yield item; + } + } + } +}; +var PagePromise = class extends APIPromise { + constructor(client, request, Page2) { + super(client, request, async (client2, props) => new Page2(client2, props.response, await defaultParseResponse(client2, props), props.options)); + } + /** + * Allow auto-paginating iteration on an unawaited list call, eg: + * + * for await (const item of client.items.list()) { + * console.log(item) + * } + */ + async *[Symbol.asyncIterator]() { + const page = await this; + for await (const item of page) { + yield item; + } + } +}; +var Page = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.next_cursor = body.next_cursor || ""; + } + getPaginatedItems() { + return this.data ?? []; + } + nextPageRequestOptions() { + const cursor = this.next_cursor; + if (!cursor) { + return null; + } + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + cursor + } + }; + } +}; + +// node_modules/@stainless-api/sdk/internal/uploads.mjs +var checkFileSupport = () => { + if (typeof File === "undefined") { + const { process: process2 } = globalThis; + const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20; + throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : "")); + } +}; +function makeFile(fileBits, fileName, options) { + checkFileSupport(); + return new File(fileBits, fileName ?? "unknown_file", options); +} +function getName(value) { + return (typeof value === "object" && value !== null && ("name" in value && value.name && String(value.name) || "url" in value && value.url && String(value.url) || "filename" in value && value.filename && String(value.filename) || "path" in value && value.path && String(value.path)) || "").split(/[\\/]/).pop() || void 0; +} +var isAsyncIterable = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function"; + +// node_modules/@stainless-api/sdk/internal/to-file.mjs +var isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function"; +var isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value); +var isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function"; +async function toFile(value, name, options) { + checkFileSupport(); + value = await value; + if (isFileLike(value)) { + if (value instanceof File) { + return value; + } + return makeFile([await value.arrayBuffer()], value.name); + } + if (isResponseLike(value)) { + const blob = await value.blob(); + name || (name = new URL(value.url).pathname.split(/[\\/]/).pop()); + return makeFile(await getBytes(blob), name, options); + } + const parts = await getBytes(value); + name || (name = getName(value)); + if (!options?.type) { + const type = parts.find((part) => typeof part === "object" && "type" in part && part.type); + if (typeof type === "string") { + options = { ...options, type }; + } + } + return makeFile(parts, name, options); +} +async function getBytes(value) { + let parts = []; + if (typeof value === "string" || ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc. + value instanceof ArrayBuffer) { + parts.push(value); + } else if (isBlobLike(value)) { + parts.push(value instanceof Blob ? value : await value.arrayBuffer()); + } else if (isAsyncIterable(value)) { + for await (const chunk of value) { + parts.push(...await getBytes(chunk)); + } + } else { + const constructor = value?.constructor?.name; + throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ""}${propsForError(value)}`); + } + return parts; +} +function propsForError(value) { + if (typeof value !== "object" || value === null) + return ""; + const props = Object.getOwnPropertyNames(value); + return `; props: [${props.map((p) => `"${p}"`).join(", ")}]`; +} + +// node_modules/@stainless-api/sdk/core/resource.mjs +var APIResource = class { + constructor(client) { + this._client = client; + } +}; + +// node_modules/@stainless-api/sdk/internal/utils/path.mjs +function encodeURIPath(str) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); +var createPathTagFunction = (pathEncoder = encodeURIPath) => function path2(statics, ...params) { + if (statics.length === 1) + return statics[0]; + let postPath = false; + const invalidSegments = []; + const path3 = statics.reduce((previousValue, currentValue, index) => { + if (/[?#]/.test(currentValue)) { + postPath = true; + } + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value); + if (index !== params.length && (value == null || typeof value === "object" && // handle values from other realms + value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)?.toString)) { + encoded = value + ""; + invalidSegments.push({ + start: previousValue.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter` + }); + } + return previousValue + currentValue + (index === params.length ? "" : encoded); + }, ""); + const pathOnly = path3.split(/[?#]/, 1)[0]; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { + invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can't be safely passed as a path parameter` + }); + } + invalidSegments.sort((a, b) => a.start - b.start); + if (invalidSegments.length > 0) { + let lastEnd = 0; + const underline = invalidSegments.reduce((acc, segment) => { + const spaces = " ".repeat(segment.start - lastEnd); + const arrows = "^".repeat(segment.length); + lastEnd = segment.start + segment.length; + return acc + spaces + arrows; + }, ""); + throw new StainlessError(`Path parameters result in path with invalid segments: +${invalidSegments.map((e) => e.error).join("\n")} +${path3} +${underline}`); + } + return path3; +}; +var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath); + +// node_modules/@stainless-api/sdk/resources/builds/diagnostics.mjs +var Diagnostics = class extends APIResource { + /** + * Get diagnostics for a build + */ + list(buildID, query = {}, options) { + return this._client.getAPIList(path`/v0/builds/${buildID}/diagnostics`, Page, { + query, + ...options + }); + } +}; + +// node_modules/@stainless-api/sdk/resources/builds/target-outputs.mjs +var TargetOutputs = class extends APIResource { + /** + * Download the output of a build target + */ + retrieve(query, options) { + return this._client.get("/v0/build_target_outputs", { query, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/builds/builds.mjs +var Builds = class extends APIResource { + constructor() { + super(...arguments); + this.diagnostics = new Diagnostics(this._client); + this.targetOutputs = new TargetOutputs(this._client); + } + /** + * Create a new build + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds", { body: { project, ...body }, ...options }); + } + /** + * Retrieve a build by ID + */ + retrieve(buildID, options) { + return this._client.get(path`/v0/builds/${buildID}`, options); + } + /** + * List builds for a project + */ + list(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.getAPIList("/v0/builds", Page, { + query: { project, ...query }, + ...options + }); + } + /** + * Creates two builds whose outputs can be compared directly + */ + compare(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds/compare", { body: { project, ...body }, ...options }); + } +}; +Builds.Diagnostics = Diagnostics; +Builds.TargetOutputs = TargetOutputs; + +// node_modules/@stainless-api/sdk/resources/generate.mjs +var Generate = class extends APIResource { + createSpec(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/generate/spec", { body: { project, ...body }, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/orgs.mjs +var Orgs = class extends APIResource { + /** + * Retrieve an organization by name + */ + retrieve(org, options) { + return this._client.get(path`/v0/orgs/${org}`, options); + } + /** + * List organizations the user has access to + */ + list(options) { + return this._client.get("/v0/orgs", options); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/branches.mjs +var Branches = class extends APIResource { + /** + * Create a new branch for a project + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/branches`, { body, ...options }); + } + /** + * Retrieve a project branch + */ + retrieve(branch, params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/branches/${branch}`, options); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/configs.mjs +var Configs = class extends APIResource { + /** + * Retrieve configuration files for a project + */ + retrieve(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/configs`, { query, ...options }); + } + /** + * Generate configuration suggestions based on an OpenAPI spec + */ + guess(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/configs/guess`, { body, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/projects.mjs +var Projects = class extends APIResource { + constructor() { + super(...arguments); + this.branches = new Branches(this._client); + this.configs = new Configs(this._client); + } + /** + * Create a new project + */ + create(body, options) { + return this._client.post("/v0/projects", { body, ...options }); + } + /** + * Retrieve a project by name + */ + retrieve(params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}`, options); + } + /** + * Update a project's properties + */ + update(params = {}, options) { + const { project = this._client.project, ...body } = params ?? {}; + return this._client.patch(path`/v0/projects/${project}`, { body, ...options }); + } + /** + * List projects in an organization, from oldest to newest + */ + list(query = {}, options) { + return this._client.getAPIList("/v0/projects", Page, { query, ...options }); + } +}; +Projects.Branches = Branches; +Projects.Configs = Configs; + +// node_modules/@stainless-api/sdk/internal/headers.mjs +var brand_privateNullableHeaders = /* @__PURE__ */ Symbol("brand.privateNullableHeaders"); +function* iterateHeaders(headers) { + if (!headers) + return; + if (brand_privateNullableHeaders in headers) { + const { values, nulls } = headers; + yield* values.entries(); + for (const name of nulls) { + yield [name, null]; + } + return; + } + let shouldClear = false; + let iter; + if (headers instanceof Headers) { + iter = headers.entries(); + } else if (isReadonlyArray(headers)) { + iter = headers; + } else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== "string") + throw new TypeError("expected header name to be a string"); + const values = isReadonlyArray(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === void 0) + continue; + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} +var buildHeaders = (newHeaders) => { + const targetHeaders = new Headers(); + const nullHeaders = /* @__PURE__ */ new Set(); + for (const headers of newHeaders) { + const seenHeaders = /* @__PURE__ */ new Set(); + for (const [name, value] of iterateHeaders(headers)) { + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(name); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(name); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(name, value); + nullHeaders.delete(lowerName); + } + } + } + return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders }; +}; + +// node_modules/@stainless-api/sdk/internal/utils/env.mjs +var readEnv = (env) => { + if (typeof globalThis.process !== "undefined") { + return globalThis.process.env?.[env]?.trim() ?? void 0; + } + if (typeof globalThis.Deno !== "undefined") { + return globalThis.Deno.env?.get?.(env)?.trim(); + } + return void 0; +}; + +// node_modules/@stainless-api/sdk/lib/unwrap.mjs +async function unwrapFile(value) { + if (value === null) { + return null; + } + if (value.type === "content") { + return value.content; + } + const response = await fetch(value.url); + return response.text(); +} + +// node_modules/@stainless-api/sdk/client.mjs +var _Stainless_instances; +var _a; +var _Stainless_encoder; +var _Stainless_baseURLOverridden; +var Stainless = class { + /** + * API Client for interfacing with the Stainless API. + * + * @param {string | null | undefined} [opts.apiKey=process.env['STAINLESS_API_KEY'] ?? null] + * @param {string | null | undefined} [opts.project] + * @param {string} [opts.baseURL=process.env['STAINLESS_BASE_URL'] ?? https://api.stainless.com] - Override the default base URL for the API. + * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out. + * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls. + * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation. + * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request. + * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API. + * @param {Record} opts.defaultQuery - Default query parameters to include with every request to the API. + */ + constructor({ baseURL = readEnv("STAINLESS_BASE_URL"), apiKey = readEnv("STAINLESS_API_KEY") ?? null, project = null, ...opts } = {}) { + _Stainless_instances.add(this); + _Stainless_encoder.set(this, void 0); + this.projects = new Projects(this); + this.builds = new Builds(this); + this.orgs = new Orgs(this); + this.generate = new Generate(this); + const options = { + apiKey, + project, + ...opts, + baseURL: baseURL || `https://api.stainless.com` + }; + this.baseURL = options.baseURL; + this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT; + this.logger = options.logger ?? console; + const defaultLogLevel = "warn"; + this.logLevel = defaultLogLevel; + this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("STAINLESS_LOG"), "process.env['STAINLESS_LOG']", this) ?? defaultLogLevel; + this.fetchOptions = options.fetchOptions; + this.maxRetries = options.maxRetries ?? 2; + this.fetch = options.fetch ?? getDefaultFetch(); + __classPrivateFieldSet(this, _Stainless_encoder, FallbackEncoder, "f"); + this._options = options; + this.apiKey = apiKey; + this.project = project; + } + /** + * Create a new client instance re-using the same options given to the current client with optional overriding. + */ + withOptions(options) { + return new this.constructor({ + ...this._options, + baseURL: this.baseURL, + maxRetries: this.maxRetries, + timeout: this.timeout, + logger: this.logger, + logLevel: this.logLevel, + fetch: this.fetch, + fetchOptions: this.fetchOptions, + apiKey: this.apiKey, + project: this.project, + ...options + }); + } + defaultQuery() { + return this._options.defaultQuery; + } + validateHeaders({ values, nulls }) { + if (this.apiKey && values.get("authorization")) { + return; + } + if (nulls.has("authorization")) { + return; + } + throw new Error('Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted'); + } + authHeaders(opts) { + if (this.apiKey == null) { + return void 0; + } + return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]); + } + stringifyQuery(query) { + return stringify(query, { arrayFormat: "comma" }); + } + getUserAgent() { + return `${this.constructor.name}/JS ${VERSION}`; + } + defaultIdempotencyKey() { + return `stainless-node-retry-${uuid4()}`; + } + makeStatusError(status, error, message, headers) { + return APIError.generate(status, error, message, headers); + } + buildURL(path2, query, defaultBaseURL) { + const baseURL = !__classPrivateFieldGet(this, _Stainless_instances, "m", _Stainless_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL; + const url = isAbsoluteURL(path2) ? new URL(path2) : new URL(baseURL + (baseURL.endsWith("/") && path2.startsWith("/") ? path2.slice(1) : path2)); + const defaultQuery = this.defaultQuery(); + if (!isEmptyObj(defaultQuery)) { + query = { ...defaultQuery, ...query }; + } + if (typeof query === "object" && query && !Array.isArray(query)) { + url.search = this.stringifyQuery(query); + } + return url.toString(); + } + /** + * Used as a callback for mutating the given `FinalRequestOptions` object. + */ + async prepareOptions(options) { + } + /** + * Used as a callback for mutating the given `RequestInit` object. + * + * This is useful for cases where you want to add certain headers based off of + * the request properties, e.g. `method` or `url`. + */ + async prepareRequest(request, { url, options }) { + } + get(path2, opts) { + return this.methodRequest("get", path2, opts); + } + post(path2, opts) { + return this.methodRequest("post", path2, opts); + } + patch(path2, opts) { + return this.methodRequest("patch", path2, opts); + } + put(path2, opts) { + return this.methodRequest("put", path2, opts); + } + delete(path2, opts) { + return this.methodRequest("delete", path2, opts); + } + methodRequest(method, path2, opts) { + return this.request(Promise.resolve(opts).then((opts2) => { + return { method, path: path2, ...opts2 }; + })); + } + request(options, remainingRetries = null) { + return new APIPromise(this, this.makeRequest(options, remainingRetries, void 0)); + } + async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { + const options = await optionsInput; + const maxRetries = options.maxRetries ?? this.maxRetries; + if (retriesRemaining == null) { + retriesRemaining = maxRetries; + } + await this.prepareOptions(options); + const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); + await this.prepareRequest(req, { url, options }); + const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0"); + const retryLogStr = retryOfRequestLogID === void 0 ? "" : `, retryOf: ${retryOfRequestLogID}`; + const startTime = Date.now(); + loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({ + retryOfRequestLogID, + method: options.method, + url, + options, + headers: req.headers + })); + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const controller = new AbortController(); + const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError); + const headersTime = Date.now(); + if (response instanceof Error) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : "")); + if (retriesRemaining) { + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID); + } + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + if (isTimeout) { + throw new APIConnectionTimeoutError(); + } + throw new APIConnectionError({ cause: response }); + } + const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`; + if (!response.ok) { + const shouldRetry = this.shouldRetry(response); + if (retriesRemaining && shouldRetry) { + const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`; + await CancelReadableStream(response.body); + loggerFor(this).info(`${responseInfo} - ${retryMessage2}`); + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers); + } + const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`; + loggerFor(this).info(`${responseInfo} - ${retryMessage}`); + const errText = await response.text().catch((err2) => castToError(err2).message); + const errJSON = safeJSON(errText); + const errMessage = errJSON ? void 0 : errText; + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + message: errMessage, + durationMs: Date.now() - startTime + })); + const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers); + throw err; + } + loggerFor(this).info(responseInfo); + loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return { response, options, controller, requestLogID, retryOfRequestLogID, startTime }; + } + getAPIList(path2, Page2, opts) { + return this.requestAPIList(Page2, { method: "get", path: path2, ...opts }); + } + requestAPIList(Page2, options) { + const request = this.makeRequest(options, null, void 0); + return new PagePromise(this, request, Page2); + } + async fetchWithTimeout(url, init, ms, controller) { + const { signal, method, ...options } = init || {}; + if (signal) + signal.addEventListener("abort", () => controller.abort()); + const timeout = setTimeout(() => controller.abort(), ms); + const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body; + const fetchOptions = { + signal: controller.signal, + ...isReadableBody ? { duplex: "half" } : {}, + method: "GET", + ...options + }; + if (method) { + fetchOptions.method = method.toUpperCase(); + } + try { + return await this.fetch.call(void 0, url, fetchOptions); + } finally { + clearTimeout(timeout); + } + } + shouldRetry(response) { + const shouldRetryHeader = response.headers.get("x-should-retry"); + if (shouldRetryHeader === "true") + return true; + if (shouldRetryHeader === "false") + return false; + if (response.status === 408) + return true; + if (response.status === 409) + return true; + if (response.status === 429) + return true; + if (response.status >= 500) + return true; + return false; + } + async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) { + let timeoutMillis; + const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms"); + if (retryAfterMillisHeader) { + const timeoutMs = parseFloat(retryAfterMillisHeader); + if (!Number.isNaN(timeoutMs)) { + timeoutMillis = timeoutMs; + } + } + const retryAfterHeader = responseHeaders?.get("retry-after"); + if (retryAfterHeader && !timeoutMillis) { + const timeoutSeconds = parseFloat(retryAfterHeader); + if (!Number.isNaN(timeoutSeconds)) { + timeoutMillis = timeoutSeconds * 1e3; + } else { + timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + } + if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3)) { + const maxRetries = options.maxRetries ?? this.maxRetries; + timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); + } + await sleep(timeoutMillis); + return this.makeRequest(options, retriesRemaining - 1, requestLogID); + } + calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) { + const initialRetryDelay = 0.5; + const maxRetryDelay = 8; + const numRetries = maxRetries - retriesRemaining; + const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay); + const jitter = 1 - Math.random() * 0.25; + return sleepSeconds * jitter * 1e3; + } + buildRequest(inputOptions, { retryCount = 0 } = {}) { + const options = { ...inputOptions }; + const { method, path: path2, query, defaultBaseURL } = options; + const url = this.buildURL(path2, query, defaultBaseURL); + if ("timeout" in options) + validatePositiveInteger("timeout", options.timeout); + options.timeout = options.timeout ?? this.timeout; + const { bodyHeaders, body } = this.buildBody({ options }); + const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount }); + const req = { + method, + headers: reqHeaders, + ...options.signal && { signal: options.signal }, + ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" }, + ...body && { body }, + ...this.fetchOptions ?? {}, + ...options.fetchOptions ?? {} + }; + return { req, url, timeout: options.timeout }; + } + buildHeaders({ options, method, bodyHeaders, retryCount }) { + let idempotencyHeaders = {}; + if (this.idempotencyHeader && method !== "get") { + if (!options.idempotencyKey) + options.idempotencyKey = this.defaultIdempotencyKey(); + idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; + } + const headers = buildHeaders([ + idempotencyHeaders, + { + Accept: "application/json", + "User-Agent": this.getUserAgent(), + "X-Stainless-Retry-Count": String(retryCount), + ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1e3)) } : {}, + ...getPlatformHeaders() + }, + this.authHeaders(options), + this._options.defaultHeaders, + bodyHeaders, + options.headers + ]); + this.validateHeaders(headers); + return headers.values; + } + buildBody({ options: { body, headers: rawHeaders } }) { + if (!body) { + return { bodyHeaders: void 0, body: void 0 }; + } + const headers = buildHeaders([rawHeaders]); + if ( + // Pass raw type verbatim + ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && // Preserve legacy string encoding behavior for now + headers.values.has("content-type") || // `Blob` is superset of `File` + body instanceof Blob || // `FormData` -> `multipart/form-data` + body instanceof FormData || // `URLSearchParams` -> `application/x-www-form-urlencoded` + body instanceof URLSearchParams || // Send chunked stream (each chunk has own `length`) + globalThis.ReadableStream && body instanceof globalThis.ReadableStream + ) { + return { bodyHeaders: void 0, body }; + } else if (typeof body === "object" && (Symbol.asyncIterator in body || Symbol.iterator in body && "next" in body && typeof body.next === "function")) { + return { bodyHeaders: void 0, body: ReadableStreamFrom(body) }; + } else { + return __classPrivateFieldGet(this, _Stainless_encoder, "f").call(this, { body, headers }); + } + } +}; +_a = Stainless, _Stainless_encoder = /* @__PURE__ */ new WeakMap(), _Stainless_instances = /* @__PURE__ */ new WeakSet(), _Stainless_baseURLOverridden = function _Stainless_baseURLOverridden2() { + return this.baseURL !== "https://api.stainless.com"; +}; +Stainless.Stainless = _a; +Stainless.DEFAULT_TIMEOUT = 6e4; +Stainless.StainlessError = StainlessError; +Stainless.APIError = APIError; +Stainless.APIConnectionError = APIConnectionError; +Stainless.APIConnectionTimeoutError = APIConnectionTimeoutError; +Stainless.APIUserAbortError = APIUserAbortError; +Stainless.NotFoundError = NotFoundError; +Stainless.ConflictError = ConflictError; +Stainless.RateLimitError = RateLimitError; +Stainless.BadRequestError = BadRequestError; +Stainless.AuthenticationError = AuthenticationError; +Stainless.InternalServerError = InternalServerError; +Stainless.PermissionDeniedError = PermissionDeniedError; +Stainless.UnprocessableEntityError = UnprocessableEntityError; +Stainless.toFile = toFile; +Stainless.unwrapFile = unwrapFile; +Stainless.Projects = Projects; +Stainless.Builds = Builds; +Stainless.Orgs = Orgs; +Stainless.Generate = Generate; + +// src/runBuilds.ts +var fs = __toESM(require("fs")); +var CONVENTIONAL_COMMIT_REGEX = new RegExp( + /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?(!?): .*$/ +); +var isValidConventionalCommitMessage = (message) => { + return CONVENTIONAL_COMMIT_REGEX.test(message); +}; +var POLLING_INTERVAL_SECONDS = 5; +var MAX_POLLING_SECONDS = 10 * 60; +async function* runBuilds({ + stainless, + projectName, + baseRevision, + baseBranch, + mergeBranch, + branch, + oasPath, + configPath, + guessConfig = false, + commitMessage, + outputDir +}) { + if (mergeBranch && (oasPath || configPath)) { + throw new Error( + "Cannot specify both merge_branch and oas_path or config_path" + ); + } + if (guessConfig && (configPath || !oasPath)) { + throw new Error( + "If guess_config is true, must have oas_path and no config_path" + ); + } + if (baseRevision && mergeBranch) { + throw new Error("Cannot specify both base_revision and merge_branch"); + } + if (commitMessage && !isValidConventionalCommitMessage(commitMessage)) { + console.warn( + `Commit message: "${commitMessage}" is not in Conventional Commits format: https://www.conventionalcommits.org/en/v1.0.0/. Prepending "feat" and using anyway.` + ); + commitMessage = `feat: ${commitMessage}`; + } + const oasContent = oasPath ? fs.readFileSync(oasPath, "utf-8") : void 0; + let configContent = configPath ? fs.readFileSync(configPath, "utf-8") : void 0; + if (!baseRevision) { + const build = await stainless.builds.create( + { + project: projectName, + revision: mergeBranch ? `${branch}..${mergeBranch}` : { + ...oasContent && { + "openapi.yml": { + content: oasContent + } + }, + ...configContent && { + "openapi.stainless.yml": { + content: configContent + } + } + }, + branch, + commit_message: commitMessage, + allow_empty: true + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1e3 + } + ); + for (const waitFor of ["postgen", "completed"]) { + const { outcomes, documentedSpec } = await pollBuild({ + stainless, + build, + waitFor + }); + let documentedSpecPath = null; + if (outputDir && documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, documentedSpec); + } + yield { + baseOutcomes: null, + outcomes, + documentedSpecPath + }; + } + return; + } + if (!configContent) { + if (guessConfig) { + console.log("Guessing config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.guess({ + branch, + spec: oasContent + }) + )[0]?.content; + } else { + console.log("Saving config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.retrieve({ + branch + }) + )[0]?.content; + } + } + console.log(`Hard resetting ${branch} to ${baseRevision}`); + const { config_commit } = await stainless.projects.branches.create({ + branch_from: baseRevision, + branch, + force: true + }); + console.log(`Hard reset ${branch}, now at ${config_commit.sha}`); + const { base, head } = await stainless.builds.compare( + { + base: { + revision: baseRevision, + branch: baseBranch, + commit_message: commitMessage + }, + head: { + revision: { + ...oasContent && { + "openapi.yml": { + content: oasContent + } + }, + ...configContent && { + "openapi.stainless.yml": { + content: configContent + } + } + }, + branch, + commit_message: commitMessage + } + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1e3 + } + ); + for (const waitFor of ["postgen", "completed"]) { + const results = await Promise.all([ + pollBuild({ stainless, build: base, waitFor }), + pollBuild({ stainless, build: head, waitFor }) + ]); + let documentedSpecPath = null; + if (outputDir && results[1].documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, results[1].documentedSpec); + } + yield { + baseOutcomes: results[0].outcomes, + outcomes: results[1].outcomes, + documentedSpecPath + }; + } + return; +} +async function pollBuild({ + stainless, + build, + waitFor, + pollingIntervalSeconds = POLLING_INTERVAL_SECONDS, + maxPollingSeconds = MAX_POLLING_SECONDS +}) { + const outcomes = {}; + let documentedSpec = null; + const buildId = build.id; + const languages = Object.keys(build.targets); + if (buildId) { + console.log( + `[${buildId}] Created build against ${build.config_commit} for languages: ${languages.join(", ")}` + ); + } else { + console.log(`No new build was created; exiting.`); + return { outcomes, documentedSpec }; + } + const pollingStart = Date.now(); + while (Object.keys(outcomes).length < languages.length && Date.now() - pollingStart < maxPollingSeconds * 1e3) { + const build2 = await stainless.builds.retrieve(buildId); + for (const language of languages) { + if (!(language in outcomes)) { + const buildOutput = build2.targets[language]; + console.log( + `[${buildId}] Build for ${language} has status ${buildOutput.status}` + ); + if ([waitFor, "completed"].includes(buildOutput.status) && buildOutput.commit.status === "completed") { + console.log( + `[${buildId}] Build has output:`, + JSON.stringify(buildOutput) + ); + const diagnostics = []; + try { + for await (const diagnostic of stainless.builds.diagnostics.list( + buildId + )) { + diagnostics.push(diagnostic); + } + } catch (e) { + console.error( + `[${buildId}] Error getting diagnostics, continuing anyway`, + e + ); + } + outcomes[language] = { + ...buildOutput, + commit: buildOutput.commit, + diagnostics + }; + } + } + } + if (!documentedSpec && build2.documented_spec) { + documentedSpec = await Stainless.unwrapFile(build2.documented_spec); + } + await new Promise( + (resolve) => setTimeout(resolve, pollingIntervalSeconds * 1e3) + ); + } + const languagesWithoutOutcome = languages.filter( + (language) => !(language in outcomes) + ); + for (const language of languagesWithoutOutcome) { + console.log( + `[${buildId}] Build for ${language} timed out after ${maxPollingSeconds} seconds` + ); + outcomes[language] = { + object: "build_target", + status: "completed", + lint: { + status: "not_started" + }, + test: { + status: "not_started" + }, + commit: { + status: "completed", + completed: { + conclusion: "timed_out", + commit: null, + merge_conflict_pr: null, + url: null + } + }, + diagnostics: [] + }; + } + return { outcomes, documentedSpec }; +} + +// src/build.ts +async function main() { + try { + const apiKey = (0, import_core.getInput)("stainless_api_key", { required: true }); + const oasPath = (0, import_core.getInput)("oas_path", { required: false }) || void 0; + const configPath = (0, import_core.getInput)("config_path", { required: false }) || void 0; + const projectName = (0, import_core.getInput)("project", { required: true }); + const commitMessage = (0, import_core.getInput)("commit_message", { required: false }) || void 0; + const guessConfig = (0, import_core.getBooleanInput)("guess_config", { required: false }); + const branch = (0, import_core.getInput)("branch", { required: false }) || void 0; + const mergeBranch = (0, import_core.getInput)("merge_branch", { required: false }) || void 0; + const baseRevision = (0, import_core.getInput)("base_revision", { required: false }) || void 0; + const baseBranch = (0, import_core.getInput)("base_branch", { required: false }) || void 0; + const outputDir = (0, import_core.getInput)("output_dir", { required: false }) || void 0; + const stainless = new Stainless({ + project: projectName, + apiKey, + logLevel: "warn" + }); + for await (const { + baseOutcomes, + outcomes, + documentedSpecPath + } of runBuilds({ + stainless, + projectName, + baseRevision, + baseBranch, + mergeBranch, + branch, + oasPath, + configPath, + guessConfig, + commitMessage, + outputDir + })) { + (0, import_core.setOutput)("outcomes", outcomes); + (0, import_core.setOutput)("base_outcomes", baseOutcomes); + (0, import_core.setOutput)("documented_spec_path", documentedSpecPath); + } + } catch (error) { + console.error("Error interacting with API:", error); + process.exit(1); + } +} +main(); +/*! Bundled license information: + +undici/lib/fetch/body.js: + (*! formdata-polyfill. MIT License. Jimmy Wärting *) + +undici/lib/websocket/frame.js: + (*! ws. MIT License. Einar Otto Stangvik *) +*/ diff --git a/dist/index.js b/dist/index.js index 547ebbcc..d4439731 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,39309 +1,29089 @@ -/******/ (() => { // webpackBootstrap -/******/ var __webpack_modules__ = ({ - -/***/ 4914: -/***/ (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; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { return m[k]; } }; - } - Object.defineProperty(o, k2, desc); -}) : (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; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; }; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.issue = exports.issueCommand = void 0; -const os = __importStar(__nccwpck_require__(857)); -const utils_1 = __nccwpck_require__(302); -/** - * Commands - * - * Command Format: - * ::name key=value,key=value::message - * - * Examples: - * ::warning::This is the message - * ::set-env name=MY_VAR::some value - */ -function issueCommand(command, properties, message) { - const cmd = new Command(command, properties, message); - process.stdout.write(cmd.toString() + os.EOL); -} -exports.issueCommand = issueCommand; -function issue(name, message = '') { - issueCommand(name, {}, message); -} -exports.issue = issue; -const CMD_STRING = '::'; -class Command { - constructor(command, properties, message) { - if (!command) { - command = 'missing.command'; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// node_modules/yaml/dist/nodes/identity.js +var require_identity = __commonJS({ + "node_modules/yaml/dist/nodes/identity.js"(exports2) { + "use strict"; + var ALIAS = Symbol.for("yaml.alias"); + var DOC = Symbol.for("yaml.document"); + var MAP = Symbol.for("yaml.map"); + var PAIR = Symbol.for("yaml.pair"); + var SCALAR = Symbol.for("yaml.scalar"); + var SEQ = Symbol.for("yaml.seq"); + var NODE_TYPE = Symbol.for("yaml.node.type"); + var isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS; + var isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC; + var isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP; + var isPair = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === PAIR; + var isScalar = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SCALAR; + var isSeq = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === SEQ; + function isCollection(node) { + if (node && typeof node === "object") + switch (node[NODE_TYPE]) { + case MAP: + case SEQ: + return true; } - this.command = command; - this.properties = properties; - this.message = message; + return false; } - toString() { - let cmdStr = CMD_STRING + this.command; - if (this.properties && Object.keys(this.properties).length > 0) { - cmdStr += ' '; - let first = true; - for (const key in this.properties) { - if (this.properties.hasOwnProperty(key)) { - const val = this.properties[key]; - if (val) { - if (first) { - first = false; - } - else { - cmdStr += ','; - } - cmdStr += `${key}=${escapeProperty(val)}`; - } - } - } + function isNode(node) { + if (node && typeof node === "object") + switch (node[NODE_TYPE]) { + case ALIAS: + case MAP: + case SCALAR: + case SEQ: + return true; } - cmdStr += `${CMD_STRING}${escapeData(this.message)}`; - return cmdStr; - } -} -function escapeData(s) { - return (0, utils_1.toCommandValue)(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A'); -} -function escapeProperty(s) { - return (0, utils_1.toCommandValue)(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A') - .replace(/:/g, '%3A') - .replace(/,/g, '%2C'); -} -//# sourceMappingURL=command.js.map - -/***/ }), - -/***/ 7484: -/***/ (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; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { return m[k]; } }; - } - Object.defineProperty(o, k2, desc); -}) : (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; + return false; + } + var hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor; + exports2.ALIAS = ALIAS; + exports2.DOC = DOC; + exports2.MAP = MAP; + exports2.NODE_TYPE = NODE_TYPE; + exports2.PAIR = PAIR; + exports2.SCALAR = SCALAR; + exports2.SEQ = SEQ; + exports2.hasAnchor = hasAnchor; + exports2.isAlias = isAlias; + exports2.isCollection = isCollection; + exports2.isDocument = isDocument; + exports2.isMap = isMap; + exports2.isNode = isNode; + exports2.isPair = isPair; + exports2.isScalar = isScalar; + exports2.isSeq = isSeq; + } }); -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; -}; -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.platform = exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = exports.markdownSummary = exports.summary = exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; -const command_1 = __nccwpck_require__(4914); -const file_command_1 = __nccwpck_require__(4753); -const utils_1 = __nccwpck_require__(302); -const os = __importStar(__nccwpck_require__(857)); -const path = __importStar(__nccwpck_require__(6928)); -const oidc_utils_1 = __nccwpck_require__(5306); -/** - * The code to exit an action - */ -var ExitCode; -(function (ExitCode) { - /** - * A code indicating that the action was successful - */ - ExitCode[ExitCode["Success"] = 0] = "Success"; - /** - * A code indicating that the action was a failure - */ - ExitCode[ExitCode["Failure"] = 1] = "Failure"; -})(ExitCode || (exports.ExitCode = ExitCode = {})); -//----------------------------------------------------------------------- -// Variables -//----------------------------------------------------------------------- -/** - * Sets env variable for this action and future actions in the job - * @param name the name of the variable to set - * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function exportVariable(name, val) { - const convertedVal = (0, utils_1.toCommandValue)(val); - process.env[name] = convertedVal; - const filePath = process.env['GITHUB_ENV'] || ''; - if (filePath) { - return (0, file_command_1.issueFileCommand)('ENV', (0, file_command_1.prepareKeyValueMessage)(name, val)); - } - (0, command_1.issueCommand)('set-env', { name }, convertedVal); -} -exports.exportVariable = exportVariable; -/** - * Registers a secret which will get masked from logs - * @param secret value of the secret - */ -function setSecret(secret) { - (0, command_1.issueCommand)('add-mask', {}, secret); -} -exports.setSecret = setSecret; -/** - * Prepends inputPath to the PATH (for this action and future actions) - * @param inputPath - */ -function addPath(inputPath) { - const filePath = process.env['GITHUB_PATH'] || ''; - if (filePath) { - (0, file_command_1.issueFileCommand)('PATH', inputPath); - } - else { - (0, command_1.issueCommand)('add-path', {}, inputPath); - } - process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; -} -exports.addPath = addPath; -/** - * Gets the value of an input. - * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed. - * Returns an empty string if the value is not defined. - * - * @param name name of the input to get - * @param options optional. See InputOptions. - * @returns string - */ -function getInput(name, options) { - const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; - if (options && options.required && !val) { - throw new Error(`Input required and not supplied: ${name}`); + +// node_modules/yaml/dist/visit.js +var require_visit = __commonJS({ + "node_modules/yaml/dist/visit.js"(exports2) { + "use strict"; + var identity = require_identity(); + var BREAK = Symbol("break visit"); + var SKIP = Symbol("skip children"); + var REMOVE = Symbol("remove node"); + function visit(node, visitor) { + const visitor_ = initVisitor(visitor); + if (identity.isDocument(node)) { + const cd = visit_(null, node.contents, visitor_, Object.freeze([node])); + if (cd === REMOVE) + node.contents = null; + } else + visit_(null, node, visitor_, Object.freeze([])); } - if (options && options.trimWhitespace === false) { - return val; + visit.BREAK = BREAK; + visit.SKIP = SKIP; + visit.REMOVE = REMOVE; + function visit_(key, node, visitor, path2) { + const ctrl = callVisitor(key, node, visitor, path2); + if (identity.isNode(ctrl) || identity.isPair(ctrl)) { + replaceNode(key, path2, ctrl); + return visit_(key, ctrl, visitor, path2); + } + if (typeof ctrl !== "symbol") { + if (identity.isCollection(node)) { + path2 = Object.freeze(path2.concat(node)); + for (let i = 0; i < node.items.length; ++i) { + const ci = visit_(i, node.items[i], visitor, path2); + if (typeof ci === "number") + i = ci - 1; + else if (ci === BREAK) + return BREAK; + else if (ci === REMOVE) { + node.items.splice(i, 1); + i -= 1; + } + } + } else if (identity.isPair(node)) { + path2 = Object.freeze(path2.concat(node)); + const ck = visit_("key", node.key, visitor, path2); + if (ck === BREAK) + return BREAK; + else if (ck === REMOVE) + node.key = null; + const cv = visit_("value", node.value, visitor, path2); + if (cv === BREAK) + return BREAK; + else if (cv === REMOVE) + node.value = null; + } + } + return ctrl; + } + async function visitAsync(node, visitor) { + const visitor_ = initVisitor(visitor); + if (identity.isDocument(node)) { + const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node])); + if (cd === REMOVE) + node.contents = null; + } else + await visitAsync_(null, node, visitor_, Object.freeze([])); } - return val.trim(); -} -exports.getInput = getInput; -/** - * Gets the values of an multiline input. Each value is also trimmed. - * - * @param name name of the input to get - * @param options optional. See InputOptions. - * @returns string[] - * - */ -function getMultilineInput(name, options) { - const inputs = getInput(name, options) - .split('\n') - .filter(x => x !== ''); - if (options && options.trimWhitespace === false) { - return inputs; + visitAsync.BREAK = BREAK; + visitAsync.SKIP = SKIP; + visitAsync.REMOVE = REMOVE; + async function visitAsync_(key, node, visitor, path2) { + const ctrl = await callVisitor(key, node, visitor, path2); + if (identity.isNode(ctrl) || identity.isPair(ctrl)) { + replaceNode(key, path2, ctrl); + return visitAsync_(key, ctrl, visitor, path2); + } + if (typeof ctrl !== "symbol") { + if (identity.isCollection(node)) { + path2 = Object.freeze(path2.concat(node)); + for (let i = 0; i < node.items.length; ++i) { + const ci = await visitAsync_(i, node.items[i], visitor, path2); + if (typeof ci === "number") + i = ci - 1; + else if (ci === BREAK) + return BREAK; + else if (ci === REMOVE) { + node.items.splice(i, 1); + i -= 1; + } + } + } else if (identity.isPair(node)) { + path2 = Object.freeze(path2.concat(node)); + const ck = await visitAsync_("key", node.key, visitor, path2); + if (ck === BREAK) + return BREAK; + else if (ck === REMOVE) + node.key = null; + const cv = await visitAsync_("value", node.value, visitor, path2); + if (cv === BREAK) + return BREAK; + else if (cv === REMOVE) + node.value = null; + } + } + return ctrl; + } + function initVisitor(visitor) { + if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) { + return Object.assign({ + Alias: visitor.Node, + Map: visitor.Node, + Scalar: visitor.Node, + Seq: visitor.Node + }, visitor.Value && { + Map: visitor.Value, + Scalar: visitor.Value, + Seq: visitor.Value + }, visitor.Collection && { + Map: visitor.Collection, + Seq: visitor.Collection + }, visitor); + } + return visitor; + } + function callVisitor(key, node, visitor, path2) { + if (typeof visitor === "function") + return visitor(key, node, path2); + if (identity.isMap(node)) + return visitor.Map?.(key, node, path2); + if (identity.isSeq(node)) + return visitor.Seq?.(key, node, path2); + if (identity.isPair(node)) + return visitor.Pair?.(key, node, path2); + if (identity.isScalar(node)) + return visitor.Scalar?.(key, node, path2); + if (identity.isAlias(node)) + return visitor.Alias?.(key, node, path2); + return void 0; + } + function replaceNode(key, path2, node) { + const parent = path2[path2.length - 1]; + if (identity.isCollection(parent)) { + parent.items[key] = node; + } else if (identity.isPair(parent)) { + if (key === "key") + parent.key = node; + else + parent.value = node; + } else if (identity.isDocument(parent)) { + parent.contents = node; + } else { + const pt = identity.isAlias(parent) ? "alias" : "scalar"; + throw new Error(`Cannot replace node with ${pt} parent`); + } } - return inputs.map(input => input.trim()); -} -exports.getMultilineInput = getMultilineInput; -/** - * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification. - * Support boolean input list: `true | True | TRUE | false | False | FALSE` . - * The return value is also in boolean type. - * ref: https://yaml.org/spec/1.2/spec.html#id2804923 - * - * @param name name of the input to get - * @param options optional. See InputOptions. - * @returns boolean - */ -function getBooleanInput(name, options) { - const trueValue = ['true', 'True', 'TRUE']; - const falseValue = ['false', 'False', 'FALSE']; - const val = getInput(name, options); - if (trueValue.includes(val)) - return true; - if (falseValue.includes(val)) - return false; - throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + - `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); -} -exports.getBooleanInput = getBooleanInput; -/** - * Sets the value of an output. - * - * @param name name of the output to set - * @param value value to store. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function setOutput(name, value) { - const filePath = process.env['GITHUB_OUTPUT'] || ''; - if (filePath) { - return (0, file_command_1.issueFileCommand)('OUTPUT', (0, file_command_1.prepareKeyValueMessage)(name, value)); - } - process.stdout.write(os.EOL); - (0, command_1.issueCommand)('set-output', { name }, (0, utils_1.toCommandValue)(value)); -} -exports.setOutput = setOutput; -/** - * Enables or disables the echoing of commands into stdout for the rest of the step. - * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. - * - */ -function setCommandEcho(enabled) { - (0, command_1.issue)('echo', enabled ? 'on' : 'off'); -} -exports.setCommandEcho = setCommandEcho; -//----------------------------------------------------------------------- -// Results -//----------------------------------------------------------------------- -/** - * Sets the action status to failed. - * When the action exits it will be with an exit code of 1 - * @param message add error issue message - */ -function setFailed(message) { - process.exitCode = ExitCode.Failure; - error(message); -} -exports.setFailed = setFailed; -//----------------------------------------------------------------------- -// Logging Commands -//----------------------------------------------------------------------- -/** - * Gets whether Actions Step Debug is on or not - */ -function isDebug() { - return process.env['RUNNER_DEBUG'] === '1'; -} -exports.isDebug = isDebug; -/** - * Writes debug message to user log - * @param message debug message - */ -function debug(message) { - (0, command_1.issueCommand)('debug', {}, message); -} -exports.debug = debug; -/** - * Adds an error issue - * @param message error issue message. Errors will be converted to string via toString() - * @param properties optional properties to add to the annotation. - */ -function error(message, properties = {}) { - (0, command_1.issueCommand)('error', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); -} -exports.error = error; -/** - * Adds a warning issue - * @param message warning issue message. Errors will be converted to string via toString() - * @param properties optional properties to add to the annotation. - */ -function warning(message, properties = {}) { - (0, command_1.issueCommand)('warning', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); -} -exports.warning = warning; -/** - * Adds a notice issue - * @param message notice issue message. Errors will be converted to string via toString() - * @param properties optional properties to add to the annotation. - */ -function notice(message, properties = {}) { - (0, command_1.issueCommand)('notice', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); -} -exports.notice = notice; -/** - * Writes info to log with console.log. - * @param message info message - */ -function info(message) { - process.stdout.write(message + os.EOL); -} -exports.info = info; -/** - * Begin an output group. - * - * Output until the next `groupEnd` will be foldable in this group - * - * @param name The name of the output group - */ -function startGroup(name) { - (0, command_1.issue)('group', name); -} -exports.startGroup = startGroup; -/** - * End an output group. - */ -function endGroup() { - (0, command_1.issue)('endgroup'); -} -exports.endGroup = endGroup; -/** - * Wrap an asynchronous function call in a group. - * - * Returns the same type as the function itself. - * - * @param name The name of the group - * @param fn The function to wrap in the group - */ -function group(name, fn) { - return __awaiter(this, void 0, void 0, function* () { - startGroup(name); - let result; - try { - result = yield fn(); + exports2.visit = visit; + exports2.visitAsync = visitAsync; + } +}); + +// node_modules/yaml/dist/doc/directives.js +var require_directives = __commonJS({ + "node_modules/yaml/dist/doc/directives.js"(exports2) { + "use strict"; + var identity = require_identity(); + var visit = require_visit(); + var escapeChars = { + "!": "%21", + ",": "%2C", + "[": "%5B", + "]": "%5D", + "{": "%7B", + "}": "%7D" + }; + var escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, (ch) => escapeChars[ch]); + var Directives = class _Directives { + constructor(yaml, tags) { + this.docStart = null; + this.docEnd = false; + this.yaml = Object.assign({}, _Directives.defaultYaml, yaml); + this.tags = Object.assign({}, _Directives.defaultTags, tags); + } + clone() { + const copy = new _Directives(this.yaml, this.tags); + copy.docStart = this.docStart; + return copy; + } + /** + * During parsing, get a Directives instance for the current document and + * update the stream state according to the current version's spec. + */ + atDocument() { + const res = new _Directives(this.yaml, this.tags); + switch (this.yaml.version) { + case "1.1": + this.atNextDocument = true; + break; + case "1.2": + this.atNextDocument = false; + this.yaml = { + explicit: _Directives.defaultYaml.explicit, + version: "1.2" + }; + this.tags = Object.assign({}, _Directives.defaultTags); + break; } - finally { - endGroup(); + return res; + } + /** + * @param onError - May be called even if the action was successful + * @returns `true` on success + */ + add(line, onError) { + if (this.atNextDocument) { + this.yaml = { explicit: _Directives.defaultYaml.explicit, version: "1.1" }; + this.tags = Object.assign({}, _Directives.defaultTags); + this.atNextDocument = false; } - return result; - }); -} -exports.group = group; -//----------------------------------------------------------------------- -// Wrapper action state -//----------------------------------------------------------------------- -/** - * Saves state for current action, the state can only be retrieved by this action's post job execution. - * - * @param name name of the state to store - * @param value value to store. Non-string values will be converted to a string via JSON.stringify - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -function saveState(name, value) { - const filePath = process.env['GITHUB_STATE'] || ''; - if (filePath) { - return (0, file_command_1.issueFileCommand)('STATE', (0, file_command_1.prepareKeyValueMessage)(name, value)); - } - (0, command_1.issueCommand)('save-state', { name }, (0, utils_1.toCommandValue)(value)); -} -exports.saveState = saveState; -/** - * Gets the value of an state set by this action's main execution. - * - * @param name name of the state to get - * @returns string - */ -function getState(name) { - return process.env[`STATE_${name}`] || ''; -} -exports.getState = getState; -function getIDToken(aud) { - return __awaiter(this, void 0, void 0, function* () { - return yield oidc_utils_1.OidcClient.getIDToken(aud); - }); -} -exports.getIDToken = getIDToken; -/** - * Summary exports - */ -var summary_1 = __nccwpck_require__(1847); -Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); -/** - * @deprecated use core.summary - */ -var summary_2 = __nccwpck_require__(1847); -Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); -/** - * Path exports - */ -var path_utils_1 = __nccwpck_require__(1976); -Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); -Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); -Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); -/** - * Platform utilities exports - */ -exports.platform = __importStar(__nccwpck_require__(8968)); -//# sourceMappingURL=core.js.map - -/***/ }), - -/***/ 4753: -/***/ (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; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { return m[k]; } }; - } - Object.defineProperty(o, k2, desc); -}) : (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; + const parts = line.trim().split(/[ \t]+/); + const name = parts.shift(); + switch (name) { + case "%TAG": { + if (parts.length !== 2) { + onError(0, "%TAG directive should contain exactly two parts"); + if (parts.length < 2) + return false; + } + const [handle, prefix] = parts; + this.tags[handle] = prefix; + return true; + } + case "%YAML": { + this.yaml.explicit = true; + if (parts.length !== 1) { + onError(0, "%YAML directive should contain exactly one part"); + return false; + } + const [version] = parts; + if (version === "1.1" || version === "1.2") { + this.yaml.version = version; + return true; + } else { + const isValid = /^\d+\.\d+$/.test(version); + onError(6, `Unsupported YAML version ${version}`, isValid); + return false; + } + } + default: + onError(0, `Unknown directive ${name}`, true); + return false; + } + } + /** + * Resolves a tag, matching handles to those defined in %TAG directives. + * + * @returns Resolved tag, which may also be the non-specific tag `'!'` or a + * `'!local'` tag, or `null` if unresolvable. + */ + tagName(source, onError) { + if (source === "!") + return "!"; + if (source[0] !== "!") { + onError(`Not a valid tag: ${source}`); + return null; + } + if (source[1] === "<") { + const verbatim = source.slice(2, -1); + if (verbatim === "!" || verbatim === "!!") { + onError(`Verbatim tags aren't resolved, so ${source} is invalid.`); + return null; + } + if (source[source.length - 1] !== ">") + onError("Verbatim tags must end with a >"); + return verbatim; + } + const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s); + if (!suffix) + onError(`The ${source} tag has no suffix`); + const prefix = this.tags[handle]; + if (prefix) { + try { + return prefix + decodeURIComponent(suffix); + } catch (error2) { + onError(String(error2)); + return null; + } + } + if (handle === "!") + return source; + onError(`Could not resolve tag: ${source}`); + return null; + } + /** + * Given a fully resolved tag, returns its printable string form, + * taking into account current tag prefixes and defaults. + */ + tagString(tag) { + for (const [handle, prefix] of Object.entries(this.tags)) { + if (tag.startsWith(prefix)) + return handle + escapeTagName(tag.substring(prefix.length)); + } + return tag[0] === "!" ? tag : `!<${tag}>`; + } + toString(doc) { + const lines = this.yaml.explicit ? [`%YAML ${this.yaml.version || "1.2"}`] : []; + const tagEntries = Object.entries(this.tags); + let tagNames; + if (doc && tagEntries.length > 0 && identity.isNode(doc.contents)) { + const tags = {}; + visit.visit(doc.contents, (_key, node) => { + if (identity.isNode(node) && node.tag) + tags[node.tag] = true; + }); + tagNames = Object.keys(tags); + } else + tagNames = []; + for (const [handle, prefix] of tagEntries) { + if (handle === "!!" && prefix === "tag:yaml.org,2002:") + continue; + if (!doc || tagNames.some((tn) => tn.startsWith(prefix))) + lines.push(`%TAG ${handle} ${prefix}`); + } + return lines.join("\n"); + } + }; + Directives.defaultYaml = { explicit: false, version: "1.2" }; + Directives.defaultTags = { "!!": "tag:yaml.org,2002:" }; + exports2.Directives = Directives; + } }); -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.prepareKeyValueMessage = exports.issueFileCommand = void 0; -// We use any as a valid input type -/* eslint-disable @typescript-eslint/no-explicit-any */ -const crypto = __importStar(__nccwpck_require__(6982)); -const fs = __importStar(__nccwpck_require__(9896)); -const os = __importStar(__nccwpck_require__(857)); -const utils_1 = __nccwpck_require__(302); -function issueFileCommand(command, message) { - const filePath = process.env[`GITHUB_${command}`]; - if (!filePath) { - throw new Error(`Unable to find environment variable for file command ${command}`); - } - if (!fs.existsSync(filePath)) { - throw new Error(`Missing file at path: ${filePath}`); - } - fs.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { - encoding: 'utf8' - }); -} -exports.issueFileCommand = issueFileCommand; -function prepareKeyValueMessage(key, value) { - const delimiter = `ghadelimiter_${crypto.randomUUID()}`; - const convertedValue = (0, utils_1.toCommandValue)(value); - // These should realistically never happen, but just in case someone finds a - // way to exploit uuid generation let's not allow keys or values that contain - // the delimiter. - if (key.includes(delimiter)) { - throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); - } - if (convertedValue.includes(delimiter)) { - throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); - } - return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; -} -exports.prepareKeyValueMessage = prepareKeyValueMessage; -//# sourceMappingURL=file-command.js.map - -/***/ }), -/***/ 5306: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.OidcClient = void 0; -const http_client_1 = __nccwpck_require__(4844); -const auth_1 = __nccwpck_require__(4552); -const core_1 = __nccwpck_require__(7484); -class OidcClient { - static createHttpClient(allowRetry = true, maxRetry = 10) { - const requestOptions = { - allowRetries: allowRetry, - maxRetries: maxRetry - }; - return new http_client_1.HttpClient('actions/oidc-client', [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions); +// node_modules/yaml/dist/doc/anchors.js +var require_anchors = __commonJS({ + "node_modules/yaml/dist/doc/anchors.js"(exports2) { + "use strict"; + var identity = require_identity(); + var visit = require_visit(); + function anchorIsValid(anchor) { + if (/[\x00-\x19\s,[\]{}]/.test(anchor)) { + const sa = JSON.stringify(anchor); + const msg = `Anchor must not contain whitespace or control characters: ${sa}`; + throw new Error(msg); + } + return true; } - static getRequestToken() { - const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN']; - if (!token) { - throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable'); + function anchorNames(root) { + const anchors = /* @__PURE__ */ new Set(); + visit.visit(root, { + Value(_key, node) { + if (node.anchor) + anchors.add(node.anchor); } - return token; + }); + return anchors; } - static getIDTokenUrl() { - const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL']; - if (!runtimeUrl) { - throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable'); - } - return runtimeUrl; + function findNewAnchor(prefix, exclude) { + for (let i = 1; true; ++i) { + const name = `${prefix}${i}`; + if (!exclude.has(name)) + return name; + } } - static getCall(id_token_url) { - var _a; - return __awaiter(this, void 0, void 0, function* () { - const httpclient = OidcClient.createHttpClient(); - const res = yield httpclient - .getJson(id_token_url) - .catch(error => { - throw new Error(`Failed to get ID Token. \n - Error Code : ${error.statusCode}\n - Error Message: ${error.message}`); - }); - const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value; - if (!id_token) { - throw new Error('Response json body do not have ID Token field'); + function createNodeAnchors(doc, prefix) { + const aliasObjects = []; + const sourceObjects = /* @__PURE__ */ new Map(); + let prevAnchors = null; + return { + onAnchor: (source) => { + aliasObjects.push(source); + prevAnchors ?? (prevAnchors = anchorNames(doc)); + const anchor = findNewAnchor(prefix, prevAnchors); + prevAnchors.add(anchor); + return anchor; + }, + /** + * With circular references, the source node is only resolved after all + * of its child nodes are. This is why anchors are set only after all of + * the nodes have been created. + */ + setAnchors: () => { + for (const source of aliasObjects) { + const ref = sourceObjects.get(source); + if (typeof ref === "object" && ref.anchor && (identity.isScalar(ref.node) || identity.isCollection(ref.node))) { + ref.node.anchor = ref.anchor; + } else { + const error2 = new Error("Failed to resolve repeated object (this should not happen)"); + error2.source = source; + throw error2; } - return id_token; - }); + } + }, + sourceObjects + }; } - static getIDToken(audience) { - return __awaiter(this, void 0, void 0, function* () { - try { - // New ID Token is requested from action service - let id_token_url = OidcClient.getIDTokenUrl(); - if (audience) { - const encodedAudience = encodeURIComponent(audience); - id_token_url = `${id_token_url}&audience=${encodedAudience}`; - } - (0, core_1.debug)(`ID token url is ${id_token_url}`); - const id_token = yield OidcClient.getCall(id_token_url); - (0, core_1.setSecret)(id_token); - return id_token; - } - catch (error) { - throw new Error(`Error message: ${error.message}`); + exports2.anchorIsValid = anchorIsValid; + exports2.anchorNames = anchorNames; + exports2.createNodeAnchors = createNodeAnchors; + exports2.findNewAnchor = findNewAnchor; + } +}); + +// node_modules/yaml/dist/doc/applyReviver.js +var require_applyReviver = __commonJS({ + "node_modules/yaml/dist/doc/applyReviver.js"(exports2) { + "use strict"; + function applyReviver(reviver, obj, key, val) { + if (val && typeof val === "object") { + if (Array.isArray(val)) { + for (let i = 0, len = val.length; i < len; ++i) { + const v0 = val[i]; + const v1 = applyReviver(reviver, val, String(i), v0); + if (v1 === void 0) + delete val[i]; + else if (v1 !== v0) + val[i] = v1; + } + } else if (val instanceof Map) { + for (const k of Array.from(val.keys())) { + const v0 = val.get(k); + const v1 = applyReviver(reviver, val, k, v0); + if (v1 === void 0) + val.delete(k); + else if (v1 !== v0) + val.set(k, v1); + } + } else if (val instanceof Set) { + for (const v0 of Array.from(val)) { + const v1 = applyReviver(reviver, val, v0, v0); + if (v1 === void 0) + val.delete(v0); + else if (v1 !== v0) { + val.delete(v0); + val.add(v1); } - }); + } + } else { + for (const [k, v0] of Object.entries(val)) { + const v1 = applyReviver(reviver, val, k, v0); + if (v1 === void 0) + delete val[k]; + else if (v1 !== v0) + val[k] = v1; + } + } + } + return reviver.call(obj, key, val); } -} -exports.OidcClient = OidcClient; -//# sourceMappingURL=oidc-utils.js.map - -/***/ }), - -/***/ 1976: -/***/ (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; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { return m[k]; } }; - } - Object.defineProperty(o, k2, desc); -}) : (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; + exports2.applyReviver = applyReviver; + } }); -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.toPlatformPath = exports.toWin32Path = exports.toPosixPath = void 0; -const path = __importStar(__nccwpck_require__(6928)); -/** - * toPosixPath converts the given path to the posix form. On Windows, \\ will be - * replaced with /. - * - * @param pth. Path to transform. - * @return string Posix path. - */ -function toPosixPath(pth) { - return pth.replace(/[\\]/g, '/'); -} -exports.toPosixPath = toPosixPath; -/** - * toWin32Path converts the given path to the win32 form. On Linux, / will be - * replaced with \\. - * - * @param pth. Path to transform. - * @return string Win32 path. - */ -function toWin32Path(pth) { - return pth.replace(/[/]/g, '\\'); -} -exports.toWin32Path = toWin32Path; -/** - * toPlatformPath converts the given path to a platform-specific path. It does - * this by replacing instances of / and \ with the platform-specific path - * separator. - * - * @param pth The path to platformize. - * @return string The platform-specific path. - */ -function toPlatformPath(pth) { - return pth.replace(/[/\\]/g, path.sep); -} -exports.toPlatformPath = toPlatformPath; -//# sourceMappingURL=path-utils.js.map -/***/ }), - -/***/ 8968: -/***/ (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; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { return m[k]; } }; - } - Object.defineProperty(o, k2, desc); -}) : (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; +// node_modules/yaml/dist/nodes/toJS.js +var require_toJS = __commonJS({ + "node_modules/yaml/dist/nodes/toJS.js"(exports2) { + "use strict"; + var identity = require_identity(); + function toJS(value, arg, ctx) { + if (Array.isArray(value)) + return value.map((v, i) => toJS(v, String(i), ctx)); + if (value && typeof value.toJSON === "function") { + if (!ctx || !identity.hasAnchor(value)) + return value.toJSON(arg, ctx); + const data = { aliasCount: 0, count: 1, res: void 0 }; + ctx.anchors.set(value, data); + ctx.onCreate = (res2) => { + data.res = res2; + delete ctx.onCreate; + }; + const res = value.toJSON(arg, ctx); + if (ctx.onCreate) + ctx.onCreate(res); + return res; + } + if (typeof value === "bigint" && !ctx?.keep) + return Number(value); + return value; + } + exports2.toJS = toJS; + } }); -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; -}; -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.getDetails = exports.isLinux = exports.isMacOS = exports.isWindows = exports.arch = exports.platform = void 0; -const os_1 = __importDefault(__nccwpck_require__(857)); -const exec = __importStar(__nccwpck_require__(5236)); -const getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { - const { stdout: version } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', undefined, { - silent: true - }); - const { stdout: name } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', undefined, { - silent: true - }); - return { - name: name.trim(), - version: version.trim() + +// node_modules/yaml/dist/nodes/Node.js +var require_Node = __commonJS({ + "node_modules/yaml/dist/nodes/Node.js"(exports2) { + "use strict"; + var applyReviver = require_applyReviver(); + var identity = require_identity(); + var toJS = require_toJS(); + var NodeBase = class { + constructor(type) { + Object.defineProperty(this, identity.NODE_TYPE, { value: type }); + } + /** Create a copy of this node. */ + clone() { + const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this)); + if (this.range) + copy.range = this.range.slice(); + return copy; + } + /** A plain JavaScript representation of this node. */ + toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) { + if (!identity.isDocument(doc)) + throw new TypeError("A document argument is required"); + const ctx = { + anchors: /* @__PURE__ */ new Map(), + doc, + keep: true, + mapAsMap: mapAsMap === true, + mapKeyWarned: false, + maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100 + }; + const res = toJS.toJS(this, "", ctx); + if (typeof onAnchor === "function") + for (const { count, res: res2 } of ctx.anchors.values()) + onAnchor(res2, count); + return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res; + } }; + exports2.NodeBase = NodeBase; + } }); -const getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { - var _a, _b, _c, _d; - const { stdout } = yield exec.getExecOutput('sw_vers', undefined, { - silent: true - }); - const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : ''; - const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ''; - return { - name, - version + +// node_modules/yaml/dist/nodes/Alias.js +var require_Alias = __commonJS({ + "node_modules/yaml/dist/nodes/Alias.js"(exports2) { + "use strict"; + var anchors = require_anchors(); + var visit = require_visit(); + var identity = require_identity(); + var Node = require_Node(); + var toJS = require_toJS(); + var Alias = class extends Node.NodeBase { + constructor(source) { + super(identity.ALIAS); + this.source = source; + Object.defineProperty(this, "tag", { + set() { + throw new Error("Alias nodes cannot have tags"); + } + }); + } + /** + * Resolve the value of this alias within `doc`, finding the last + * instance of the `source` anchor before this node. + */ + resolve(doc, ctx) { + let nodes; + if (ctx?.aliasResolveCache) { + nodes = ctx.aliasResolveCache; + } else { + nodes = []; + visit.visit(doc, { + Node: (_key, node) => { + if (identity.isAlias(node) || identity.hasAnchor(node)) + nodes.push(node); + } + }); + if (ctx) + ctx.aliasResolveCache = nodes; + } + let found = void 0; + for (const node of nodes) { + if (node === this) + break; + if (node.anchor === this.source) + found = node; + } + return found; + } + toJSON(_arg, ctx) { + if (!ctx) + return { source: this.source }; + const { anchors: anchors2, doc, maxAliasCount } = ctx; + const source = this.resolve(doc, ctx); + if (!source) { + const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`; + throw new ReferenceError(msg); + } + let data = anchors2.get(source); + if (!data) { + toJS.toJS(source, null, ctx); + data = anchors2.get(source); + } + if (!data || data.res === void 0) { + const msg = "This should not happen: Alias anchor was not resolved?"; + throw new ReferenceError(msg); + } + if (maxAliasCount >= 0) { + data.count += 1; + if (data.aliasCount === 0) + data.aliasCount = getAliasCount(doc, source, anchors2); + if (data.count * data.aliasCount > maxAliasCount) { + const msg = "Excessive alias count indicates a resource exhaustion attack"; + throw new ReferenceError(msg); + } + } + return data.res; + } + toString(ctx, _onComment, _onChompKeep) { + const src = `*${this.source}`; + if (ctx) { + anchors.anchorIsValid(this.source); + if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) { + const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`; + throw new Error(msg); + } + if (ctx.implicitKey) + return `${src} `; + } + return src; + } }; + function getAliasCount(doc, node, anchors2) { + if (identity.isAlias(node)) { + const source = node.resolve(doc); + const anchor = anchors2 && source && anchors2.get(source); + return anchor ? anchor.count * anchor.aliasCount : 0; + } else if (identity.isCollection(node)) { + let count = 0; + for (const item of node.items) { + const c = getAliasCount(doc, item, anchors2); + if (c > count) + count = c; + } + return count; + } else if (identity.isPair(node)) { + const kc = getAliasCount(doc, node.key, anchors2); + const vc = getAliasCount(doc, node.value, anchors2); + return Math.max(kc, vc); + } + return 1; + } + exports2.Alias = Alias; + } }); -const getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { - const { stdout } = yield exec.getExecOutput('lsb_release', ['-i', '-r', '-s'], { - silent: true - }); - const [name, version] = stdout.trim().split('\n'); - return { - name, - version + +// node_modules/yaml/dist/nodes/Scalar.js +var require_Scalar = __commonJS({ + "node_modules/yaml/dist/nodes/Scalar.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Node = require_Node(); + var toJS = require_toJS(); + var isScalarValue = (value) => !value || typeof value !== "function" && typeof value !== "object"; + var Scalar = class extends Node.NodeBase { + constructor(value) { + super(identity.SCALAR); + this.value = value; + } + toJSON(arg, ctx) { + return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx); + } + toString() { + return String(this.value); + } }; + Scalar.BLOCK_FOLDED = "BLOCK_FOLDED"; + Scalar.BLOCK_LITERAL = "BLOCK_LITERAL"; + Scalar.PLAIN = "PLAIN"; + Scalar.QUOTE_DOUBLE = "QUOTE_DOUBLE"; + Scalar.QUOTE_SINGLE = "QUOTE_SINGLE"; + exports2.Scalar = Scalar; + exports2.isScalarValue = isScalarValue; + } }); -exports.platform = os_1.default.platform(); -exports.arch = os_1.default.arch(); -exports.isWindows = exports.platform === 'win32'; -exports.isMacOS = exports.platform === 'darwin'; -exports.isLinux = exports.platform === 'linux'; -function getDetails() { - return __awaiter(this, void 0, void 0, function* () { - return Object.assign(Object.assign({}, (yield (exports.isWindows - ? getWindowsInfo() - : exports.isMacOS - ? getMacOsInfo() - : getLinuxInfo()))), { platform: exports.platform, - arch: exports.arch, - isWindows: exports.isWindows, - isMacOS: exports.isMacOS, - isLinux: exports.isLinux }); - }); -} -exports.getDetails = getDetails; -//# sourceMappingURL=platform.js.map - -/***/ }), - -/***/ 1847: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = void 0; -const os_1 = __nccwpck_require__(857); -const fs_1 = __nccwpck_require__(9896); -const { access, appendFile, writeFile } = fs_1.promises; -exports.SUMMARY_ENV_VAR = 'GITHUB_STEP_SUMMARY'; -exports.SUMMARY_DOCS_URL = 'https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary'; -class Summary { - constructor() { - this._buffer = ''; - } - /** - * Finds the summary file path from the environment, rejects if env var is not found or file does not exist - * Also checks r/w permissions. - * - * @returns step summary file path - */ - filePath() { - return __awaiter(this, void 0, void 0, function* () { - if (this._filePath) { - return this._filePath; - } - const pathFromEnv = process.env[exports.SUMMARY_ENV_VAR]; - if (!pathFromEnv) { - throw new Error(`Unable to find environment variable for $${exports.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); - } - try { - yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); - } - catch (_a) { - throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); - } - this._filePath = pathFromEnv; - return this._filePath; - }); +// node_modules/yaml/dist/doc/createNode.js +var require_createNode = __commonJS({ + "node_modules/yaml/dist/doc/createNode.js"(exports2) { + "use strict"; + var Alias = require_Alias(); + var identity = require_identity(); + var Scalar = require_Scalar(); + var defaultTagPrefix = "tag:yaml.org,2002:"; + function findTagObject(value, tagName, tags) { + if (tagName) { + const match = tags.filter((t) => t.tag === tagName); + const tagObj = match.find((t) => !t.format) ?? match[0]; + if (!tagObj) + throw new Error(`Tag ${tagName} not found`); + return tagObj; + } + return tags.find((t) => t.identify?.(value) && !t.format); } - /** - * Wraps content in an HTML tag, adding any HTML attributes - * - * @param {string} tag HTML tag to wrap - * @param {string | null} content content within the tag - * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add - * - * @returns {string} content wrapped in HTML element - */ - wrap(tag, content, attrs = {}) { - const htmlAttrs = Object.entries(attrs) - .map(([key, value]) => ` ${key}="${value}"`) - .join(''); - if (!content) { - return `<${tag}${htmlAttrs}>`; + function createNode(value, tagName, ctx) { + if (identity.isDocument(value)) + value = value.contents; + if (identity.isNode(value)) + return value; + if (identity.isPair(value)) { + const map = ctx.schema[identity.MAP].createNode?.(ctx.schema, null, ctx); + map.items.push(value); + return map; + } + if (value instanceof String || value instanceof Number || value instanceof Boolean || typeof BigInt !== "undefined" && value instanceof BigInt) { + value = value.valueOf(); + } + const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx; + let ref = void 0; + if (aliasDuplicateObjects && value && typeof value === "object") { + ref = sourceObjects.get(value); + if (ref) { + ref.anchor ?? (ref.anchor = onAnchor(value)); + return new Alias.Alias(ref.anchor); + } else { + ref = { anchor: null, node: null }; + sourceObjects.set(value, ref); } - return `<${tag}${htmlAttrs}>${content}`; + } + if (tagName?.startsWith("!!")) + tagName = defaultTagPrefix + tagName.slice(2); + let tagObj = findTagObject(value, tagName, schema.tags); + if (!tagObj) { + if (value && typeof value.toJSON === "function") { + value = value.toJSON(); + } + if (!value || typeof value !== "object") { + const node2 = new Scalar.Scalar(value); + if (ref) + ref.node = node2; + return node2; + } + tagObj = value instanceof Map ? schema[identity.MAP] : Symbol.iterator in Object(value) ? schema[identity.SEQ] : schema[identity.MAP]; + } + if (onTagObj) { + onTagObj(tagObj); + delete ctx.onTagObj; + } + const node = tagObj?.createNode ? tagObj.createNode(ctx.schema, value, ctx) : typeof tagObj?.nodeClass?.from === "function" ? tagObj.nodeClass.from(ctx.schema, value, ctx) : new Scalar.Scalar(value); + if (tagName) + node.tag = tagName; + else if (!tagObj.default) + node.tag = tagObj.tag; + if (ref) + ref.node = node; + return node; } - /** - * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. - * - * @param {SummaryWriteOptions} [options] (optional) options for write operation - * - * @returns {Promise} summary instance - */ - write(options) { - return __awaiter(this, void 0, void 0, function* () { - const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); - const filePath = yield this.filePath(); - const writeFunc = overwrite ? writeFile : appendFile; - yield writeFunc(filePath, this._buffer, { encoding: 'utf8' }); - return this.emptyBuffer(); - }); + exports2.createNode = createNode; + } +}); + +// node_modules/yaml/dist/nodes/Collection.js +var require_Collection = __commonJS({ + "node_modules/yaml/dist/nodes/Collection.js"(exports2) { + "use strict"; + var createNode = require_createNode(); + var identity = require_identity(); + var Node = require_Node(); + function collectionFromPath(schema, path2, value) { + let v = value; + for (let i = path2.length - 1; i >= 0; --i) { + const k = path2[i]; + if (typeof k === "number" && Number.isInteger(k) && k >= 0) { + const a = []; + a[k] = v; + v = a; + } else { + v = /* @__PURE__ */ new Map([[k, v]]); + } + } + return createNode.createNode(v, void 0, { + aliasDuplicateObjects: false, + keepUndefined: false, + onAnchor: () => { + throw new Error("This should not happen, please report a bug."); + }, + schema, + sourceObjects: /* @__PURE__ */ new Map() + }); } - /** - * Clears the summary buffer and wipes the summary file - * - * @returns {Summary} summary instance - */ - clear() { - return __awaiter(this, void 0, void 0, function* () { - return this.emptyBuffer().write({ overwrite: true }); + var isEmptyPath = (path2) => path2 == null || typeof path2 === "object" && !!path2[Symbol.iterator]().next().done; + var Collection = class extends Node.NodeBase { + constructor(type, schema) { + super(type); + Object.defineProperty(this, "schema", { + value: schema, + configurable: true, + enumerable: false, + writable: true }); + } + /** + * Create a copy of this collection. + * + * @param schema - If defined, overwrites the original's schema + */ + clone(schema) { + const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this)); + if (schema) + copy.schema = schema; + copy.items = copy.items.map((it) => identity.isNode(it) || identity.isPair(it) ? it.clone(schema) : it); + if (this.range) + copy.range = this.range.slice(); + return copy; + } + /** + * Adds a value to the collection. For `!!map` and `!!omap` the value must + * be a Pair instance or a `{ key, value }` object, which may not have a key + * that already exists in the map. + */ + addIn(path2, value) { + if (isEmptyPath(path2)) + this.add(value); + else { + const [key, ...rest] = path2; + const node = this.get(key, true); + if (identity.isCollection(node)) + node.addIn(rest, value); + else if (node === void 0 && this.schema) + this.set(key, collectionFromPath(this.schema, rest, value)); + else + throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + } + /** + * Removes a value from the collection. + * @returns `true` if the item was found and removed. + */ + deleteIn(path2) { + const [key, ...rest] = path2; + if (rest.length === 0) + return this.delete(key); + const node = this.get(key, true); + if (identity.isCollection(node)) + return node.deleteIn(rest); + else + throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + /** + * Returns item at `key`, or `undefined` if not found. By default unwraps + * scalar values from their surrounding node; to disable set `keepScalar` to + * `true` (collections are always returned intact). + */ + getIn(path2, keepScalar) { + const [key, ...rest] = path2; + const node = this.get(key, true); + if (rest.length === 0) + return !keepScalar && identity.isScalar(node) ? node.value : node; + else + return identity.isCollection(node) ? node.getIn(rest, keepScalar) : void 0; + } + hasAllNullValues(allowScalar) { + return this.items.every((node) => { + if (!identity.isPair(node)) + return false; + const n = node.value; + return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag; + }); + } + /** + * Checks if the collection includes a value with the key `key`. + */ + hasIn(path2) { + const [key, ...rest] = path2; + if (rest.length === 0) + return this.has(key); + const node = this.get(key, true); + return identity.isCollection(node) ? node.hasIn(rest) : false; + } + /** + * Sets a value in this collection. For `!!set`, `value` needs to be a + * boolean to add/remove the item from the set. + */ + setIn(path2, value) { + const [key, ...rest] = path2; + if (rest.length === 0) { + this.set(key, value); + } else { + const node = this.get(key, true); + if (identity.isCollection(node)) + node.setIn(rest, value); + else if (node === void 0 && this.schema) + this.set(key, collectionFromPath(this.schema, rest, value)); + else + throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + } + } + }; + exports2.Collection = Collection; + exports2.collectionFromPath = collectionFromPath; + exports2.isEmptyPath = isEmptyPath; + } +}); + +// node_modules/yaml/dist/stringify/stringifyComment.js +var require_stringifyComment = __commonJS({ + "node_modules/yaml/dist/stringify/stringifyComment.js"(exports2) { + "use strict"; + var stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, "#"); + function indentComment(comment, indent) { + if (/^\n+$/.test(comment)) + return comment.substring(1); + return indent ? comment.replace(/^(?! *$)/gm, indent) : comment; } - /** - * Returns the current summary buffer as a string - * - * @returns {string} string of summary buffer - */ - stringify() { - return this._buffer; - } - /** - * If the summary buffer is empty - * - * @returns {boolen} true if the buffer is empty - */ - isEmptyBuffer() { - return this._buffer.length === 0; - } - /** - * Resets the summary buffer without writing to summary file - * - * @returns {Summary} summary instance - */ - emptyBuffer() { - this._buffer = ''; - return this; - } - /** - * Adds raw text to the summary buffer - * - * @param {string} text content to add - * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) - * - * @returns {Summary} summary instance - */ - addRaw(text, addEOL = false) { - this._buffer += text; - return addEOL ? this.addEOL() : this; - } - /** - * Adds the operating system-specific end-of-line marker to the buffer - * - * @returns {Summary} summary instance - */ - addEOL() { - return this.addRaw(os_1.EOL); - } - /** - * Adds an HTML codeblock to the summary buffer - * - * @param {string} code content to render within fenced code block - * @param {string} lang (optional) language to syntax highlight code - * - * @returns {Summary} summary instance - */ - addCodeBlock(code, lang) { - const attrs = Object.assign({}, (lang && { lang })); - const element = this.wrap('pre', this.wrap('code', code), attrs); - return this.addRaw(element).addEOL(); - } - /** - * Adds an HTML list to the summary buffer - * - * @param {string[]} items list of items to render - * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) - * - * @returns {Summary} summary instance - */ - addList(items, ordered = false) { - const tag = ordered ? 'ol' : 'ul'; - const listItems = items.map(item => this.wrap('li', item)).join(''); - const element = this.wrap(tag, listItems); - return this.addRaw(element).addEOL(); + var lineComment = (str, indent, comment) => str.endsWith("\n") ? indentComment(comment, indent) : comment.includes("\n") ? "\n" + indentComment(comment, indent) : (str.endsWith(" ") ? "" : " ") + comment; + exports2.indentComment = indentComment; + exports2.lineComment = lineComment; + exports2.stringifyComment = stringifyComment; + } +}); + +// node_modules/yaml/dist/stringify/foldFlowLines.js +var require_foldFlowLines = __commonJS({ + "node_modules/yaml/dist/stringify/foldFlowLines.js"(exports2) { + "use strict"; + var FOLD_FLOW = "flow"; + var FOLD_BLOCK = "block"; + var FOLD_QUOTED = "quoted"; + function foldFlowLines(text, indent, mode = "flow", { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) { + if (!lineWidth || lineWidth < 0) + return text; + if (lineWidth < minContentWidth) + minContentWidth = 0; + const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length); + if (text.length <= endStep) + return text; + const folds = []; + const escapedFolds = {}; + let end = lineWidth - indent.length; + if (typeof indentAtStart === "number") { + if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) + folds.push(0); + else + end = lineWidth - indentAtStart; + } + let split = void 0; + let prev = void 0; + let overflow = false; + let i = -1; + let escStart = -1; + let escEnd = -1; + if (mode === FOLD_BLOCK) { + i = consumeMoreIndentedLines(text, i, indent.length); + if (i !== -1) + end = i + endStep; + } + for (let ch; ch = text[i += 1]; ) { + if (mode === FOLD_QUOTED && ch === "\\") { + escStart = i; + switch (text[i + 1]) { + case "x": + i += 3; + break; + case "u": + i += 5; + break; + case "U": + i += 9; + break; + default: + i += 1; + } + escEnd = i; + } + if (ch === "\n") { + if (mode === FOLD_BLOCK) + i = consumeMoreIndentedLines(text, i, indent.length); + end = i + indent.length + endStep; + split = void 0; + } else { + if (ch === " " && prev && prev !== " " && prev !== "\n" && prev !== " ") { + const next = text[i + 1]; + if (next && next !== " " && next !== "\n" && next !== " ") + split = i; + } + if (i >= end) { + if (split) { + folds.push(split); + end = split + endStep; + split = void 0; + } else if (mode === FOLD_QUOTED) { + while (prev === " " || prev === " ") { + prev = ch; + ch = text[i += 1]; + overflow = true; + } + const j = i > escEnd + 1 ? i - 2 : escStart - 1; + if (escapedFolds[j]) + return text; + folds.push(j); + escapedFolds[j] = true; + end = j + endStep; + split = void 0; + } else { + overflow = true; + } + } + } + prev = ch; + } + if (overflow && onOverflow) + onOverflow(); + if (folds.length === 0) + return text; + if (onFold) + onFold(); + let res = text.slice(0, folds[0]); + for (let i2 = 0; i2 < folds.length; ++i2) { + const fold = folds[i2]; + const end2 = folds[i2 + 1] || text.length; + if (fold === 0) + res = ` +${indent}${text.slice(0, end2)}`; + else { + if (mode === FOLD_QUOTED && escapedFolds[fold]) + res += `${text[fold]}\\`; + res += ` +${indent}${text.slice(fold + 1, end2)}`; + } + } + return res; } - /** - * Adds an HTML table to the summary buffer - * - * @param {SummaryTableCell[]} rows table rows - * - * @returns {Summary} summary instance - */ - addTable(rows) { - const tableBody = rows - .map(row => { - const cells = row - .map(cell => { - if (typeof cell === 'string') { - return this.wrap('td', cell); - } - const { header, data, colspan, rowspan } = cell; - const tag = header ? 'th' : 'td'; - const attrs = Object.assign(Object.assign({}, (colspan && { colspan })), (rowspan && { rowspan })); - return this.wrap(tag, data, attrs); - }) - .join(''); - return this.wrap('tr', cells); - }) - .join(''); - const element = this.wrap('table', tableBody); - return this.addRaw(element).addEOL(); + function consumeMoreIndentedLines(text, i, indent) { + let end = i; + let start = i + 1; + let ch = text[start]; + while (ch === " " || ch === " ") { + if (i < start + indent) { + ch = text[++i]; + } else { + do { + ch = text[++i]; + } while (ch && ch !== "\n"); + end = i; + start = i + 1; + ch = text[start]; + } + } + return end; } - /** - * Adds a collapsable HTML details element to the summary buffer - * - * @param {string} label text for the closed state - * @param {string} content collapsable content - * - * @returns {Summary} summary instance - */ - addDetails(label, content) { - const element = this.wrap('details', this.wrap('summary', label) + content); - return this.addRaw(element).addEOL(); + exports2.FOLD_BLOCK = FOLD_BLOCK; + exports2.FOLD_FLOW = FOLD_FLOW; + exports2.FOLD_QUOTED = FOLD_QUOTED; + exports2.foldFlowLines = foldFlowLines; + } +}); + +// node_modules/yaml/dist/stringify/stringifyString.js +var require_stringifyString = __commonJS({ + "node_modules/yaml/dist/stringify/stringifyString.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + var foldFlowLines = require_foldFlowLines(); + var getFoldOptions = (ctx, isBlock) => ({ + indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart, + lineWidth: ctx.options.lineWidth, + minContentWidth: ctx.options.minContentWidth + }); + var containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str); + function lineLengthOverLimit(str, lineWidth, indentLength) { + if (!lineWidth || lineWidth < 0) + return false; + const limit2 = lineWidth - indentLength; + const strLen = str.length; + if (strLen <= limit2) + return false; + for (let i = 0, start = 0; i < strLen; ++i) { + if (str[i] === "\n") { + if (i - start > limit2) + return true; + start = i + 1; + if (strLen - start <= limit2) + return false; + } + } + return true; } - /** - * Adds an HTML image tag to the summary buffer - * - * @param {string} src path to the image you to embed - * @param {string} alt text description of the image - * @param {SummaryImageOptions} options (optional) addition image attributes - * - * @returns {Summary} summary instance - */ - addImage(src, alt, options) { - const { width, height } = options || {}; - const attrs = Object.assign(Object.assign({}, (width && { width })), (height && { height })); - const element = this.wrap('img', null, Object.assign({ src, alt }, attrs)); - return this.addRaw(element).addEOL(); + function doubleQuotedString(value, ctx) { + const json = JSON.stringify(value); + if (ctx.options.doubleQuotedAsJSON) + return json; + const { implicitKey } = ctx; + const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength; + const indent = ctx.indent || (containsDocumentMarker(value) ? " " : ""); + let str = ""; + let start = 0; + for (let i = 0, ch = json[i]; ch; ch = json[++i]) { + if (ch === " " && json[i + 1] === "\\" && json[i + 2] === "n") { + str += json.slice(start, i) + "\\ "; + i += 1; + start = i; + ch = "\\"; + } + if (ch === "\\") + switch (json[i + 1]) { + case "u": + { + str += json.slice(start, i); + const code = json.substr(i + 2, 4); + switch (code) { + case "0000": + str += "\\0"; + break; + case "0007": + str += "\\a"; + break; + case "000b": + str += "\\v"; + break; + case "001b": + str += "\\e"; + break; + case "0085": + str += "\\N"; + break; + case "00a0": + str += "\\_"; + break; + case "2028": + str += "\\L"; + break; + case "2029": + str += "\\P"; + break; + default: + if (code.substr(0, 2) === "00") + str += "\\x" + code.substr(2); + else + str += json.substr(i, 6); + } + i += 5; + start = i + 1; + } + break; + case "n": + if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) { + i += 1; + } else { + str += json.slice(start, i) + "\n\n"; + while (json[i + 2] === "\\" && json[i + 3] === "n" && json[i + 4] !== '"') { + str += "\n"; + i += 2; + } + str += indent; + if (json[i + 2] === " ") + str += "\\"; + i += 1; + start = i + 1; + } + break; + default: + i += 1; + } + } + str = start ? str + json.slice(start) : json; + return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false)); } - /** - * Adds an HTML section heading element - * - * @param {string} text heading text - * @param {number | string} [level=1] (optional) the heading level, default: 1 - * - * @returns {Summary} summary instance - */ - addHeading(text, level) { - const tag = `h${level}`; - const allowedTag = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag) - ? tag - : 'h1'; - const element = this.wrap(allowedTag, text); - return this.addRaw(element).addEOL(); + function singleQuotedString(value, ctx) { + if (ctx.options.singleQuote === false || ctx.implicitKey && value.includes("\n") || /[ \t]\n|\n[ \t]/.test(value)) + return doubleQuotedString(value, ctx); + const indent = ctx.indent || (containsDocumentMarker(value) ? " " : ""); + const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$& +${indent}`) + "'"; + return ctx.implicitKey ? res : foldFlowLines.foldFlowLines(res, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false)); + } + function quotedString(value, ctx) { + const { singleQuote } = ctx.options; + let qs; + if (singleQuote === false) + qs = doubleQuotedString; + else { + const hasDouble = value.includes('"'); + const hasSingle = value.includes("'"); + if (hasDouble && !hasSingle) + qs = singleQuotedString; + else if (hasSingle && !hasDouble) + qs = doubleQuotedString; + else + qs = singleQuote ? singleQuotedString : doubleQuotedString; + } + return qs(value, ctx); } - /** - * Adds an HTML thematic break (
) to the summary buffer - * - * @returns {Summary} summary instance - */ - addSeparator() { - const element = this.wrap('hr', null); - return this.addRaw(element).addEOL(); + var blockEndNewlines; + try { + blockEndNewlines = new RegExp("(^|(?) to the summary buffer - * - * @returns {Summary} summary instance - */ - addBreak() { - const element = this.wrap('br', null); - return this.addRaw(element).addEOL(); + function blockString({ comment, type, value }, ctx, onComment, onChompKeep) { + const { blockQuote, commentString, lineWidth } = ctx.options; + if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) { + return quotedString(value, ctx); + } + const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? " " : ""); + const literal = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.Scalar.BLOCK_FOLDED ? false : type === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length); + if (!value) + return literal ? "|\n" : ">\n"; + let chomp; + let endStart; + for (endStart = value.length; endStart > 0; --endStart) { + const ch = value[endStart - 1]; + if (ch !== "\n" && ch !== " " && ch !== " ") + break; + } + let end = value.substring(endStart); + const endNlPos = end.indexOf("\n"); + if (endNlPos === -1) { + chomp = "-"; + } else if (value === end || endNlPos !== end.length - 1) { + chomp = "+"; + if (onChompKeep) + onChompKeep(); + } else { + chomp = ""; + } + if (end) { + value = value.slice(0, -end.length); + if (end[end.length - 1] === "\n") + end = end.slice(0, -1); + end = end.replace(blockEndNewlines, `$&${indent}`); + } + let startWithSpace = false; + let startEnd; + let startNlPos = -1; + for (startEnd = 0; startEnd < value.length; ++startEnd) { + const ch = value[startEnd]; + if (ch === " ") + startWithSpace = true; + else if (ch === "\n") + startNlPos = startEnd; + else + break; + } + let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd); + if (start) { + value = value.substring(start.length); + start = start.replace(/\n+/g, `$&${indent}`); + } + const indentSize = indent ? "2" : "1"; + let header = (startWithSpace ? indentSize : "") + chomp; + if (comment) { + header += " " + commentString(comment.replace(/ ?[\r\n]+/g, " ")); + if (onComment) + onComment(); + } + if (!literal) { + const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`); + let literalFallback = false; + const foldOptions = getFoldOptions(ctx, true); + if (blockQuote !== "folded" && type !== Scalar.Scalar.BLOCK_FOLDED) { + foldOptions.onOverflow = () => { + literalFallback = true; + }; + } + const body = foldFlowLines.foldFlowLines(`${start}${foldedValue}${end}`, indent, foldFlowLines.FOLD_BLOCK, foldOptions); + if (!literalFallback) + return `>${header} +${indent}${body}`; + } + value = value.replace(/\n+/g, `$&${indent}`); + return `|${header} +${indent}${start}${value}${end}`; } - /** - * Adds an HTML blockquote to the summary buffer - * - * @param {string} text quote text - * @param {string} cite (optional) citation url - * - * @returns {Summary} summary instance - */ - addQuote(text, cite) { - const attrs = Object.assign({}, (cite && { cite })); - const element = this.wrap('blockquote', text, attrs); - return this.addRaw(element).addEOL(); + function plainString(item, ctx, onComment, onChompKeep) { + const { type, value } = item; + const { actualString, implicitKey, indent, indentStep, inFlow } = ctx; + if (implicitKey && value.includes("\n") || inFlow && /[[\]{},]/.test(value)) { + return quotedString(value, ctx); + } + if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) { + return implicitKey || inFlow || !value.includes("\n") ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep); + } + if (!implicitKey && !inFlow && type !== Scalar.Scalar.PLAIN && value.includes("\n")) { + return blockString(item, ctx, onComment, onChompKeep); + } + if (containsDocumentMarker(value)) { + if (indent === "") { + ctx.forceBlockIndent = true; + return blockString(item, ctx, onComment, onChompKeep); + } else if (implicitKey && indent === indentStep) { + return quotedString(value, ctx); + } + } + const str = value.replace(/\n+/g, `$& +${indent}`); + if (actualString) { + const test = (tag) => tag.default && tag.tag !== "tag:yaml.org,2002:str" && tag.test?.test(str); + const { compat, tags } = ctx.doc.schema; + if (tags.some(test) || compat?.some(test)) + return quotedString(value, ctx); + } + return implicitKey ? str : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false)); } - /** - * Adds an HTML anchor tag to the summary buffer - * - * @param {string} text link text/content - * @param {string} href hyperlink - * - * @returns {Summary} summary instance - */ - addLink(text, href) { - const element = this.wrap('a', text, { href }); - return this.addRaw(element).addEOL(); + function stringifyString(item, ctx, onComment, onChompKeep) { + const { implicitKey, inFlow } = ctx; + const ss = typeof item.value === "string" ? item : Object.assign({}, item, { value: String(item.value) }); + let { type } = item; + if (type !== Scalar.Scalar.QUOTE_DOUBLE) { + if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) + type = Scalar.Scalar.QUOTE_DOUBLE; + } + const _stringify = (_type) => { + switch (_type) { + case Scalar.Scalar.BLOCK_FOLDED: + case Scalar.Scalar.BLOCK_LITERAL: + return implicitKey || inFlow ? quotedString(ss.value, ctx) : blockString(ss, ctx, onComment, onChompKeep); + case Scalar.Scalar.QUOTE_DOUBLE: + return doubleQuotedString(ss.value, ctx); + case Scalar.Scalar.QUOTE_SINGLE: + return singleQuotedString(ss.value, ctx); + case Scalar.Scalar.PLAIN: + return plainString(ss, ctx, onComment, onChompKeep); + default: + return null; + } + }; + let res = _stringify(type); + if (res === null) { + const { defaultKeyType, defaultStringType } = ctx.options; + const t = implicitKey && defaultKeyType || defaultStringType; + res = _stringify(t); + if (res === null) + throw new Error(`Unsupported default string type ${t}`); + } + return res; } -} -const _summary = new Summary(); -/** - * @deprecated use `core.summary` - */ -exports.markdownSummary = _summary; -exports.summary = _summary; -//# sourceMappingURL=summary.js.map - -/***/ }), - -/***/ 302: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; + exports2.stringifyString = stringifyString; + } +}); -// We use any as a valid input type -/* eslint-disable @typescript-eslint/no-explicit-any */ -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.toCommandProperties = exports.toCommandValue = void 0; -/** - * Sanitizes an input into a string so it can be passed into issueCommand safely - * @param input input to sanitize into a string - */ -function toCommandValue(input) { - if (input === null || input === undefined) { - return ''; - } - else if (typeof input === 'string' || input instanceof String) { - return input; +// node_modules/yaml/dist/stringify/stringify.js +var require_stringify = __commonJS({ + "node_modules/yaml/dist/stringify/stringify.js"(exports2) { + "use strict"; + var anchors = require_anchors(); + var identity = require_identity(); + var stringifyComment = require_stringifyComment(); + var stringifyString = require_stringifyString(); + function createStringifyContext(doc, options) { + const opt = Object.assign({ + blockQuote: true, + commentString: stringifyComment.stringifyComment, + defaultKeyType: null, + defaultStringType: "PLAIN", + directives: null, + doubleQuotedAsJSON: false, + doubleQuotedMinMultiLineLength: 40, + falseStr: "false", + flowCollectionPadding: true, + indentSeq: true, + lineWidth: 80, + minContentWidth: 20, + nullStr: "null", + simpleKeys: false, + singleQuote: null, + trueStr: "true", + verifyAliasOrder: true + }, doc.schema.toStringOptions, options); + let inFlow; + switch (opt.collectionStyle) { + case "block": + inFlow = false; + break; + case "flow": + inFlow = true; + break; + default: + inFlow = null; + } + return { + anchors: /* @__PURE__ */ new Set(), + doc, + flowCollectionPadding: opt.flowCollectionPadding ? " " : "", + indent: "", + indentStep: typeof opt.indent === "number" ? " ".repeat(opt.indent) : " ", + inFlow, + options: opt + }; } - return JSON.stringify(input); -} -exports.toCommandValue = toCommandValue; -/** - * - * @param annotationProperties - * @returns The command properties to send with the actual annotation command - * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646 - */ -function toCommandProperties(annotationProperties) { - if (!Object.keys(annotationProperties).length) { - return {}; + function getTagObject(tags, item) { + if (item.tag) { + const match = tags.filter((t) => t.tag === item.tag); + if (match.length > 0) + return match.find((t) => t.format === item.format) ?? match[0]; + } + let tagObj = void 0; + let obj; + if (identity.isScalar(item)) { + obj = item.value; + let match = tags.filter((t) => t.identify?.(obj)); + if (match.length > 1) { + const testMatch = match.filter((t) => t.test); + if (testMatch.length > 0) + match = testMatch; + } + tagObj = match.find((t) => t.format === item.format) ?? match.find((t) => !t.format); + } else { + obj = item; + tagObj = tags.find((t) => t.nodeClass && obj instanceof t.nodeClass); + } + if (!tagObj) { + const name = obj?.constructor?.name ?? (obj === null ? "null" : typeof obj); + throw new Error(`Tag not resolved for ${name} value`); + } + return tagObj; } - return { - title: annotationProperties.title, - file: annotationProperties.file, - line: annotationProperties.startLine, - endLine: annotationProperties.endLine, - col: annotationProperties.startColumn, - endColumn: annotationProperties.endColumn - }; -} -exports.toCommandProperties = toCommandProperties; -//# sourceMappingURL=utils.js.map - -/***/ }), - -/***/ 5236: -/***/ (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; + function stringifyProps(node, tagObj, { anchors: anchors$1, doc }) { + if (!doc.directives) + return ""; + const props = []; + const anchor = (identity.isScalar(node) || identity.isCollection(node)) && node.anchor; + if (anchor && anchors.anchorIsValid(anchor)) { + anchors$1.add(anchor); + props.push(`&${anchor}`); + } + const tag = node.tag ?? (tagObj.default ? null : tagObj.tag); + if (tag) + props.push(doc.directives.tagString(tag)); + return props.join(" "); + } + function stringify2(item, ctx, onComment, onChompKeep) { + if (identity.isPair(item)) + return item.toString(ctx, onComment, onChompKeep); + if (identity.isAlias(item)) { + if (ctx.doc.directives) + return item.toString(ctx); + if (ctx.resolvedAliases?.has(item)) { + throw new TypeError(`Cannot stringify circular structure without alias nodes`); + } else { + if (ctx.resolvedAliases) + ctx.resolvedAliases.add(item); + else + ctx.resolvedAliases = /* @__PURE__ */ new Set([item]); + item = item.resolve(ctx.doc); + } + } + let tagObj = void 0; + const node = identity.isNode(item) ? item : ctx.doc.createNode(item, { onTagObj: (o) => tagObj = o }); + tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node)); + const props = stringifyProps(node, tagObj, ctx); + if (props.length > 0) + ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1; + const str = typeof tagObj.stringify === "function" ? tagObj.stringify(node, ctx, onComment, onChompKeep) : identity.isScalar(node) ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) : node.toString(ctx, onComment, onChompKeep); + if (!props) + return str; + return identity.isScalar(node) || str[0] === "{" || str[0] === "[" ? `${props} ${str}` : `${props} +${ctx.indent}${str}`; + } + exports2.createStringifyContext = createStringifyContext; + exports2.stringify = stringify2; + } }); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getExecOutput = exports.exec = void 0; -const string_decoder_1 = __nccwpck_require__(3193); -const tr = __importStar(__nccwpck_require__(6665)); -/** - * Exec a command. - * Output will be streamed to the live console. - * Returns promise with return code - * - * @param commandLine command to execute (can include additional args). Must be correctly escaped. - * @param args optional arguments for tool. Escaping is handled by the lib. - * @param options optional exec options. See ExecOptions - * @returns Promise exit code - */ -function exec(commandLine, args, options) { - return __awaiter(this, void 0, void 0, function* () { - const commandArgs = tr.argStringToArray(commandLine); - if (commandArgs.length === 0) { - throw new Error(`Parameter 'commandLine' cannot be null or empty.`); - } - // Path to tool to execute should be first arg - const toolPath = commandArgs[0]; - args = commandArgs.slice(1).concat(args || []); - const runner = new tr.ToolRunner(toolPath, args, options); - return runner.exec(); - }); -} -exports.exec = exec; -/** - * Exec a command and get the output. - * Output will be streamed to the live console. - * Returns promise with the exit code and collected stdout and stderr - * - * @param commandLine command to execute (can include additional args). Must be correctly escaped. - * @param args optional arguments for tool. Escaping is handled by the lib. - * @param options optional exec options. See ExecOptions - * @returns Promise exit code, stdout, and stderr - */ -function getExecOutput(commandLine, args, options) { - var _a, _b; - return __awaiter(this, void 0, void 0, function* () { - let stdout = ''; - let stderr = ''; - //Using string decoder covers the case where a mult-byte character is split - const stdoutDecoder = new string_decoder_1.StringDecoder('utf8'); - const stderrDecoder = new string_decoder_1.StringDecoder('utf8'); - const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout; - const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr; - const stdErrListener = (data) => { - stderr += stderrDecoder.write(data); - if (originalStdErrListener) { - originalStdErrListener(data); - } - }; - const stdOutListener = (data) => { - stdout += stdoutDecoder.write(data); - if (originalStdoutListener) { - originalStdoutListener(data); - } - }; - const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener }); - const exitCode = yield exec(commandLine, args, Object.assign(Object.assign({}, options), { listeners })); - //flush any remaining characters - stdout += stdoutDecoder.end(); - stderr += stderrDecoder.end(); - return { - exitCode, - stdout, - stderr - }; - }); -} -exports.getExecOutput = getExecOutput; -//# sourceMappingURL=exec.js.map - -/***/ }), -/***/ 6665: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.argStringToArray = exports.ToolRunner = void 0; -const os = __importStar(__nccwpck_require__(857)); -const events = __importStar(__nccwpck_require__(4434)); -const child = __importStar(__nccwpck_require__(5317)); -const path = __importStar(__nccwpck_require__(6928)); -const io = __importStar(__nccwpck_require__(4994)); -const ioUtil = __importStar(__nccwpck_require__(5207)); -const timers_1 = __nccwpck_require__(3557); -/* eslint-disable @typescript-eslint/unbound-method */ -const IS_WINDOWS = process.platform === 'win32'; -/* - * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way. - */ -class ToolRunner extends events.EventEmitter { - constructor(toolPath, args, options) { - super(); - if (!toolPath) { - throw new Error("Parameter 'toolPath' cannot be null or empty."); - } - this.toolPath = toolPath; - this.args = args || []; - this.options = options || {}; - } - _debug(message) { - if (this.options.listeners && this.options.listeners.debug) { - this.options.listeners.debug(message); +// node_modules/yaml/dist/stringify/stringifyPair.js +var require_stringifyPair = __commonJS({ + "node_modules/yaml/dist/stringify/stringifyPair.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Scalar = require_Scalar(); + var stringify2 = require_stringify(); + var stringifyComment = require_stringifyComment(); + function stringifyPair({ key, value }, ctx, onComment, onChompKeep) { + const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx; + let keyComment = identity.isNode(key) && key.comment || null; + if (simpleKeys) { + if (keyComment) { + throw new Error("With simple keys, key nodes cannot have comments"); } - } - _getCommandString(options, noPrefix) { - const toolPath = this._getSpawnFileName(); - const args = this._getSpawnArgs(options); - let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool - if (IS_WINDOWS) { - // Windows + cmd file - if (this._isCmdFile()) { - cmd += toolPath; - for (const a of args) { - cmd += ` ${a}`; - } - } - // Windows + verbatim - else if (options.windowsVerbatimArguments) { - cmd += `"${toolPath}"`; - for (const a of args) { - cmd += ` ${a}`; - } - } - // Windows (regular) - else { - cmd += this._windowsQuoteCmdArg(toolPath); - for (const a of args) { - cmd += ` ${this._windowsQuoteCmdArg(a)}`; - } - } + if (identity.isCollection(key) || !identity.isNode(key) && typeof key === "object") { + const msg = "With simple keys, collection cannot be used as a key value"; + throw new Error(msg); } - else { - // OSX/Linux - this can likely be improved with some form of quoting. - // creating processes on Unix is fundamentally different than Windows. - // on Unix, execvp() takes an arg array. - cmd += toolPath; - for (const a of args) { - cmd += ` ${a}`; - } + } + let explicitKey = !simpleKeys && (!key || keyComment && value == null && !ctx.inFlow || identity.isCollection(key) || (identity.isScalar(key) ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL : typeof key === "object")); + ctx = Object.assign({}, ctx, { + allNullValues: false, + implicitKey: !explicitKey && (simpleKeys || !allNullValues), + indent: indent + indentStep + }); + let keyCommentDone = false; + let chompKeep = false; + let str = stringify2.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true); + if (!explicitKey && !ctx.inFlow && str.length > 1024) { + if (simpleKeys) + throw new Error("With simple keys, single line scalar must not span more than 1024 characters"); + explicitKey = true; + } + if (ctx.inFlow) { + if (allNullValues || value == null) { + if (keyCommentDone && onComment) + onComment(); + return str === "" ? "?" : explicitKey ? `? ${str}` : str; } - return cmd; - } - _processLineBuffer(data, strBuffer, onLine) { - try { - let s = strBuffer + data.toString(); - let n = s.indexOf(os.EOL); - while (n > -1) { - const line = s.substring(0, n); - onLine(line); - // the rest of the string ... - s = s.substring(n + os.EOL.length); - n = s.indexOf(os.EOL); - } - return s; + } else if (allNullValues && !simpleKeys || value == null && explicitKey) { + str = `? ${str}`; + if (keyComment && !keyCommentDone) { + str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment)); + } else if (chompKeep && onChompKeep) + onChompKeep(); + return str; + } + if (keyCommentDone) + keyComment = null; + if (explicitKey) { + if (keyComment) + str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment)); + str = `? ${str} +${indent}:`; + } else { + str = `${str}:`; + if (keyComment) + str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment)); + } + let vsb, vcb, valueComment; + if (identity.isNode(value)) { + vsb = !!value.spaceBefore; + vcb = value.commentBefore; + valueComment = value.comment; + } else { + vsb = false; + vcb = null; + valueComment = null; + if (value && typeof value === "object") + value = doc.createNode(value); + } + ctx.implicitKey = false; + if (!explicitKey && !keyComment && identity.isScalar(value)) + ctx.indentAtStart = str.length + 1; + chompKeep = false; + if (!indentSeq && indentStep.length >= 2 && !ctx.inFlow && !explicitKey && identity.isSeq(value) && !value.flow && !value.tag && !value.anchor) { + ctx.indent = ctx.indent.substring(2); + } + let valueCommentDone = false; + const valueStr = stringify2.stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true); + let ws = " "; + if (keyComment || vsb || vcb) { + ws = vsb ? "\n" : ""; + if (vcb) { + const cs = commentString(vcb); + ws += ` +${stringifyComment.indentComment(cs, ctx.indent)}`; } - catch (err) { - // streaming lines to console is best effort. Don't fail a build. - this._debug(`error processing line. Failed with error ${err}`); - return ''; + if (valueStr === "" && !ctx.inFlow) { + if (ws === "\n") + ws = "\n\n"; + } else { + ws += ` +${ctx.indent}`; } - } - _getSpawnFileName() { - if (IS_WINDOWS) { - if (this._isCmdFile()) { - return process.env['COMSPEC'] || 'cmd.exe'; + } else if (!explicitKey && identity.isCollection(value)) { + const vs0 = valueStr[0]; + const nl0 = valueStr.indexOf("\n"); + const hasNewline = nl0 !== -1; + const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0; + if (hasNewline || !flow) { + let hasPropsLine = false; + if (hasNewline && (vs0 === "&" || vs0 === "!")) { + let sp0 = valueStr.indexOf(" "); + if (vs0 === "&" && sp0 !== -1 && sp0 < nl0 && valueStr[sp0 + 1] === "!") { + sp0 = valueStr.indexOf(" ", sp0 + 1); } + if (sp0 === -1 || nl0 < sp0) + hasPropsLine = true; + } + if (!hasPropsLine) + ws = ` +${ctx.indent}`; } - return this.toolPath; + } else if (valueStr === "" || valueStr[0] === "\n") { + ws = ""; + } + str += ws + valueStr; + if (ctx.inFlow) { + if (valueCommentDone && onComment) + onComment(); + } else if (valueComment && !valueCommentDone) { + str += stringifyComment.lineComment(str, ctx.indent, commentString(valueComment)); + } else if (chompKeep && onChompKeep) { + onChompKeep(); + } + return str; } - _getSpawnArgs(options) { - if (IS_WINDOWS) { - if (this._isCmdFile()) { - let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; - for (const a of this.args) { - argline += ' '; - argline += options.windowsVerbatimArguments - ? a - : this._windowsQuoteCmdArg(a); - } - argline += '"'; - return [argline]; - } - } - return this.args; - } - _endsWith(str, end) { - return str.endsWith(end); - } - _isCmdFile() { - const upperToolPath = this.toolPath.toUpperCase(); - return (this._endsWith(upperToolPath, '.CMD') || - this._endsWith(upperToolPath, '.BAT')); + exports2.stringifyPair = stringifyPair; + } +}); + +// node_modules/yaml/dist/log.js +var require_log = __commonJS({ + "node_modules/yaml/dist/log.js"(exports2) { + "use strict"; + var node_process = require("process"); + function debug(logLevel, ...messages) { + if (logLevel === "debug") + console.log(...messages); } - _windowsQuoteCmdArg(arg) { - // for .exe, apply the normal quoting rules that libuv applies - if (!this._isCmdFile()) { - return this._uvQuoteCmdArg(arg); - } - // otherwise apply quoting rules specific to the cmd.exe command line parser. - // the libuv rules are generic and are not designed specifically for cmd.exe - // command line parser. - // - // for a detailed description of the cmd.exe command line parser, refer to - // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912 - // need quotes for empty arg - if (!arg) { - return '""'; - } - // determine whether the arg needs to be quoted - const cmdSpecialChars = [ - ' ', - '\t', - '&', - '(', - ')', - '[', - ']', - '{', - '}', - '^', - '=', - ';', - '!', - "'", - '+', - ',', - '`', - '~', - '|', - '<', - '>', - '"' - ]; - let needsQuotes = false; - for (const char of arg) { - if (cmdSpecialChars.some(x => x === char)) { - needsQuotes = true; - break; - } - } - // short-circuit if quotes not needed - if (!needsQuotes) { - return arg; - } - // the following quoting rules are very similar to the rules that by libuv applies. - // - // 1) wrap the string in quotes - // - // 2) double-up quotes - i.e. " => "" - // - // this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately - // doesn't work well with a cmd.exe command line. - // - // note, replacing " with "" also works well if the arg is passed to a downstream .NET console app. - // for example, the command line: - // foo.exe "myarg:""my val""" - // is parsed by a .NET console app into an arg array: - // [ "myarg:\"my val\"" ] - // which is the same end result when applying libuv quoting rules. although the actual - // command line from libuv quoting rules would look like: - // foo.exe "myarg:\"my val\"" - // - // 3) double-up slashes that precede a quote, - // e.g. hello \world => "hello \world" - // hello\"world => "hello\\""world" - // hello\\"world => "hello\\\\""world" - // hello world\ => "hello world\\" - // - // technically this is not required for a cmd.exe command line, or the batch argument parser. - // the reasons for including this as a .cmd quoting rule are: - // - // a) this is optimized for the scenario where the argument is passed from the .cmd file to an - // external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule. - // - // b) it's what we've been doing previously (by deferring to node default behavior) and we - // haven't heard any complaints about that aspect. - // - // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be - // escaped when used on the command line directly - even though within a .cmd file % can be escaped - // by using %%. - // - // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts - // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing. - // - // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would - // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the - // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args - // to an external program. - // - // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file. - // % can be escaped within a .cmd file. - let reverse = '"'; - let quoteHit = true; - for (let i = arg.length; i > 0; i--) { - // walk the string in reverse - reverse += arg[i - 1]; - if (quoteHit && arg[i - 1] === '\\') { - reverse += '\\'; // double the slash - } - else if (arg[i - 1] === '"') { - quoteHit = true; - reverse += '"'; // double the quote - } - else { - quoteHit = false; - } - } - reverse += '"'; - return reverse - .split('') - .reverse() - .join(''); - } - _uvQuoteCmdArg(arg) { - // Tool runner wraps child_process.spawn() and needs to apply the same quoting as - // Node in certain cases where the undocumented spawn option windowsVerbatimArguments - // is used. - // - // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV, - // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details), - // pasting copyright notice from Node within this function: - // - // Copyright Joyent, Inc. and other Node contributors. All rights reserved. - // - // Permission is hereby granted, free of charge, to any person obtaining a copy - // of this software and associated documentation files (the "Software"), to - // deal in the Software without restriction, including without limitation the - // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - // sell copies of the Software, and to permit persons to whom the Software is - // furnished to do so, subject to the following conditions: - // - // The above copyright notice and this permission notice shall be included in - // all copies or substantial portions of the Software. - // - // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - // IN THE SOFTWARE. - if (!arg) { - // Need double quotation for empty argument - return '""'; - } - if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) { - // No quotation needed - return arg; - } - if (!arg.includes('"') && !arg.includes('\\')) { - // No embedded double quotes or backslashes, so I can just wrap - // quote marks around the whole thing. - return `"${arg}"`; - } - // Expected input/output: - // input : hello"world - // output: "hello\"world" - // input : hello""world - // output: "hello\"\"world" - // input : hello\world - // output: hello\world - // input : hello\\world - // output: hello\\world - // input : hello\"world - // output: "hello\\\"world" - // input : hello\\"world - // output: "hello\\\\\"world" - // input : hello world\ - // output: "hello world\\" - note the comment in libuv actually reads "hello world\" - // but it appears the comment is wrong, it should be "hello world\\" - let reverse = '"'; - let quoteHit = true; - for (let i = arg.length; i > 0; i--) { - // walk the string in reverse - reverse += arg[i - 1]; - if (quoteHit && arg[i - 1] === '\\') { - reverse += '\\'; - } - else if (arg[i - 1] === '"') { - quoteHit = true; - reverse += '\\'; - } - else { - quoteHit = false; - } - } - reverse += '"'; - return reverse - .split('') - .reverse() - .join(''); + function warn2(logLevel, warning) { + if (logLevel === "debug" || logLevel === "warn") { + if (typeof node_process.emitWarning === "function") + node_process.emitWarning(warning); + else + console.warn(warning); + } } - _cloneExecOptions(options) { - options = options || {}; - const result = { - cwd: options.cwd || process.cwd(), - env: options.env || process.env, - silent: options.silent || false, - windowsVerbatimArguments: options.windowsVerbatimArguments || false, - failOnStdErr: options.failOnStdErr || false, - ignoreReturnCode: options.ignoreReturnCode || false, - delay: options.delay || 10000 - }; - result.outStream = options.outStream || process.stdout; - result.errStream = options.errStream || process.stderr; - return result; + exports2.debug = debug; + exports2.warn = warn2; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/merge.js +var require_merge = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/merge.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Scalar = require_Scalar(); + var MERGE_KEY = "<<"; + var merge = { + identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY, + default: "key", + tag: "tag:yaml.org,2002:merge", + test: /^<<$/, + resolve: () => Object.assign(new Scalar.Scalar(Symbol(MERGE_KEY)), { + addToJSMap: addMergeToJSMap + }), + stringify: () => MERGE_KEY + }; + var isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default); + function addMergeToJSMap(ctx, map, value) { + value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value; + if (identity.isSeq(value)) + for (const it of value.items) + mergeValue(ctx, map, it); + else if (Array.isArray(value)) + for (const it of value) + mergeValue(ctx, map, it); + else + mergeValue(ctx, map, value); } - _getSpawnOptions(options, toolPath) { - options = options || {}; - const result = {}; - result.cwd = options.cwd; - result.env = options.env; - result['windowsVerbatimArguments'] = - options.windowsVerbatimArguments || this._isCmdFile(); - if (options.windowsVerbatimArguments) { - result.argv0 = `"${toolPath}"`; + function mergeValue(ctx, map, value) { + const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value; + if (!identity.isMap(source)) + throw new Error("Merge sources must be maps or map aliases"); + const srcMap = source.toJSON(null, ctx, Map); + for (const [key, value2] of srcMap) { + if (map instanceof Map) { + if (!map.has(key)) + map.set(key, value2); + } else if (map instanceof Set) { + map.add(key); + } else if (!Object.prototype.hasOwnProperty.call(map, key)) { + Object.defineProperty(map, key, { + value: value2, + writable: true, + enumerable: true, + configurable: true + }); } - return result; - } - /** - * Exec a tool. - * Output will be streamed to the live console. - * Returns promise with return code - * - * @param tool path to tool to exec - * @param options optional exec options. See ExecOptions - * @returns number - */ - exec() { - return __awaiter(this, void 0, void 0, function* () { - // root the tool path if it is unrooted and contains relative pathing - if (!ioUtil.isRooted(this.toolPath) && - (this.toolPath.includes('/') || - (IS_WINDOWS && this.toolPath.includes('\\')))) { - // prefer options.cwd if it is specified, however options.cwd may also need to be rooted - this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); - } - // if the tool is only a file name, then resolve it from the PATH - // otherwise verify it exists (add extension on Windows if necessary) - this.toolPath = yield io.which(this.toolPath, true); - return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { - this._debug(`exec tool: ${this.toolPath}`); - this._debug('arguments:'); - for (const arg of this.args) { - this._debug(` ${arg}`); - } - const optionsNonNull = this._cloneExecOptions(this.options); - if (!optionsNonNull.silent && optionsNonNull.outStream) { - optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); - } - const state = new ExecState(optionsNonNull, this.toolPath); - state.on('debug', (message) => { - this._debug(message); - }); - if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) { - return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); - } - const fileName = this._getSpawnFileName(); - const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); - let stdbuffer = ''; - if (cp.stdout) { - cp.stdout.on('data', (data) => { - if (this.options.listeners && this.options.listeners.stdout) { - this.options.listeners.stdout(data); - } - if (!optionsNonNull.silent && optionsNonNull.outStream) { - optionsNonNull.outStream.write(data); - } - stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { - if (this.options.listeners && this.options.listeners.stdline) { - this.options.listeners.stdline(line); - } - }); - }); - } - let errbuffer = ''; - if (cp.stderr) { - cp.stderr.on('data', (data) => { - state.processStderr = true; - if (this.options.listeners && this.options.listeners.stderr) { - this.options.listeners.stderr(data); - } - if (!optionsNonNull.silent && - optionsNonNull.errStream && - optionsNonNull.outStream) { - const s = optionsNonNull.failOnStdErr - ? optionsNonNull.errStream - : optionsNonNull.outStream; - s.write(data); - } - errbuffer = this._processLineBuffer(data, errbuffer, (line) => { - if (this.options.listeners && this.options.listeners.errline) { - this.options.listeners.errline(line); - } - }); - }); - } - cp.on('error', (err) => { - state.processError = err.message; - state.processExited = true; - state.processClosed = true; - state.CheckComplete(); - }); - cp.on('exit', (code) => { - state.processExitCode = code; - state.processExited = true; - this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); - state.CheckComplete(); - }); - cp.on('close', (code) => { - state.processExitCode = code; - state.processExited = true; - state.processClosed = true; - this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); - state.CheckComplete(); - }); - state.on('done', (error, exitCode) => { - if (stdbuffer.length > 0) { - this.emit('stdline', stdbuffer); - } - if (errbuffer.length > 0) { - this.emit('errline', errbuffer); - } - cp.removeAllListeners(); - if (error) { - reject(error); - } - else { - resolve(exitCode); - } - }); - if (this.options.input) { - if (!cp.stdin) { - throw new Error('child process missing stdin'); - } - cp.stdin.end(this.options.input); - } - })); - }); + } + return map; } -} -exports.ToolRunner = ToolRunner; -/** - * Convert an arg string to an array of args. Handles escaping - * - * @param argString string of arguments - * @returns string[] array of arguments - */ -function argStringToArray(argString) { - const args = []; - let inQuotes = false; - let escaped = false; - let arg = ''; - function append(c) { - // we only escape double quotes. - if (escaped && c !== '"') { - arg += '\\'; + exports2.addMergeToJSMap = addMergeToJSMap; + exports2.isMergeKey = isMergeKey; + exports2.merge = merge; + } +}); + +// node_modules/yaml/dist/nodes/addPairToJSMap.js +var require_addPairToJSMap = __commonJS({ + "node_modules/yaml/dist/nodes/addPairToJSMap.js"(exports2) { + "use strict"; + var log = require_log(); + var merge = require_merge(); + var stringify2 = require_stringify(); + var identity = require_identity(); + var toJS = require_toJS(); + function addPairToJSMap(ctx, map, { key, value }) { + if (identity.isNode(key) && key.addToJSMap) + key.addToJSMap(ctx, map, value); + else if (merge.isMergeKey(ctx, key)) + merge.addMergeToJSMap(ctx, map, value); + else { + const jsKey = toJS.toJS(key, "", ctx); + if (map instanceof Map) { + map.set(jsKey, toJS.toJS(value, jsKey, ctx)); + } else if (map instanceof Set) { + map.add(jsKey); + } else { + const stringKey = stringifyKey(key, jsKey, ctx); + const jsValue = toJS.toJS(value, stringKey, ctx); + if (stringKey in map) + Object.defineProperty(map, stringKey, { + value: jsValue, + writable: true, + enumerable: true, + configurable: true + }); + else + map[stringKey] = jsValue; } - arg += c; - escaped = false; + } + return map; } - for (let i = 0; i < argString.length; i++) { - const c = argString.charAt(i); - if (c === '"') { - if (!escaped) { - inQuotes = !inQuotes; - } - else { - append(c); - } - continue; - } - if (c === '\\' && escaped) { - append(c); - continue; - } - if (c === '\\' && inQuotes) { - escaped = true; - continue; - } - if (c === ' ' && !inQuotes) { - if (arg.length > 0) { - args.push(arg); - arg = ''; - } - continue; + function stringifyKey(key, jsKey, ctx) { + if (jsKey === null) + return ""; + if (typeof jsKey !== "object") + return String(jsKey); + if (identity.isNode(key) && ctx?.doc) { + const strCtx = stringify2.createStringifyContext(ctx.doc, {}); + strCtx.anchors = /* @__PURE__ */ new Set(); + for (const node of ctx.anchors.keys()) + strCtx.anchors.add(node.anchor); + strCtx.inFlow = true; + strCtx.inStringifyKey = true; + const strKey = key.toString(strCtx); + if (!ctx.mapKeyWarned) { + let jsonStr = JSON.stringify(strKey); + if (jsonStr.length > 40) + jsonStr = jsonStr.substring(0, 36) + '..."'; + log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`); + ctx.mapKeyWarned = true; } - append(c); - } - if (arg.length > 0) { - args.push(arg.trim()); + return strKey; + } + return JSON.stringify(jsKey); } - return args; -} -exports.argStringToArray = argStringToArray; -class ExecState extends events.EventEmitter { - constructor(options, toolPath) { - super(); - this.processClosed = false; // tracks whether the process has exited and stdio is closed - this.processError = ''; - this.processExitCode = 0; - this.processExited = false; // tracks whether the process has exited - this.processStderr = false; // tracks whether stderr was written to - this.delay = 10000; // 10 seconds - this.done = false; - this.timeout = null; - if (!toolPath) { - throw new Error('toolPath must not be empty'); + exports2.addPairToJSMap = addPairToJSMap; + } +}); + +// node_modules/yaml/dist/nodes/Pair.js +var require_Pair = __commonJS({ + "node_modules/yaml/dist/nodes/Pair.js"(exports2) { + "use strict"; + var createNode = require_createNode(); + var stringifyPair = require_stringifyPair(); + var addPairToJSMap = require_addPairToJSMap(); + var identity = require_identity(); + function createPair(key, value, ctx) { + const k = createNode.createNode(key, void 0, ctx); + const v = createNode.createNode(value, void 0, ctx); + return new Pair(k, v); + } + var Pair = class _Pair { + constructor(key, value = null) { + Object.defineProperty(this, identity.NODE_TYPE, { value: identity.PAIR }); + this.key = key; + this.value = value; + } + clone(schema) { + let { key, value } = this; + if (identity.isNode(key)) + key = key.clone(schema); + if (identity.isNode(value)) + value = value.clone(schema); + return new _Pair(key, value); + } + toJSON(_, ctx) { + const pair = ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {}; + return addPairToJSMap.addPairToJSMap(ctx, pair, this); + } + toString(ctx, onComment, onChompKeep) { + return ctx?.doc ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this); + } + }; + exports2.Pair = Pair; + exports2.createPair = createPair; + } +}); + +// node_modules/yaml/dist/stringify/stringifyCollection.js +var require_stringifyCollection = __commonJS({ + "node_modules/yaml/dist/stringify/stringifyCollection.js"(exports2) { + "use strict"; + var identity = require_identity(); + var stringify2 = require_stringify(); + var stringifyComment = require_stringifyComment(); + function stringifyCollection(collection, ctx, options) { + const flow = ctx.inFlow ?? collection.flow; + const stringify3 = flow ? stringifyFlowCollection : stringifyBlockCollection; + return stringify3(collection, ctx, options); + } + function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) { + const { indent, options: { commentString } } = ctx; + const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null }); + let chompKeep = false; + const lines = []; + for (let i = 0; i < items.length; ++i) { + const item = items[i]; + let comment2 = null; + if (identity.isNode(item)) { + if (!chompKeep && item.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, item.commentBefore, chompKeep); + if (item.comment) + comment2 = item.comment; + } else if (identity.isPair(item)) { + const ik = identity.isNode(item.key) ? item.key : null; + if (ik) { + if (!chompKeep && ik.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, ik.commentBefore, chompKeep); + } } - this.options = options; - this.toolPath = toolPath; - if (options.delay) { - this.delay = options.delay; + chompKeep = false; + let str2 = stringify2.stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true); + if (comment2) + str2 += stringifyComment.lineComment(str2, itemIndent, commentString(comment2)); + if (chompKeep && comment2) + chompKeep = false; + lines.push(blockItemPrefix + str2); + } + let str; + if (lines.length === 0) { + str = flowChars.start + flowChars.end; + } else { + str = lines[0]; + for (let i = 1; i < lines.length; ++i) { + const line = lines[i]; + str += line ? ` +${indent}${line}` : "\n"; } + } + if (comment) { + str += "\n" + stringifyComment.indentComment(commentString(comment), indent); + if (onComment) + onComment(); + } else if (chompKeep && onChompKeep) + onChompKeep(); + return str; } - CheckComplete() { - if (this.done) { - return; + function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) { + const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx; + itemIndent += indentStep; + const itemCtx = Object.assign({}, ctx, { + indent: itemIndent, + inFlow: true, + type: null + }); + let reqNewline = false; + let linesAtValue = 0; + const lines = []; + for (let i = 0; i < items.length; ++i) { + const item = items[i]; + let comment = null; + if (identity.isNode(item)) { + if (item.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, item.commentBefore, false); + if (item.comment) + comment = item.comment; + } else if (identity.isPair(item)) { + const ik = identity.isNode(item.key) ? item.key : null; + if (ik) { + if (ik.spaceBefore) + lines.push(""); + addCommentBefore(ctx, lines, ik.commentBefore, false); + if (ik.comment) + reqNewline = true; + } + const iv = identity.isNode(item.value) ? item.value : null; + if (iv) { + if (iv.comment) + comment = iv.comment; + if (iv.commentBefore) + reqNewline = true; + } else if (item.value == null && ik?.comment) { + comment = ik.comment; + } } - if (this.processClosed) { - this._setResult(); + if (comment) + reqNewline = true; + let str = stringify2.stringify(item, itemCtx, () => comment = null); + if (i < items.length - 1) + str += ","; + if (comment) + str += stringifyComment.lineComment(str, itemIndent, commentString(comment)); + if (!reqNewline && (lines.length > linesAtValue || str.includes("\n"))) + reqNewline = true; + lines.push(str); + linesAtValue = lines.length; + } + const { start, end } = flowChars; + if (lines.length === 0) { + return start + end; + } else { + if (!reqNewline) { + const len = lines.reduce((sum, line) => sum + line.length + 2, 2); + reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth; } - else if (this.processExited) { - this.timeout = timers_1.setTimeout(ExecState.HandleTimeout, this.delay, this); + if (reqNewline) { + let str = start; + for (const line of lines) + str += line ? ` +${indentStep}${indent}${line}` : "\n"; + return `${str} +${indent}${end}`; + } else { + return `${start}${fcPadding}${lines.join(" ")}${fcPadding}${end}`; } + } } - _debug(message) { - this.emit('debug', message); + function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) { + if (comment && chompKeep) + comment = comment.replace(/^\n+/, ""); + if (comment) { + const ic = stringifyComment.indentComment(commentString(comment), indent); + lines.push(ic.trimStart()); + } } - _setResult() { - // determine whether there is an error - let error; - if (this.processExited) { - if (this.processError) { - error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); - } - else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { - error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); - } - else if (this.processStderr && this.options.failOnStdErr) { - error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); - } - } - // clear the timeout - if (this.timeout) { - clearTimeout(this.timeout); - this.timeout = null; + exports2.stringifyCollection = stringifyCollection; + } +}); + +// node_modules/yaml/dist/nodes/YAMLMap.js +var require_YAMLMap = __commonJS({ + "node_modules/yaml/dist/nodes/YAMLMap.js"(exports2) { + "use strict"; + var stringifyCollection = require_stringifyCollection(); + var addPairToJSMap = require_addPairToJSMap(); + var Collection = require_Collection(); + var identity = require_identity(); + var Pair = require_Pair(); + var Scalar = require_Scalar(); + function findPair(items, key) { + const k = identity.isScalar(key) ? key.value : key; + for (const it of items) { + if (identity.isPair(it)) { + if (it.key === key || it.key === k) + return it; + if (identity.isScalar(it.key) && it.key.value === k) + return it; } - this.done = true; - this.emit('done', error, this.processExitCode); + } + return void 0; } - static HandleTimeout(state) { - if (state.done) { + var YAMLMap = class extends Collection.Collection { + static get tagName() { + return "tag:yaml.org,2002:map"; + } + constructor(schema) { + super(identity.MAP, schema); + this.items = []; + } + /** + * A generic collection parsing method that can be extended + * to other node classes that inherit from YAMLMap + */ + static from(schema, obj, ctx) { + const { keepUndefined, replacer } = ctx; + const map = new this(schema); + const add = (key, value) => { + if (typeof replacer === "function") + value = replacer.call(obj, key, value); + else if (Array.isArray(replacer) && !replacer.includes(key)) return; + if (value !== void 0 || keepUndefined) + map.items.push(Pair.createPair(key, value, ctx)); + }; + if (obj instanceof Map) { + for (const [key, value] of obj) + add(key, value); + } else if (obj && typeof obj === "object") { + for (const key of Object.keys(obj)) + add(key, obj[key]); } - if (!state.processClosed && state.processExited) { - const message = `The STDIO streams did not close within ${state.delay / - 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; - state._debug(message); - } - state._setResult(); - } -} -//# sourceMappingURL=toolrunner.js.map - -/***/ }), - -/***/ 4552: -/***/ (function(__unused_webpack_module, exports) { - -"use strict"; - -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.PersonalAccessTokenCredentialHandler = exports.BearerCredentialHandler = exports.BasicCredentialHandler = void 0; -class BasicCredentialHandler { - constructor(username, password) { - this.username = username; - this.password = password; - } - prepareRequest(options) { - if (!options.headers) { - throw Error('The request has no headers'); + if (typeof schema.sortMapEntries === "function") { + map.items.sort(schema.sortMapEntries); } - options.headers['Authorization'] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`; - } - // This handler cannot handle 401 - canHandleAuthentication() { - return false; - } - handleAuthentication() { - return __awaiter(this, void 0, void 0, function* () { - throw new Error('not implemented'); - }); - } -} -exports.BasicCredentialHandler = BasicCredentialHandler; -class BearerCredentialHandler { - constructor(token) { - this.token = token; - } - // currently implements pre-authorization - // TODO: support preAuth = false where it hooks on 401 - prepareRequest(options) { - if (!options.headers) { - throw Error('The request has no headers'); + return map; + } + /** + * Adds a value to the collection. + * + * @param overwrite - If not set `true`, using a key that is already in the + * collection will throw. Otherwise, overwrites the previous value. + */ + add(pair, overwrite) { + let _pair; + if (identity.isPair(pair)) + _pair = pair; + else if (!pair || typeof pair !== "object" || !("key" in pair)) { + _pair = new Pair.Pair(pair, pair?.value); + } else + _pair = new Pair.Pair(pair.key, pair.value); + const prev = findPair(this.items, _pair.key); + const sortEntries = this.schema?.sortMapEntries; + if (prev) { + if (!overwrite) + throw new Error(`Key ${_pair.key} already set`); + if (identity.isScalar(prev.value) && Scalar.isScalarValue(_pair.value)) + prev.value.value = _pair.value; + else + prev.value = _pair.value; + } else if (sortEntries) { + const i = this.items.findIndex((item) => sortEntries(_pair, item) < 0); + if (i === -1) + this.items.push(_pair); + else + this.items.splice(i, 0, _pair); + } else { + this.items.push(_pair); } - options.headers['Authorization'] = `Bearer ${this.token}`; - } - // This handler cannot handle 401 - canHandleAuthentication() { - return false; - } - handleAuthentication() { - return __awaiter(this, void 0, void 0, function* () { - throw new Error('not implemented'); - }); - } -} -exports.BearerCredentialHandler = BearerCredentialHandler; -class PersonalAccessTokenCredentialHandler { - constructor(token) { - this.token = token; - } - // currently implements pre-authorization - // TODO: support preAuth = false where it hooks on 401 - prepareRequest(options) { - if (!options.headers) { - throw Error('The request has no headers'); + } + delete(key) { + const it = findPair(this.items, key); + if (!it) + return false; + const del = this.items.splice(this.items.indexOf(it), 1); + return del.length > 0; + } + get(key, keepScalar) { + const it = findPair(this.items, key); + const node = it?.value; + return (!keepScalar && identity.isScalar(node) ? node.value : node) ?? void 0; + } + has(key) { + return !!findPair(this.items, key); + } + set(key, value) { + this.add(new Pair.Pair(key, value), true); + } + /** + * @param ctx - Conversion context, originally set in Document#toJS() + * @param {Class} Type - If set, forces the returned collection type + * @returns Instance of Type, Map, or Object + */ + toJSON(_, ctx, Type) { + const map = Type ? new Type() : ctx?.mapAsMap ? /* @__PURE__ */ new Map() : {}; + if (ctx?.onCreate) + ctx.onCreate(map); + for (const item of this.items) + addPairToJSMap.addPairToJSMap(ctx, map, item); + return map; + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) + return JSON.stringify(this); + for (const item of this.items) { + if (!identity.isPair(item)) + throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`); } - options.headers['Authorization'] = `Basic ${Buffer.from(`PAT:${this.token}`).toString('base64')}`; - } - // This handler cannot handle 401 - canHandleAuthentication() { - return false; - } - handleAuthentication() { - return __awaiter(this, void 0, void 0, function* () { - throw new Error('not implemented'); + if (!ctx.allNullValues && this.hasAllNullValues(false)) + ctx = Object.assign({}, ctx, { allNullValues: true }); + return stringifyCollection.stringifyCollection(this, ctx, { + blockItemPrefix: "", + flowChars: { start: "{", end: "}" }, + itemIndent: ctx.indent || "", + onChompKeep, + onComment + }); + } + }; + exports2.YAMLMap = YAMLMap; + exports2.findPair = findPair; + } +}); + +// node_modules/yaml/dist/schema/common/map.js +var require_map = __commonJS({ + "node_modules/yaml/dist/schema/common/map.js"(exports2) { + "use strict"; + var identity = require_identity(); + var YAMLMap = require_YAMLMap(); + var map = { + collection: "map", + default: true, + nodeClass: YAMLMap.YAMLMap, + tag: "tag:yaml.org,2002:map", + resolve(map2, onError) { + if (!identity.isMap(map2)) + onError("Expected a mapping for this tag"); + return map2; + }, + createNode: (schema, obj, ctx) => YAMLMap.YAMLMap.from(schema, obj, ctx) + }; + exports2.map = map; + } +}); + +// node_modules/yaml/dist/nodes/YAMLSeq.js +var require_YAMLSeq = __commonJS({ + "node_modules/yaml/dist/nodes/YAMLSeq.js"(exports2) { + "use strict"; + var createNode = require_createNode(); + var stringifyCollection = require_stringifyCollection(); + var Collection = require_Collection(); + var identity = require_identity(); + var Scalar = require_Scalar(); + var toJS = require_toJS(); + var YAMLSeq = class extends Collection.Collection { + static get tagName() { + return "tag:yaml.org,2002:seq"; + } + constructor(schema) { + super(identity.SEQ, schema); + this.items = []; + } + add(value) { + this.items.push(value); + } + /** + * Removes a value from the collection. + * + * `key` must contain a representation of an integer for this to succeed. + * It may be wrapped in a `Scalar`. + * + * @returns `true` if the item was found and removed. + */ + delete(key) { + const idx = asItemIndex(key); + if (typeof idx !== "number") + return false; + const del = this.items.splice(idx, 1); + return del.length > 0; + } + get(key, keepScalar) { + const idx = asItemIndex(key); + if (typeof idx !== "number") + return void 0; + const it = this.items[idx]; + return !keepScalar && identity.isScalar(it) ? it.value : it; + } + /** + * Checks if the collection includes a value with the key `key`. + * + * `key` must contain a representation of an integer for this to succeed. + * It may be wrapped in a `Scalar`. + */ + has(key) { + const idx = asItemIndex(key); + return typeof idx === "number" && idx < this.items.length; + } + /** + * Sets a value in this collection. For `!!set`, `value` needs to be a + * boolean to add/remove the item from the set. + * + * If `key` does not contain a representation of an integer, this will throw. + * It may be wrapped in a `Scalar`. + */ + set(key, value) { + const idx = asItemIndex(key); + if (typeof idx !== "number") + throw new Error(`Expected a valid index, not ${key}.`); + const prev = this.items[idx]; + if (identity.isScalar(prev) && Scalar.isScalarValue(value)) + prev.value = value; + else + this.items[idx] = value; + } + toJSON(_, ctx) { + const seq = []; + if (ctx?.onCreate) + ctx.onCreate(seq); + let i = 0; + for (const item of this.items) + seq.push(toJS.toJS(item, String(i++), ctx)); + return seq; + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) + return JSON.stringify(this); + return stringifyCollection.stringifyCollection(this, ctx, { + blockItemPrefix: "- ", + flowChars: { start: "[", end: "]" }, + itemIndent: (ctx.indent || "") + " ", + onChompKeep, + onComment }); + } + static from(schema, obj, ctx) { + const { replacer } = ctx; + const seq = new this(schema); + if (obj && Symbol.iterator in Object(obj)) { + let i = 0; + for (let it of obj) { + if (typeof replacer === "function") { + const key = obj instanceof Set ? it : String(i++); + it = replacer.call(obj, key, it); + } + seq.items.push(createNode.createNode(it, void 0, ctx)); + } + } + return seq; + } + }; + function asItemIndex(key) { + let idx = identity.isScalar(key) ? key.value : key; + if (idx && typeof idx === "string") + idx = Number(idx); + return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null; } -} -exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; -//# sourceMappingURL=auth.js.map + exports2.YAMLSeq = YAMLSeq; + } +}); -/***/ }), +// node_modules/yaml/dist/schema/common/seq.js +var require_seq = __commonJS({ + "node_modules/yaml/dist/schema/common/seq.js"(exports2) { + "use strict"; + var identity = require_identity(); + var YAMLSeq = require_YAMLSeq(); + var seq = { + collection: "seq", + default: true, + nodeClass: YAMLSeq.YAMLSeq, + tag: "tag:yaml.org,2002:seq", + resolve(seq2, onError) { + if (!identity.isSeq(seq2)) + onError("Expected a sequence for this tag"); + return seq2; + }, + createNode: (schema, obj, ctx) => YAMLSeq.YAMLSeq.from(schema, obj, ctx) + }; + exports2.seq = seq; + } +}); -/***/ 4844: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { +// node_modules/yaml/dist/schema/common/string.js +var require_string = __commonJS({ + "node_modules/yaml/dist/schema/common/string.js"(exports2) { + "use strict"; + var stringifyString = require_stringifyString(); + var string = { + identify: (value) => typeof value === "string", + default: true, + tag: "tag:yaml.org,2002:str", + resolve: (str) => str, + stringify(item, ctx, onComment, onChompKeep) { + ctx = Object.assign({ actualString: true }, ctx); + return stringifyString.stringifyString(item, ctx, onComment, onChompKeep); + } + }; + exports2.string = string; + } +}); -"use strict"; +// node_modules/yaml/dist/schema/common/null.js +var require_null = __commonJS({ + "node_modules/yaml/dist/schema/common/null.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + var nullTag = { + identify: (value) => value == null, + createNode: () => new Scalar.Scalar(null), + default: true, + tag: "tag:yaml.org,2002:null", + test: /^(?:~|[Nn]ull|NULL)?$/, + resolve: () => new Scalar.Scalar(null), + stringify: ({ source }, ctx) => typeof source === "string" && nullTag.test.test(source) ? source : ctx.options.nullStr + }; + exports2.nullTag = nullTag; + } +}); -/* eslint-disable @typescript-eslint/no-explicit-any */ -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { return m[k]; } }; - } - Object.defineProperty(o, k2, desc); -}) : (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; +// node_modules/yaml/dist/schema/core/bool.js +var require_bool = __commonJS({ + "node_modules/yaml/dist/schema/core/bool.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + var boolTag = { + identify: (value) => typeof value === "boolean", + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/, + resolve: (str) => new Scalar.Scalar(str[0] === "t" || str[0] === "T"), + stringify({ source, value }, ctx) { + if (source && boolTag.test.test(source)) { + const sv = source[0] === "t" || source[0] === "T"; + if (value === sv) + return source; + } + return value ? ctx.options.trueStr : ctx.options.falseStr; + } + }; + exports2.boolTag = boolTag; + } }); -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; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; -const http = __importStar(__nccwpck_require__(8611)); -const https = __importStar(__nccwpck_require__(5692)); -const pm = __importStar(__nccwpck_require__(4988)); -const tunnel = __importStar(__nccwpck_require__(770)); -const undici_1 = __nccwpck_require__(4371); -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 = HttpCodes = {})); -var Headers; -(function (Headers) { - Headers["Accept"] = "accept"; - Headers["ContentType"] = "content-type"; -})(Headers || (exports.Headers = Headers = {})); -var MediaTypes; -(function (MediaTypes) { - MediaTypes["ApplicationJson"] = "application/json"; -})(MediaTypes || (exports.MediaTypes = MediaTypes = {})); -/** - * Returns the proxy URL, depending upon the supplied url and proxy environment variables. - * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com - */ -function getProxyUrl(serverUrl) { - const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); - return proxyUrl ? proxyUrl.href : ''; -} -exports.getProxyUrl = getProxyUrl; -const HttpRedirectCodes = [ - HttpCodes.MovedPermanently, - HttpCodes.ResourceMoved, - HttpCodes.SeeOther, - HttpCodes.TemporaryRedirect, - HttpCodes.PermanentRedirect -]; -const HttpResponseRetryCodes = [ - HttpCodes.BadGateway, - HttpCodes.ServiceUnavailable, - HttpCodes.GatewayTimeout -]; -const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; -const ExponentialBackoffCeiling = 10; -const ExponentialBackoffTimeSlice = 5; -class HttpClientError extends Error { - constructor(message, statusCode) { - super(message); - this.name = 'HttpClientError'; - this.statusCode = statusCode; - Object.setPrototypeOf(this, HttpClientError.prototype); - } -} -exports.HttpClientError = HttpClientError; -class HttpClientResponse { - constructor(message) { - this.message = message; - } - readBody() { - return __awaiter(this, void 0, void 0, function* () { - return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { - let output = Buffer.alloc(0); - this.message.on('data', (chunk) => { - output = Buffer.concat([output, chunk]); - }); - this.message.on('end', () => { - resolve(output.toString()); - }); - })); - }); - } - readBodyBuffer() { - return __awaiter(this, void 0, void 0, function* () { - return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { - const chunks = []; - this.message.on('data', (chunk) => { - chunks.push(chunk); - }); - this.message.on('end', () => { - resolve(Buffer.concat(chunks)); - }); - })); - }); + +// node_modules/yaml/dist/stringify/stringifyNumber.js +var require_stringifyNumber = __commonJS({ + "node_modules/yaml/dist/stringify/stringifyNumber.js"(exports2) { + "use strict"; + function stringifyNumber({ format, minFractionDigits, tag, value }) { + if (typeof value === "bigint") + return String(value); + const num = typeof value === "number" ? value : Number(value); + if (!isFinite(num)) + return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf"; + let n = JSON.stringify(value); + if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) { + let i = n.indexOf("."); + if (i < 0) { + i = n.length; + n += "."; + } + let d = minFractionDigits - (n.length - i - 1); + while (d-- > 0) + n += "0"; + } + return n; } -} -exports.HttpClientResponse = HttpClientResponse; -function isHttps(requestUrl) { - const parsedUrl = new URL(requestUrl); - return parsedUrl.protocol === 'https:'; -} -exports.isHttps = isHttps; -class HttpClient { - constructor(userAgent, handlers, requestOptions) { - this._ignoreSslError = false; - this._allowRedirects = true; - this._allowRedirectDowngrade = false; - this._maxRedirects = 50; - this._allowRetries = false; - this._maxRetries = 1; - this._keepAlive = false; - this._disposed = false; - this.userAgent = userAgent; - this.handlers = handlers || []; - this.requestOptions = requestOptions; - if (requestOptions) { - if (requestOptions.ignoreSslError != null) { - this._ignoreSslError = requestOptions.ignoreSslError; - } - this._socketTimeout = requestOptions.socketTimeout; - if (requestOptions.allowRedirects != null) { - this._allowRedirects = requestOptions.allowRedirects; - } - if (requestOptions.allowRedirectDowngrade != null) { - this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; - } - if (requestOptions.maxRedirects != null) { - this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); - } - if (requestOptions.keepAlive != null) { - this._keepAlive = requestOptions.keepAlive; - } - if (requestOptions.allowRetries != null) { - this._allowRetries = requestOptions.allowRetries; + exports2.stringifyNumber = stringifyNumber; + } +}); + +// node_modules/yaml/dist/schema/core/float.js +var require_float = __commonJS({ + "node_modules/yaml/dist/schema/core/float.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + var stringifyNumber = require_stringifyNumber(); + var floatNaN = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/, + resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, + stringify: stringifyNumber.stringifyNumber + }; + var floatExp = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + format: "EXP", + test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/, + resolve: (str) => parseFloat(str), + stringify(node) { + const num = Number(node.value); + return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node); + } + }; + var float = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/, + resolve(str) { + const node = new Scalar.Scalar(parseFloat(str)); + const dot = str.indexOf("."); + if (dot !== -1 && str[str.length - 1] === "0") + node.minFractionDigits = str.length - dot - 1; + return node; + }, + stringify: stringifyNumber.stringifyNumber + }; + exports2.float = float; + exports2.floatExp = floatExp; + exports2.floatNaN = floatNaN; + } +}); + +// node_modules/yaml/dist/schema/core/int.js +var require_int = __commonJS({ + "node_modules/yaml/dist/schema/core/int.js"(exports2) { + "use strict"; + var stringifyNumber = require_stringifyNumber(); + var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value); + var intResolve = (str, offset, radix, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix); + function intStringify(node, radix, prefix) { + const { value } = node; + if (intIdentify(value) && value >= 0) + return prefix + value.toString(radix); + return stringifyNumber.stringifyNumber(node); + } + var intOct = { + identify: (value) => intIdentify(value) && value >= 0, + default: true, + tag: "tag:yaml.org,2002:int", + format: "OCT", + test: /^0o[0-7]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt), + stringify: (node) => intStringify(node, 8, "0o") + }; + var int = { + identify: intIdentify, + default: true, + tag: "tag:yaml.org,2002:int", + test: /^[-+]?[0-9]+$/, + resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt), + stringify: stringifyNumber.stringifyNumber + }; + var intHex = { + identify: (value) => intIdentify(value) && value >= 0, + default: true, + tag: "tag:yaml.org,2002:int", + format: "HEX", + test: /^0x[0-9a-fA-F]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt), + stringify: (node) => intStringify(node, 16, "0x") + }; + exports2.int = int; + exports2.intHex = intHex; + exports2.intOct = intOct; + } +}); + +// node_modules/yaml/dist/schema/core/schema.js +var require_schema = __commonJS({ + "node_modules/yaml/dist/schema/core/schema.js"(exports2) { + "use strict"; + var map = require_map(); + var _null = require_null(); + var seq = require_seq(); + var string = require_string(); + var bool = require_bool(); + var float = require_float(); + var int = require_int(); + var schema = [ + map.map, + seq.seq, + string.string, + _null.nullTag, + bool.boolTag, + int.intOct, + int.int, + int.intHex, + float.floatNaN, + float.floatExp, + float.float + ]; + exports2.schema = schema; + } +}); + +// node_modules/yaml/dist/schema/json/schema.js +var require_schema2 = __commonJS({ + "node_modules/yaml/dist/schema/json/schema.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + var map = require_map(); + var seq = require_seq(); + function intIdentify(value) { + return typeof value === "bigint" || Number.isInteger(value); + } + var stringifyJSON = ({ value }) => JSON.stringify(value); + var jsonScalars = [ + { + identify: (value) => typeof value === "string", + default: true, + tag: "tag:yaml.org,2002:str", + resolve: (str) => str, + stringify: stringifyJSON + }, + { + identify: (value) => value == null, + createNode: () => new Scalar.Scalar(null), + default: true, + tag: "tag:yaml.org,2002:null", + test: /^null$/, + resolve: () => null, + stringify: stringifyJSON + }, + { + identify: (value) => typeof value === "boolean", + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^true$|^false$/, + resolve: (str) => str === "true", + stringify: stringifyJSON + }, + { + identify: intIdentify, + default: true, + tag: "tag:yaml.org,2002:int", + test: /^-?(?:0|[1-9][0-9]*)$/, + resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10), + stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value) + }, + { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/, + resolve: (str) => parseFloat(str), + stringify: stringifyJSON + } + ]; + var jsonError = { + default: true, + tag: "", + test: /^/, + resolve(str, onError) { + onError(`Unresolved plain scalar ${JSON.stringify(str)}`); + return str; + } + }; + var schema = [map.map, seq.seq].concat(jsonScalars, jsonError); + exports2.schema = schema; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/binary.js +var require_binary = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/binary.js"(exports2) { + "use strict"; + var node_buffer = require("buffer"); + var Scalar = require_Scalar(); + var stringifyString = require_stringifyString(); + var binary = { + identify: (value) => value instanceof Uint8Array, + // Buffer inherits from Uint8Array + default: false, + tag: "tag:yaml.org,2002:binary", + /** + * Returns a Buffer in node and an Uint8Array in browsers + * + * To use the resulting buffer as an image, you'll want to do something like: + * + * const blob = new Blob([buffer], { type: 'image/jpeg' }) + * document.querySelector('#photo').src = URL.createObjectURL(blob) + */ + resolve(src, onError) { + if (typeof node_buffer.Buffer === "function") { + return node_buffer.Buffer.from(src, "base64"); + } else if (typeof atob === "function") { + const str = atob(src.replace(/[\n\r]/g, "")); + const buffer = new Uint8Array(str.length); + for (let i = 0; i < str.length; ++i) + buffer[i] = str.charCodeAt(i); + return buffer; + } else { + onError("This environment does not support reading binary tags; either Buffer or atob is required"); + return src; + } + }, + stringify({ comment, type, value }, ctx, onComment, onChompKeep) { + if (!value) + return ""; + const buf = value; + let str; + if (typeof node_buffer.Buffer === "function") { + str = buf instanceof node_buffer.Buffer ? buf.toString("base64") : node_buffer.Buffer.from(buf.buffer).toString("base64"); + } else if (typeof btoa === "function") { + let s = ""; + for (let i = 0; i < buf.length; ++i) + s += String.fromCharCode(buf[i]); + str = btoa(s); + } else { + throw new Error("This environment does not support writing binary tags; either Buffer or btoa is required"); + } + type ?? (type = Scalar.Scalar.BLOCK_LITERAL); + if (type !== Scalar.Scalar.QUOTE_DOUBLE) { + const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth); + const n = Math.ceil(str.length / lineWidth); + const lines = new Array(n); + for (let i = 0, o = 0; i < n; ++i, o += lineWidth) { + lines[i] = str.substr(o, lineWidth); + } + str = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? "\n" : " "); + } + return stringifyString.stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep); + } + }; + exports2.binary = binary; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/pairs.js +var require_pairs = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/pairs.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Pair = require_Pair(); + var Scalar = require_Scalar(); + var YAMLSeq = require_YAMLSeq(); + function resolvePairs(seq, onError) { + if (identity.isSeq(seq)) { + for (let i = 0; i < seq.items.length; ++i) { + let item = seq.items[i]; + if (identity.isPair(item)) + continue; + else if (identity.isMap(item)) { + if (item.items.length > 1) + onError("Each pair must have its own sequence indicator"); + const pair = item.items[0] || new Pair.Pair(new Scalar.Scalar(null)); + if (item.commentBefore) + pair.key.commentBefore = pair.key.commentBefore ? `${item.commentBefore} +${pair.key.commentBefore}` : item.commentBefore; + if (item.comment) { + const cn = pair.value ?? pair.key; + cn.comment = cn.comment ? `${item.comment} +${cn.comment}` : item.comment; } - if (requestOptions.maxRetries != null) { - this._maxRetries = requestOptions.maxRetries; + item = pair; + } + seq.items[i] = identity.isPair(item) ? item : new Pair.Pair(item); + } + } else + onError("Expected a sequence for this tag"); + return seq; + } + function createPairs(schema, iterable, ctx) { + const { replacer } = ctx; + const pairs2 = new YAMLSeq.YAMLSeq(schema); + pairs2.tag = "tag:yaml.org,2002:pairs"; + let i = 0; + if (iterable && Symbol.iterator in Object(iterable)) + for (let it of iterable) { + if (typeof replacer === "function") + it = replacer.call(iterable, String(i++), it); + let key, value; + if (Array.isArray(it)) { + if (it.length === 2) { + key = it[0]; + value = it[1]; + } else + throw new TypeError(`Expected [key, value] tuple: ${it}`); + } else if (it && it instanceof Object) { + const keys = Object.keys(it); + if (keys.length === 1) { + key = keys[0]; + value = it[key]; + } else { + throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`); } + } else { + key = it; + } + pairs2.items.push(Pair.createPair(key, value, ctx)); } + return pairs2; } - options(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); - }); - } - get(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('GET', requestUrl, null, additionalHeaders || {}); - }); - } - del(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('DELETE', requestUrl, null, additionalHeaders || {}); - }); - } - post(requestUrl, data, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('POST', requestUrl, data, additionalHeaders || {}); - }); - } - patch(requestUrl, data, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('PATCH', requestUrl, data, additionalHeaders || {}); - }); - } - put(requestUrl, data, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('PUT', requestUrl, data, additionalHeaders || {}); - }); - } - head(requestUrl, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request('HEAD', requestUrl, null, additionalHeaders || {}); - }); - } - sendStream(verb, requestUrl, stream, additionalHeaders) { - return __awaiter(this, void 0, void 0, function* () { - return this.request(verb, requestUrl, stream, additionalHeaders); - }); - } - /** - * Gets a typed object from an endpoint - * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise - */ - getJson(requestUrl, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - const res = yield this.get(requestUrl, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - postJson(requestUrl, obj, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - const data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - const res = yield this.post(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - putJson(requestUrl, obj, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - const data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - const res = yield this.put(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - patchJson(requestUrl, obj, additionalHeaders = {}) { - return __awaiter(this, void 0, void 0, function* () { - const data = JSON.stringify(obj, null, 2); - additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); - additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); - const res = yield this.patch(requestUrl, data, additionalHeaders); - return this._processResponse(res, this.requestOptions); - }); - } - /** - * Makes a raw http request. - * All other methods such as get, post, patch, and request ultimately call this. - * Prefer get, del, post and patch - */ - request(verb, requestUrl, data, headers) { - return __awaiter(this, void 0, void 0, function* () { - if (this._disposed) { - throw new Error('Client has already been disposed.'); - } - const parsedUrl = new URL(requestUrl); - let info = this._prepareRequest(verb, parsedUrl, headers); - // Only perform retries on reads since writes may not be idempotent. - const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) - ? this._maxRetries + 1 - : 1; - let numTries = 0; - let response; - do { - response = yield this.requestRaw(info, data); - // Check if it's an authentication challenge - if (response && - response.message && - response.message.statusCode === HttpCodes.Unauthorized) { - let authenticationHandler; - for (const handler of this.handlers) { - if (handler.canHandleAuthentication(response)) { - authenticationHandler = handler; - break; - } - } - if (authenticationHandler) { - return authenticationHandler.handleAuthentication(this, info, data); - } - else { - // We have received an unauthorized response but have no handlers to handle it. - // Let the response return to the caller. - return response; - } - } - let redirectsRemaining = this._maxRedirects; - while (response.message.statusCode && - HttpRedirectCodes.includes(response.message.statusCode) && - this._allowRedirects && - redirectsRemaining > 0) { - const redirectUrl = response.message.headers['location']; - if (!redirectUrl) { - // if there's no location to redirect to, we won't - break; - } - const parsedRedirectUrl = new URL(redirectUrl); - if (parsedUrl.protocol === 'https:' && - parsedUrl.protocol !== parsedRedirectUrl.protocol && - !this._allowRedirectDowngrade) { - throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); - } - // we need to finish reading the response before reassigning response - // which will leak the open socket. - yield response.readBody(); - // strip authorization header if redirected to a different hostname - if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { - for (const header in headers) { - // header names are case insensitive - if (header.toLowerCase() === 'authorization') { - delete headers[header]; - } - } - } - // let's make the request with the new redirectUrl - info = this._prepareRequest(verb, parsedRedirectUrl, headers); - response = yield this.requestRaw(info, data); - redirectsRemaining--; - } - if (!response.message.statusCode || - !HttpResponseRetryCodes.includes(response.message.statusCode)) { - // If not a retry code, return immediately instead of retrying - return response; - } - numTries += 1; - if (numTries < maxTries) { - yield response.readBody(); - yield this._performExponentialBackoff(numTries); - } - } while (numTries < maxTries); - return response; - }); - } - /** - * Needs to be called if keepAlive is set to true in request options. - */ - dispose() { - if (this._agent) { - this._agent.destroy(); - } - this._disposed = true; - } - /** - * Raw request. - * @param info - * @param data - */ - requestRaw(info, data) { - return __awaiter(this, void 0, void 0, function* () { - return new Promise((resolve, reject) => { - function callbackForResult(err, res) { - if (err) { - reject(err); - } - else if (!res) { - // If `err` is not passed, then `res` must be passed. - reject(new Error('Unknown error')); - } - else { - resolve(res); - } - } - this.requestRawWithCallback(info, data, callbackForResult); - }); - }); - } - /** - * Raw request with callback. - * @param info - * @param data - * @param onResult - */ - requestRawWithCallback(info, data, onResult) { - if (typeof data === 'string') { - if (!info.options.headers) { - info.options.headers = {}; - } - info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); - } - let callbackCalled = false; - function handleResult(err, res) { - if (!callbackCalled) { - callbackCalled = true; - onResult(err, res); - } + var pairs = { + collection: "seq", + default: false, + tag: "tag:yaml.org,2002:pairs", + resolve: resolvePairs, + createNode: createPairs + }; + exports2.createPairs = createPairs; + exports2.pairs = pairs; + exports2.resolvePairs = resolvePairs; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/omap.js +var require_omap = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/omap.js"(exports2) { + "use strict"; + var identity = require_identity(); + var toJS = require_toJS(); + var YAMLMap = require_YAMLMap(); + var YAMLSeq = require_YAMLSeq(); + var pairs = require_pairs(); + var YAMLOMap = class _YAMLOMap extends YAMLSeq.YAMLSeq { + constructor() { + super(); + this.add = YAMLMap.YAMLMap.prototype.add.bind(this); + this.delete = YAMLMap.YAMLMap.prototype.delete.bind(this); + this.get = YAMLMap.YAMLMap.prototype.get.bind(this); + this.has = YAMLMap.YAMLMap.prototype.has.bind(this); + this.set = YAMLMap.YAMLMap.prototype.set.bind(this); + this.tag = _YAMLOMap.tag; + } + /** + * If `ctx` is given, the return type is actually `Map`, + * but TypeScript won't allow widening the signature of a child method. + */ + toJSON(_, ctx) { + if (!ctx) + return super.toJSON(_); + const map = /* @__PURE__ */ new Map(); + if (ctx?.onCreate) + ctx.onCreate(map); + for (const pair of this.items) { + let key, value; + if (identity.isPair(pair)) { + key = toJS.toJS(pair.key, "", ctx); + value = toJS.toJS(pair.value, key, ctx); + } else { + key = toJS.toJS(pair, "", ctx); + } + if (map.has(key)) + throw new Error("Ordered maps must not include duplicate keys"); + map.set(key, value); } - const req = info.httpModule.request(info.options, (msg) => { - const res = new HttpClientResponse(msg); - handleResult(undefined, res); - }); - let socket; - req.on('socket', sock => { - socket = sock; - }); - // If we ever get disconnected, we want the socket to timeout eventually - req.setTimeout(this._socketTimeout || 3 * 60000, () => { - if (socket) { - socket.end(); + return map; + } + static from(schema, iterable, ctx) { + const pairs$1 = pairs.createPairs(schema, iterable, ctx); + const omap2 = new this(); + omap2.items = pairs$1.items; + return omap2; + } + }; + YAMLOMap.tag = "tag:yaml.org,2002:omap"; + var omap = { + collection: "seq", + identify: (value) => value instanceof Map, + nodeClass: YAMLOMap, + default: false, + tag: "tag:yaml.org,2002:omap", + resolve(seq, onError) { + const pairs$1 = pairs.resolvePairs(seq, onError); + const seenKeys = []; + for (const { key } of pairs$1.items) { + if (identity.isScalar(key)) { + if (seenKeys.includes(key.value)) { + onError(`Ordered maps must not include duplicate keys: ${key.value}`); + } else { + seenKeys.push(key.value); } - handleResult(new Error(`Request timeout: ${info.options.path}`)); - }); - req.on('error', function (err) { - // err has statusCode property - // res should have headers - handleResult(err); - }); - if (data && typeof data === 'string') { - req.write(data, 'utf8'); - } - if (data && typeof data !== 'string') { - data.on('close', function () { - req.end(); - }); - data.pipe(req); + } } - else { - req.end(); + return Object.assign(new YAMLOMap(), pairs$1); + }, + createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx) + }; + exports2.YAMLOMap = YAMLOMap; + exports2.omap = omap; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/bool.js +var require_bool2 = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/bool.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + function boolStringify({ value, source }, ctx) { + const boolObj = value ? trueTag : falseTag; + if (source && boolObj.test.test(source)) + return source; + return value ? ctx.options.trueStr : ctx.options.falseStr; + } + var trueTag = { + identify: (value) => value === true, + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/, + resolve: () => new Scalar.Scalar(true), + stringify: boolStringify + }; + var falseTag = { + identify: (value) => value === false, + default: true, + tag: "tag:yaml.org,2002:bool", + test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/, + resolve: () => new Scalar.Scalar(false), + stringify: boolStringify + }; + exports2.falseTag = falseTag; + exports2.trueTag = trueTag; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/float.js +var require_float2 = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/float.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + var stringifyNumber = require_stringifyNumber(); + var floatNaN = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/, + resolve: (str) => str.slice(-3).toLowerCase() === "nan" ? NaN : str[0] === "-" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, + stringify: stringifyNumber.stringifyNumber + }; + var floatExp = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + format: "EXP", + test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/, + resolve: (str) => parseFloat(str.replace(/_/g, "")), + stringify(node) { + const num = Number(node.value); + return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node); + } + }; + var float = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/, + resolve(str) { + const node = new Scalar.Scalar(parseFloat(str.replace(/_/g, ""))); + const dot = str.indexOf("."); + if (dot !== -1) { + const f = str.substring(dot + 1).replace(/_/g, ""); + if (f[f.length - 1] === "0") + node.minFractionDigits = f.length; } - } - /** - * Gets an http agent. This function is useful when you need an http agent that handles - * routing through a proxy server - depending upon the url and proxy environment variables. - * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com - */ - getAgent(serverUrl) { - const parsedUrl = new URL(serverUrl); - return this._getAgent(parsedUrl); - } - getAgentDispatcher(serverUrl) { - const parsedUrl = new URL(serverUrl); - const proxyUrl = pm.getProxyUrl(parsedUrl); - const useProxy = proxyUrl && proxyUrl.hostname; - if (!useProxy) { - return; + return node; + }, + stringify: stringifyNumber.stringifyNumber + }; + exports2.float = float; + exports2.floatExp = floatExp; + exports2.floatNaN = floatNaN; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/int.js +var require_int2 = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/int.js"(exports2) { + "use strict"; + var stringifyNumber = require_stringifyNumber(); + var intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value); + function intResolve(str, offset, radix, { intAsBigInt }) { + const sign = str[0]; + if (sign === "-" || sign === "+") + offset += 1; + str = str.substring(offset).replace(/_/g, ""); + if (intAsBigInt) { + switch (radix) { + case 2: + str = `0b${str}`; + break; + case 8: + str = `0o${str}`; + break; + case 16: + str = `0x${str}`; + break; } - return this._getProxyAgentDispatcher(parsedUrl, proxyUrl); + const n2 = BigInt(str); + return sign === "-" ? BigInt(-1) * n2 : n2; + } + const n = parseInt(str, radix); + return sign === "-" ? -1 * n : n; } - _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; + function intStringify(node, radix, prefix) { + const { value } = node; + if (intIdentify(value)) { + const str = value.toString(radix); + return value < 0 ? "-" + prefix + str.substr(1) : prefix + str; + } + return stringifyNumber.stringifyNumber(node); + } + var intBin = { + identify: intIdentify, + default: true, + tag: "tag:yaml.org,2002:int", + format: "BIN", + test: /^[-+]?0b[0-1_]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt), + stringify: (node) => intStringify(node, 2, "0b") + }; + var intOct = { + identify: intIdentify, + default: true, + tag: "tag:yaml.org,2002:int", + format: "OCT", + test: /^[-+]?0[0-7_]+$/, + resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt), + stringify: (node) => intStringify(node, 8, "0") + }; + var int = { + identify: intIdentify, + default: true, + tag: "tag:yaml.org,2002:int", + test: /^[-+]?[0-9][0-9_]*$/, + resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt), + stringify: stringifyNumber.stringifyNumber + }; + var intHex = { + identify: intIdentify, + default: true, + tag: "tag:yaml.org,2002:int", + format: "HEX", + test: /^[-+]?0x[0-9a-fA-F_]+$/, + resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt), + stringify: (node) => intStringify(node, 16, "0x") + }; + exports2.int = int; + exports2.intBin = intBin; + exports2.intHex = intHex; + exports2.intOct = intOct; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/set.js +var require_set = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/set.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Pair = require_Pair(); + var YAMLMap = require_YAMLMap(); + var YAMLSet = class _YAMLSet extends YAMLMap.YAMLMap { + constructor(schema) { + super(schema); + this.tag = _YAMLSet.tag; + } + add(key) { + let pair; + if (identity.isPair(key)) + pair = key; + else if (key && typeof key === "object" && "key" in key && "value" in key && key.value === null) + pair = new Pair.Pair(key.key, null); + else + pair = new Pair.Pair(key, null); + const prev = YAMLMap.findPair(this.items, pair.key); + if (!prev) + this.items.push(pair); + } + /** + * If `keepPair` is `true`, returns the Pair matching `key`. + * Otherwise, returns the value of that Pair's key. + */ + get(key, keepPair) { + const pair = YAMLMap.findPair(this.items, key); + return !keepPair && identity.isPair(pair) ? identity.isScalar(pair.key) ? pair.key.value : pair.key : pair; + } + set(key, value) { + if (typeof value !== "boolean") + throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`); + const prev = YAMLMap.findPair(this.items, key); + if (prev && !value) { + this.items.splice(this.items.indexOf(prev), 1); + } else if (!prev && value) { + this.items.push(new Pair.Pair(key)); } - info.options.agent = this._getAgent(info.parsedUrl); - // gives handlers an opportunity to participate - if (this.handlers) { - for (const handler of this.handlers) { - handler.prepareRequest(info.options); - } + } + toJSON(_, ctx) { + return super.toJSON(_, ctx, Set); + } + toString(ctx, onComment, onChompKeep) { + if (!ctx) + return JSON.stringify(this); + if (this.hasAllNullValues(true)) + return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep); + else + throw new Error("Set items must all have null values"); + } + static from(schema, iterable, ctx) { + const { replacer } = ctx; + const set2 = new this(schema); + if (iterable && Symbol.iterator in Object(iterable)) + for (let value of iterable) { + if (typeof replacer === "function") + value = replacer.call(iterable, value, value); + set2.items.push(Pair.createPair(value, null, ctx)); + } + return set2; + } + }; + YAMLSet.tag = "tag:yaml.org,2002:set"; + var set = { + collection: "map", + identify: (value) => value instanceof Set, + nodeClass: YAMLSet, + default: false, + tag: "tag:yaml.org,2002:set", + createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx), + resolve(map, onError) { + if (identity.isMap(map)) { + if (map.hasAllNullValues(true)) + return Object.assign(new YAMLSet(), map); + else + onError("Set items must all have null values"); + } else + onError("Expected a mapping for this tag"); + return map; + } + }; + exports2.YAMLSet = YAMLSet; + exports2.set = set; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/timestamp.js +var require_timestamp = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/timestamp.js"(exports2) { + "use strict"; + var stringifyNumber = require_stringifyNumber(); + function parseSexagesimal(str, asBigInt) { + const sign = str[0]; + const parts = sign === "-" || sign === "+" ? str.substring(1) : str; + const num = (n) => asBigInt ? BigInt(n) : Number(n); + const res = parts.replace(/_/g, "").split(":").reduce((res2, p) => res2 * num(60) + num(p), num(0)); + return sign === "-" ? num(-1) * res : res; + } + function stringifySexagesimal(node) { + let { value } = node; + let num = (n) => n; + if (typeof value === "bigint") + num = (n) => BigInt(n); + else if (isNaN(value) || !isFinite(value)) + return stringifyNumber.stringifyNumber(node); + let sign = ""; + if (value < 0) { + sign = "-"; + value *= num(-1); + } + const _60 = num(60); + const parts = [value % _60]; + if (value < 60) { + parts.unshift(0); + } else { + value = (value - parts[0]) / _60; + parts.unshift(value % _60); + if (value >= 60) { + value = (value - parts[0]) / _60; + parts.unshift(value); } - return info; + } + return sign + parts.map((n) => String(n).padStart(2, "0")).join(":").replace(/000000\d*$/, ""); } - _mergeHeaders(headers) { - if (this.requestOptions && this.requestOptions.headers) { - return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + var intTime = { + identify: (value) => typeof value === "bigint" || Number.isInteger(value), + default: true, + tag: "tag:yaml.org,2002:int", + format: "TIME", + test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/, + resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt), + stringify: stringifySexagesimal + }; + var floatTime = { + identify: (value) => typeof value === "number", + default: true, + tag: "tag:yaml.org,2002:float", + format: "TIME", + test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/, + resolve: (str) => parseSexagesimal(str, false), + stringify: stringifySexagesimal + }; + var timestamp = { + identify: (value) => value instanceof Date, + default: true, + tag: "tag:yaml.org,2002:timestamp", + // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part + // may be omitted altogether, resulting in a date format. In such a case, the time part is + // assumed to be 00:00:00Z (start of day, UTC). + test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?$"), + resolve(str) { + const match = str.match(timestamp.test); + if (!match) + throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd"); + const [, year, month, day, hour, minute, second] = match.map(Number); + const millisec = match[7] ? Number((match[7] + "00").substr(1, 3)) : 0; + let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec); + const tz = match[8]; + if (tz && tz !== "Z") { + let d = parseSexagesimal(tz, false); + if (Math.abs(d) < 30) + d *= 60; + date -= 6e4 * d; } - return lowercaseKeys(headers || {}); - } - _getExistingOrDefaultHeader(additionalHeaders, header, _default) { - let clientHeader; - if (this.requestOptions && this.requestOptions.headers) { - clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + return new Date(date); + }, + stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\.000Z$/, "") ?? "" + }; + exports2.floatTime = floatTime; + exports2.intTime = intTime; + exports2.timestamp = timestamp; + } +}); + +// node_modules/yaml/dist/schema/yaml-1.1/schema.js +var require_schema3 = __commonJS({ + "node_modules/yaml/dist/schema/yaml-1.1/schema.js"(exports2) { + "use strict"; + var map = require_map(); + var _null = require_null(); + var seq = require_seq(); + var string = require_string(); + var binary = require_binary(); + var bool = require_bool2(); + var float = require_float2(); + var int = require_int2(); + var merge = require_merge(); + var omap = require_omap(); + var pairs = require_pairs(); + var set = require_set(); + var timestamp = require_timestamp(); + var schema = [ + map.map, + seq.seq, + string.string, + _null.nullTag, + bool.trueTag, + bool.falseTag, + int.intBin, + int.intOct, + int.int, + int.intHex, + float.floatNaN, + float.floatExp, + float.float, + binary.binary, + merge.merge, + omap.omap, + pairs.pairs, + set.set, + timestamp.intTime, + timestamp.floatTime, + timestamp.timestamp + ]; + exports2.schema = schema; + } +}); + +// node_modules/yaml/dist/schema/tags.js +var require_tags = __commonJS({ + "node_modules/yaml/dist/schema/tags.js"(exports2) { + "use strict"; + var map = require_map(); + var _null = require_null(); + var seq = require_seq(); + var string = require_string(); + var bool = require_bool(); + var float = require_float(); + var int = require_int(); + var schema = require_schema(); + var schema$1 = require_schema2(); + var binary = require_binary(); + var merge = require_merge(); + var omap = require_omap(); + var pairs = require_pairs(); + var schema$2 = require_schema3(); + var set = require_set(); + var timestamp = require_timestamp(); + var schemas = /* @__PURE__ */ new Map([ + ["core", schema.schema], + ["failsafe", [map.map, seq.seq, string.string]], + ["json", schema$1.schema], + ["yaml11", schema$2.schema], + ["yaml-1.1", schema$2.schema] + ]); + var tagsByName = { + binary: binary.binary, + bool: bool.boolTag, + float: float.float, + floatExp: float.floatExp, + floatNaN: float.floatNaN, + floatTime: timestamp.floatTime, + int: int.int, + intHex: int.intHex, + intOct: int.intOct, + intTime: timestamp.intTime, + map: map.map, + merge: merge.merge, + null: _null.nullTag, + omap: omap.omap, + pairs: pairs.pairs, + seq: seq.seq, + set: set.set, + timestamp: timestamp.timestamp + }; + var coreKnownTags = { + "tag:yaml.org,2002:binary": binary.binary, + "tag:yaml.org,2002:merge": merge.merge, + "tag:yaml.org,2002:omap": omap.omap, + "tag:yaml.org,2002:pairs": pairs.pairs, + "tag:yaml.org,2002:set": set.set, + "tag:yaml.org,2002:timestamp": timestamp.timestamp + }; + function getTags(customTags, schemaName, addMergeTag) { + const schemaTags = schemas.get(schemaName); + if (schemaTags && !customTags) { + return addMergeTag && !schemaTags.includes(merge.merge) ? schemaTags.concat(merge.merge) : schemaTags.slice(); + } + let tags = schemaTags; + if (!tags) { + if (Array.isArray(customTags)) + tags = []; + else { + const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", "); + throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`); } - return additionalHeaders[header] || clientHeader || _default; + } + if (Array.isArray(customTags)) { + for (const tag of customTags) + tags = tags.concat(tag); + } else if (typeof customTags === "function") { + tags = customTags(tags.slice()); + } + if (addMergeTag) + tags = tags.concat(merge.merge); + return tags.reduce((tags2, tag) => { + const tagObj = typeof tag === "string" ? tagsByName[tag] : tag; + if (!tagObj) { + const tagName = JSON.stringify(tag); + const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", "); + throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`); + } + if (!tags2.includes(tagObj)) + tags2.push(tagObj); + return tags2; + }, []); } - _getAgent(parsedUrl) { - let agent; - const proxyUrl = pm.getProxyUrl(parsedUrl); - const useProxy = proxyUrl && proxyUrl.hostname; - if (this._keepAlive && useProxy) { - agent = this._proxyAgent; + exports2.coreKnownTags = coreKnownTags; + exports2.getTags = getTags; + } +}); + +// node_modules/yaml/dist/schema/Schema.js +var require_Schema = __commonJS({ + "node_modules/yaml/dist/schema/Schema.js"(exports2) { + "use strict"; + var identity = require_identity(); + var map = require_map(); + var seq = require_seq(); + var string = require_string(); + var tags = require_tags(); + var sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0; + var Schema = class _Schema { + constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) { + this.compat = Array.isArray(compat) ? tags.getTags(compat, "compat") : compat ? tags.getTags(null, compat) : null; + this.name = typeof schema === "string" && schema || "core"; + this.knownTags = resolveKnownTags ? tags.coreKnownTags : {}; + this.tags = tags.getTags(customTags, this.name, merge); + this.toStringOptions = toStringDefaults ?? null; + Object.defineProperty(this, identity.MAP, { value: map.map }); + Object.defineProperty(this, identity.SCALAR, { value: string.string }); + Object.defineProperty(this, identity.SEQ, { value: seq.seq }); + this.sortMapEntries = typeof sortMapEntries === "function" ? sortMapEntries : sortMapEntries === true ? sortMapEntriesByKey : null; + } + clone() { + const copy = Object.create(_Schema.prototype, Object.getOwnPropertyDescriptors(this)); + copy.tags = this.tags.slice(); + return copy; + } + }; + exports2.Schema = Schema; + } +}); + +// node_modules/yaml/dist/stringify/stringifyDocument.js +var require_stringifyDocument = __commonJS({ + "node_modules/yaml/dist/stringify/stringifyDocument.js"(exports2) { + "use strict"; + var identity = require_identity(); + var stringify2 = require_stringify(); + var stringifyComment = require_stringifyComment(); + function stringifyDocument(doc, options) { + const lines = []; + let hasDirectives = options.directives === true; + if (options.directives !== false && doc.directives) { + const dir = doc.directives.toString(doc); + if (dir) { + lines.push(dir); + hasDirectives = true; + } else if (doc.directives.docStart) + hasDirectives = true; + } + if (hasDirectives) + lines.push("---"); + const ctx = stringify2.createStringifyContext(doc, options); + const { commentString } = ctx.options; + if (doc.commentBefore) { + if (lines.length !== 1) + lines.unshift(""); + const cs = commentString(doc.commentBefore); + lines.unshift(stringifyComment.indentComment(cs, "")); + } + let chompKeep = false; + let contentComment = null; + if (doc.contents) { + if (identity.isNode(doc.contents)) { + if (doc.contents.spaceBefore && hasDirectives) + lines.push(""); + if (doc.contents.commentBefore) { + const cs = commentString(doc.contents.commentBefore); + lines.push(stringifyComment.indentComment(cs, "")); + } + ctx.forceBlockIndent = !!doc.comment; + contentComment = doc.contents.comment; } - if (!useProxy) { - agent = this._agent; + const onChompKeep = contentComment ? void 0 : () => chompKeep = true; + let body = stringify2.stringify(doc.contents, ctx, () => contentComment = null, onChompKeep); + if (contentComment) + body += stringifyComment.lineComment(body, "", commentString(contentComment)); + if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") { + lines[lines.length - 1] = `--- ${body}`; + } else + lines.push(body); + } else { + lines.push(stringify2.stringify(doc.contents, ctx)); + } + if (doc.directives?.docEnd) { + if (doc.comment) { + const cs = commentString(doc.comment); + if (cs.includes("\n")) { + lines.push("..."); + lines.push(stringifyComment.indentComment(cs, "")); + } else { + lines.push(`... ${cs}`); + } + } else { + lines.push("..."); } - // if agent is already assigned use that agent. - if (agent) { - return agent; + } else { + let dc = doc.comment; + if (dc && chompKeep) + dc = dc.replace(/^\n+/, ""); + if (dc) { + if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "") + lines.push(""); + lines.push(stringifyComment.indentComment(commentString(dc), "")); } - const usingSsl = parsedUrl.protocol === 'https:'; - let maxSockets = 100; - if (this.requestOptions) { - maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + return lines.join("\n") + "\n"; + } + exports2.stringifyDocument = stringifyDocument; + } +}); + +// node_modules/yaml/dist/doc/Document.js +var require_Document = __commonJS({ + "node_modules/yaml/dist/doc/Document.js"(exports2) { + "use strict"; + var Alias = require_Alias(); + var Collection = require_Collection(); + var identity = require_identity(); + var Pair = require_Pair(); + var toJS = require_toJS(); + var Schema = require_Schema(); + var stringifyDocument = require_stringifyDocument(); + var anchors = require_anchors(); + var applyReviver = require_applyReviver(); + var createNode = require_createNode(); + var directives = require_directives(); + var Document = class _Document { + constructor(value, replacer, options) { + this.commentBefore = null; + this.comment = null; + this.errors = []; + this.warnings = []; + Object.defineProperty(this, identity.NODE_TYPE, { value: identity.DOC }); + let _replacer = null; + if (typeof replacer === "function" || Array.isArray(replacer)) { + _replacer = replacer; + } else if (options === void 0 && replacer) { + options = replacer; + replacer = void 0; } - // This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis. - if (proxyUrl && proxyUrl.hostname) { - const agentOptions = { - maxSockets, - keepAlive: this._keepAlive, - proxy: Object.assign(Object.assign({}, ((proxyUrl.username || proxyUrl.password) && { - proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` - })), { host: proxyUrl.hostname, port: proxyUrl.port }) - }; - let tunnelAgent; - const overHttps = proxyUrl.protocol === 'https:'; - if (usingSsl) { - tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; - } - else { - tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; - } - agent = tunnelAgent(agentOptions); - this._proxyAgent = agent; + const opt = Object.assign({ + intAsBigInt: false, + keepSourceTokens: false, + logLevel: "warn", + prettyErrors: true, + strict: true, + stringKeys: false, + uniqueKeys: true, + version: "1.2" + }, options); + this.options = opt; + let { version } = opt; + if (options?._directives) { + this.directives = options._directives.atDocument(); + if (this.directives.yaml.explicit) + version = this.directives.yaml.version; + } else + this.directives = new directives.Directives({ version }); + this.setSchema(version, options); + this.contents = value === void 0 ? null : this.createNode(value, _replacer, options); + } + /** + * Create a deep copy of this Document and its contents. + * + * Custom Node values that inherit from `Object` still refer to their original instances. + */ + clone() { + const copy = Object.create(_Document.prototype, { + [identity.NODE_TYPE]: { value: identity.DOC } + }); + copy.commentBefore = this.commentBefore; + copy.comment = this.comment; + copy.errors = this.errors.slice(); + copy.warnings = this.warnings.slice(); + copy.options = Object.assign({}, this.options); + if (this.directives) + copy.directives = this.directives.clone(); + copy.schema = this.schema.clone(); + copy.contents = identity.isNode(this.contents) ? this.contents.clone(copy.schema) : this.contents; + if (this.range) + copy.range = this.range.slice(); + return copy; + } + /** Adds a value to the document. */ + add(value) { + if (assertCollection(this.contents)) + this.contents.add(value); + } + /** Adds a value to the document. */ + addIn(path2, value) { + if (assertCollection(this.contents)) + this.contents.addIn(path2, value); + } + /** + * Create a new `Alias` node, ensuring that the target `node` has the required anchor. + * + * If `node` already has an anchor, `name` is ignored. + * Otherwise, the `node.anchor` value will be set to `name`, + * or if an anchor with that name is already present in the document, + * `name` will be used as a prefix for a new unique anchor. + * If `name` is undefined, the generated anchor will use 'a' as a prefix. + */ + createAlias(node, name) { + if (!node.anchor) { + const prev = anchors.anchorNames(this); + node.anchor = // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing + !name || prev.has(name) ? anchors.findNewAnchor(name || "a", prev) : name; } - // if tunneling agent isn't assigned create a new agent - if (!agent) { - const options = { keepAlive: this._keepAlive, maxSockets }; - agent = usingSsl ? new https.Agent(options) : new http.Agent(options); - this._agent = agent; + return new Alias.Alias(node.anchor); + } + createNode(value, replacer, options) { + let _replacer = void 0; + if (typeof replacer === "function") { + value = replacer.call({ "": value }, "", value); + _replacer = replacer; + } else if (Array.isArray(replacer)) { + const keyToStr = (v) => typeof v === "number" || v instanceof String || v instanceof Number; + const asStr = replacer.filter(keyToStr).map(String); + if (asStr.length > 0) + replacer = replacer.concat(asStr); + _replacer = replacer; + } else if (options === void 0 && replacer) { + options = replacer; + replacer = void 0; } - 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 - }); + const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {}; + const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors( + this, + // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing + anchorPrefix || "a" + ); + const ctx = { + aliasDuplicateObjects: aliasDuplicateObjects ?? true, + keepUndefined: keepUndefined ?? false, + onAnchor, + onTagObj, + replacer: _replacer, + schema: this.schema, + sourceObjects + }; + const node = createNode.createNode(value, tag, ctx); + if (flow && identity.isCollection(node)) + node.flow = true; + setAnchors(); + return node; + } + /** + * Convert a key and a value into a `Pair` using the current schema, + * recursively wrapping all values as `Scalar` or `Collection` nodes. + */ + createPair(key, value, options = {}) { + const k = this.createNode(key, null, options); + const v = this.createNode(value, null, options); + return new Pair.Pair(k, v); + } + /** + * Removes a value from the document. + * @returns `true` if the item was found and removed. + */ + delete(key) { + return assertCollection(this.contents) ? this.contents.delete(key) : false; + } + /** + * Removes a value from the document. + * @returns `true` if the item was found and removed. + */ + deleteIn(path2) { + if (Collection.isEmptyPath(path2)) { + if (this.contents == null) + return false; + this.contents = null; + return true; } - return agent; - } - _getProxyAgentDispatcher(parsedUrl, proxyUrl) { - let proxyAgent; - if (this._keepAlive) { - proxyAgent = this._proxyAgentDispatcher; + return assertCollection(this.contents) ? this.contents.deleteIn(path2) : false; + } + /** + * Returns item at `key`, or `undefined` if not found. By default unwraps + * scalar values from their surrounding node; to disable set `keepScalar` to + * `true` (collections are always returned intact). + */ + get(key, keepScalar) { + return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : void 0; + } + /** + * Returns item at `path`, or `undefined` if not found. By default unwraps + * scalar values from their surrounding node; to disable set `keepScalar` to + * `true` (collections are always returned intact). + */ + getIn(path2, keepScalar) { + if (Collection.isEmptyPath(path2)) + return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents; + return identity.isCollection(this.contents) ? this.contents.getIn(path2, keepScalar) : void 0; + } + /** + * Checks if the document includes a value with the key `key`. + */ + has(key) { + return identity.isCollection(this.contents) ? this.contents.has(key) : false; + } + /** + * Checks if the document includes a value at `path`. + */ + hasIn(path2) { + if (Collection.isEmptyPath(path2)) + return this.contents !== void 0; + return identity.isCollection(this.contents) ? this.contents.hasIn(path2) : false; + } + /** + * Sets a value in this document. For `!!set`, `value` needs to be a + * boolean to add/remove the item from the set. + */ + set(key, value) { + if (this.contents == null) { + this.contents = Collection.collectionFromPath(this.schema, [key], value); + } else if (assertCollection(this.contents)) { + this.contents.set(key, value); } - // if agent is already assigned use that agent. - if (proxyAgent) { - return proxyAgent; + } + /** + * Sets a value in this document. For `!!set`, `value` needs to be a + * boolean to add/remove the item from the set. + */ + setIn(path2, value) { + if (Collection.isEmptyPath(path2)) { + this.contents = value; + } else if (this.contents == null) { + this.contents = Collection.collectionFromPath(this.schema, Array.from(path2), value); + } else if (assertCollection(this.contents)) { + this.contents.setIn(path2, value); } - const usingSsl = parsedUrl.protocol === 'https:'; - proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, ((proxyUrl.username || proxyUrl.password) && { - token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString('base64')}` - }))); - this._proxyAgentDispatcher = proxyAgent; - 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 - proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { - rejectUnauthorized: false - }); + } + /** + * Change the YAML version and schema used by the document. + * A `null` version disables support for directives, explicit tags, anchors, and aliases. + * It also requires the `schema` option to be given as a `Schema` instance value. + * + * Overrides all previously set schema options. + */ + setSchema(version, options = {}) { + if (typeof version === "number") + version = String(version); + let opt; + switch (version) { + case "1.1": + if (this.directives) + this.directives.yaml.version = "1.1"; + else + this.directives = new directives.Directives({ version: "1.1" }); + opt = { resolveKnownTags: false, schema: "yaml-1.1" }; + break; + case "1.2": + case "next": + if (this.directives) + this.directives.yaml.version = version; + else + this.directives = new directives.Directives({ version }); + opt = { resolveKnownTags: true, schema: "core" }; + break; + case null: + if (this.directives) + delete this.directives; + opt = null; + break; + default: { + const sv = JSON.stringify(version); + throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`); + } } - return proxyAgent; - } - _performExponentialBackoff(retryNumber) { - return __awaiter(this, void 0, void 0, function* () { - retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); - const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); - return new Promise(resolve => setTimeout(() => resolve(), ms)); - }); - } - _processResponse(res, options) { - return __awaiter(this, void 0, void 0, function* () { - return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { - const statusCode = res.message.statusCode || 0; - const response = { - statusCode, - result: null, - headers: {} - }; - // not found leads to null obj returned - if (statusCode === HttpCodes.NotFound) { - resolve(response); - } - // get the result from the body - function dateTimeDeserializer(key, value) { - if (typeof value === 'string') { - const a = new Date(value); - if (!isNaN(a.valueOf())) { - return a; - } - } - return value; - } - let obj; - let contents; - try { - contents = yield res.readBody(); - if (contents && contents.length > 0) { - if (options && options.deserializeDates) { - obj = JSON.parse(contents, dateTimeDeserializer); - } - else { - obj = JSON.parse(contents); - } - response.result = obj; - } - response.headers = res.message.headers; - } - catch (err) { - // Invalid resource (contents not json); leaving result obj null - } - // note that 3xx redirects are handled by the http layer. - if (statusCode > 299) { - let msg; - // if exception/error in body, attempt to get better error - if (obj && obj.message) { - msg = obj.message; - } - else if (contents && contents.length > 0) { - // it may be the case that the exception is in the body message as string - msg = contents; - } - else { - msg = `Failed request: (${statusCode})`; - } - const err = new HttpClientError(msg, statusCode); - err.result = response.result; - reject(err); - } - else { - resolve(response); - } - })); - }); + if (options.schema instanceof Object) + this.schema = options.schema; + else if (opt) + this.schema = new Schema.Schema(Object.assign(opt, options)); + else + throw new Error(`With a null YAML version, the { schema: Schema } option is required`); + } + // json & jsonArg are only used from toJSON() + toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) { + const ctx = { + anchors: /* @__PURE__ */ new Map(), + doc: this, + keep: !json, + mapAsMap: mapAsMap === true, + mapKeyWarned: false, + maxAliasCount: typeof maxAliasCount === "number" ? maxAliasCount : 100 + }; + const res = toJS.toJS(this.contents, jsonArg ?? "", ctx); + if (typeof onAnchor === "function") + for (const { count, res: res2 } of ctx.anchors.values()) + onAnchor(res2, count); + return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res; + } + /** + * A JSON representation of the document `contents`. + * + * @param jsonArg Used by `JSON.stringify` to indicate the array index or + * property name. + */ + toJSON(jsonArg, onAnchor) { + return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor }); + } + /** A YAML representation of the document. */ + toString(options = {}) { + if (this.errors.length > 0) + throw new Error("Document with errors cannot be stringified"); + if ("indent" in options && (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) { + const s = JSON.stringify(options.indent); + throw new Error(`"indent" option must be a positive integer, not ${s}`); + } + return stringifyDocument.stringifyDocument(this, options); + } + }; + function assertCollection(contents) { + if (identity.isCollection(contents)) + return true; + throw new Error("Expected a YAML collection as document contents"); } -} -exports.HttpClient = HttpClient; -const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); -//# sourceMappingURL=index.js.map - -/***/ }), + exports2.Document = Document; + } +}); -/***/ 4988: -/***/ ((__unused_webpack_module, exports) => { +// node_modules/yaml/dist/errors.js +var require_errors = __commonJS({ + "node_modules/yaml/dist/errors.js"(exports2) { + "use strict"; + var YAMLError = class extends Error { + constructor(name, pos, code, message) { + super(); + this.name = name; + this.code = code; + this.message = message; + this.pos = pos; + } + }; + var YAMLParseError = class extends YAMLError { + constructor(pos, code, message) { + super("YAMLParseError", pos, code, message); + } + }; + var YAMLWarning = class extends YAMLError { + constructor(pos, code, message) { + super("YAMLWarning", pos, code, message); + } + }; + var prettifyError = (src, lc) => (error2) => { + if (error2.pos[0] === -1) + return; + error2.linePos = error2.pos.map((pos) => lc.linePos(pos)); + const { line, col } = error2.linePos[0]; + error2.message += ` at line ${line}, column ${col}`; + let ci = col - 1; + let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, ""); + if (ci >= 60 && lineStr.length > 80) { + const trimStart = Math.min(ci - 39, lineStr.length - 79); + lineStr = "\u2026" + lineStr.substring(trimStart); + ci -= trimStart - 1; + } + if (lineStr.length > 80) + lineStr = lineStr.substring(0, 79) + "\u2026"; + if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) { + let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]); + if (prev.length > 80) + prev = prev.substring(0, 79) + "\u2026\n"; + lineStr = prev + lineStr; + } + if (/[^ ]/.test(lineStr)) { + let count = 1; + const end = error2.linePos[1]; + if (end && end.line === line && end.col > col) { + count = Math.max(1, Math.min(end.col - col, 80 - ci)); + } + const pointer = " ".repeat(ci) + "^".repeat(count); + error2.message += `: -"use strict"; +${lineStr} +${pointer} +`; + } + }; + exports2.YAMLError = YAMLError; + exports2.YAMLParseError = YAMLParseError; + exports2.YAMLWarning = YAMLWarning; + exports2.prettifyError = prettifyError; + } +}); -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.checkBypass = exports.getProxyUrl = void 0; -function getProxyUrl(reqUrl) { - const usingSsl = reqUrl.protocol === 'https:'; - if (checkBypass(reqUrl)) { - return undefined; - } - const proxyVar = (() => { - if (usingSsl) { - return process.env['https_proxy'] || process.env['HTTPS_PROXY']; - } - else { - return process.env['http_proxy'] || process.env['HTTP_PROXY']; +// node_modules/yaml/dist/compose/resolve-props.js +var require_resolve_props = __commonJS({ + "node_modules/yaml/dist/compose/resolve-props.js"(exports2) { + "use strict"; + function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) { + let spaceBefore = false; + let atNewline = startOnNewline; + let hasSpace = startOnNewline; + let comment = ""; + let commentSep = ""; + let hasNewline = false; + let reqSpace = false; + let tab = null; + let anchor = null; + let tag = null; + let newlineAfterProp = null; + let comma = null; + let found = null; + let start = null; + for (const token of tokens) { + if (reqSpace) { + if (token.type !== "space" && token.type !== "newline" && token.type !== "comma") + onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space"); + reqSpace = false; } - })(); - if (proxyVar) { - try { - return new DecodedURL(proxyVar); + if (tab) { + if (atNewline && token.type !== "comment" && token.type !== "newline") { + onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation"); + } + tab = null; } - catch (_a) { - if (!proxyVar.startsWith('http://') && !proxyVar.startsWith('https://')) - return new DecodedURL(`http://${proxyVar}`); + switch (token.type) { + case "space": + if (!flow && (indicator !== "doc-start" || next?.type !== "flow-collection") && token.source.includes(" ")) { + tab = token; + } + hasSpace = true; + break; + case "comment": { + if (!hasSpace) + onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters"); + const cb = token.source.substring(1) || " "; + if (!comment) + comment = cb; + else + comment += commentSep + cb; + commentSep = ""; + atNewline = false; + break; + } + case "newline": + if (atNewline) { + if (comment) + comment += token.source; + else if (!found || indicator !== "seq-item-ind") + spaceBefore = true; + } else + commentSep += token.source; + atNewline = true; + hasNewline = true; + if (anchor || tag) + newlineAfterProp = token; + hasSpace = true; + break; + case "anchor": + if (anchor) + onError(token, "MULTIPLE_ANCHORS", "A node can have at most one anchor"); + if (token.source.endsWith(":")) + onError(token.offset + token.source.length - 1, "BAD_ALIAS", "Anchor ending in : is ambiguous", true); + anchor = token; + start ?? (start = token.offset); + atNewline = false; + hasSpace = false; + reqSpace = true; + break; + case "tag": { + if (tag) + onError(token, "MULTIPLE_TAGS", "A node can have at most one tag"); + tag = token; + start ?? (start = token.offset); + atNewline = false; + hasSpace = false; + reqSpace = true; + break; + } + case indicator: + if (anchor || tag) + onError(token, "BAD_PROP_ORDER", `Anchors and tags must be after the ${token.source} indicator`); + if (found) + onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.source} in ${flow ?? "collection"}`); + found = token; + atNewline = indicator === "seq-item-ind" || indicator === "explicit-key-ind"; + hasSpace = false; + break; + case "comma": + if (flow) { + if (comma) + onError(token, "UNEXPECTED_TOKEN", `Unexpected , in ${flow}`); + comma = token; + atNewline = false; + hasSpace = false; + break; + } + // else fallthrough + default: + onError(token, "UNEXPECTED_TOKEN", `Unexpected ${token.type} token`); + atNewline = false; + hasSpace = false; } + } + const last = tokens[tokens.length - 1]; + const end = last ? last.offset + last.source.length : offset; + if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== "")) { + onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space"); + } + if (tab && (atNewline && tab.indent <= parentIndent || next?.type === "block-map" || next?.type === "block-seq")) + onError(tab, "TAB_AS_INDENT", "Tabs are not allowed as indentation"); + return { + comma, + found, + spaceBefore, + comment, + hasNewline, + anchor, + tag, + newlineAfterProp, + end, + start: start ?? end + }; } - else { - return undefined; - } -} -exports.getProxyUrl = getProxyUrl; -function checkBypass(reqUrl) { - if (!reqUrl.hostname) { - return false; - } - const reqHost = reqUrl.hostname; - if (isLoopbackAddress(reqHost)) { - return true; - } - const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; - if (!noProxy) { - return false; - } - // Determine the request port - let reqPort; - if (reqUrl.port) { - reqPort = Number(reqUrl.port); - } - else if (reqUrl.protocol === 'http:') { - reqPort = 80; - } - else if (reqUrl.protocol === 'https:') { - reqPort = 443; - } - // Format the request hostname and hostname with port - const upperReqHosts = [reqUrl.hostname.toUpperCase()]; - if (typeof reqPort === 'number') { - upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); - } - // Compare request host against noproxy - for (const upperNoProxyItem of noProxy - .split(',') - .map(x => x.trim().toUpperCase()) - .filter(x => x)) { - if (upperNoProxyItem === '*' || - upperReqHosts.some(x => x === upperNoProxyItem || - x.endsWith(`.${upperNoProxyItem}`) || - (upperNoProxyItem.startsWith('.') && - x.endsWith(`${upperNoProxyItem}`)))) { + exports2.resolveProps = resolveProps; + } +}); + +// node_modules/yaml/dist/compose/util-contains-newline.js +var require_util_contains_newline = __commonJS({ + "node_modules/yaml/dist/compose/util-contains-newline.js"(exports2) { + "use strict"; + function containsNewline(key) { + if (!key) + return null; + switch (key.type) { + case "alias": + case "scalar": + case "double-quoted-scalar": + case "single-quoted-scalar": + if (key.source.includes("\n")) return true; - } - } - return false; -} -exports.checkBypass = checkBypass; -function isLoopbackAddress(host) { - const hostLower = host.toLowerCase(); - return (hostLower === 'localhost' || - hostLower.startsWith('127.') || - hostLower.startsWith('[::1]') || - hostLower.startsWith('[0:0:0:0:0:0:0:1]')); -} -class DecodedURL extends URL { - constructor(url, base) { - super(url, base); - this._decodedUsername = decodeURIComponent(super.username); - this._decodedPassword = decodeURIComponent(super.password); - } - get username() { - return this._decodedUsername; - } - get password() { - return this._decodedPassword; + if (key.end) { + for (const st of key.end) + if (st.type === "newline") + return true; + } + return false; + case "flow-collection": + for (const it of key.items) { + for (const st of it.start) + if (st.type === "newline") + return true; + if (it.sep) { + for (const st of it.sep) + if (st.type === "newline") + return true; + } + if (containsNewline(it.key) || containsNewline(it.value)) + return true; + } + return false; + default: + return true; + } } -} -//# sourceMappingURL=proxy.js.map - -/***/ }), - -/***/ 5207: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + exports2.containsNewline = containsNewline; + } +}); -"use strict"; +// node_modules/yaml/dist/compose/util-flow-indent-check.js +var require_util_flow_indent_check = __commonJS({ + "node_modules/yaml/dist/compose/util-flow-indent-check.js"(exports2) { + "use strict"; + var utilContainsNewline = require_util_contains_newline(); + function flowIndentCheck(indent, fc, onError) { + if (fc?.type === "flow-collection") { + const end = fc.end[0]; + if (end.indent === indent && (end.source === "]" || end.source === "}") && utilContainsNewline.containsNewline(fc)) { + const msg = "Flow end indicator should be more indented than parent"; + onError(end, "BAD_INDENT", msg, true); + } + } + } + exports2.flowIndentCheck = flowIndentCheck; + } +}); -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; +// node_modules/yaml/dist/compose/util-map-includes.js +var require_util_map_includes = __commonJS({ + "node_modules/yaml/dist/compose/util-map-includes.js"(exports2) { + "use strict"; + var identity = require_identity(); + function mapIncludes(ctx, items, search) { + const { uniqueKeys } = ctx.options; + if (uniqueKeys === false) + return false; + const isEqual = typeof uniqueKeys === "function" ? uniqueKeys : (a, b) => a === b || identity.isScalar(a) && identity.isScalar(b) && a.value === b.value; + return items.some((pair) => isEqual(pair.key, search)); + } + exports2.mapIncludes = mapIncludes; + } }); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -var _a; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getCmdPath = exports.tryGetExecutablePath = exports.isRooted = exports.isDirectory = exports.exists = exports.READONLY = exports.UV_FS_O_EXLOCK = exports.IS_WINDOWS = exports.unlink = exports.symlink = exports.stat = exports.rmdir = exports.rm = exports.rename = exports.readlink = exports.readdir = exports.open = exports.mkdir = exports.lstat = exports.copyFile = exports.chmod = void 0; -const fs = __importStar(__nccwpck_require__(9896)); -const path = __importStar(__nccwpck_require__(6928)); -_a = fs.promises -// export const {open} = 'fs' -, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.open = _a.open, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rm = _a.rm, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink; -// export const {open} = 'fs' -exports.IS_WINDOWS = process.platform === 'win32'; -// See https://github.com/nodejs/node/blob/d0153aee367422d0858105abec186da4dff0a0c5/deps/uv/include/uv/win.h#L691 -exports.UV_FS_O_EXLOCK = 0x10000000; -exports.READONLY = fs.constants.O_RDONLY; -function exists(fsPath) { - return __awaiter(this, void 0, void 0, function* () { - try { - yield exports.stat(fsPath); - } - catch (err) { - if (err.code === 'ENOENT') { - return false; + +// node_modules/yaml/dist/compose/resolve-block-map.js +var require_resolve_block_map = __commonJS({ + "node_modules/yaml/dist/compose/resolve-block-map.js"(exports2) { + "use strict"; + var Pair = require_Pair(); + var YAMLMap = require_YAMLMap(); + var resolveProps = require_resolve_props(); + var utilContainsNewline = require_util_contains_newline(); + var utilFlowIndentCheck = require_util_flow_indent_check(); + var utilMapIncludes = require_util_map_includes(); + var startColMsg = "All mapping items must start at the same column"; + function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) { + const NodeClass = tag?.nodeClass ?? YAMLMap.YAMLMap; + const map = new NodeClass(ctx.schema); + if (ctx.atRoot) + ctx.atRoot = false; + let offset = bm.offset; + let commentEnd = null; + for (const collItem of bm.items) { + const { start, key, sep, value } = collItem; + const keyProps = resolveProps.resolveProps(start, { + indicator: "explicit-key-ind", + next: key ?? sep?.[0], + offset, + onError, + parentIndent: bm.indent, + startOnNewline: true + }); + const implicitKey = !keyProps.found; + if (implicitKey) { + if (key) { + if (key.type === "block-seq") + onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key"); + else if ("indent" in key && key.indent !== bm.indent) + onError(offset, "BAD_INDENT", startColMsg); + } + if (!keyProps.anchor && !keyProps.tag && !sep) { + commentEnd = keyProps.end; + if (keyProps.comment) { + if (map.comment) + map.comment += "\n" + keyProps.comment; + else + map.comment = keyProps.comment; } - throw err; + continue; + } + if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key)) { + onError(key ?? start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line"); + } + } else if (keyProps.found?.indent !== bm.indent) { + onError(offset, "BAD_INDENT", startColMsg); } - return true; - }); -} -exports.exists = exists; -function isDirectory(fsPath, useStat = false) { - return __awaiter(this, void 0, void 0, function* () { - const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath); - return stats.isDirectory(); - }); -} -exports.isDirectory = isDirectory; -/** - * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like: - * \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases). - */ -function isRooted(p) { - p = normalizeSeparators(p); - if (!p) { - throw new Error('isRooted() parameter "p" cannot be empty'); - } - if (exports.IS_WINDOWS) { - return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello - ); // e.g. C: or C:\hello + ctx.atKey = true; + const keyStart = keyProps.end; + const keyNode = key ? composeNode(ctx, key, keyProps, onError) : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError); + if (ctx.schema.compat) + utilFlowIndentCheck.flowIndentCheck(bm.indent, key, onError); + ctx.atKey = false; + if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode)) + onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique"); + const valueProps = resolveProps.resolveProps(sep ?? [], { + indicator: "map-value-ind", + next: value, + offset: keyNode.range[2], + onError, + parentIndent: bm.indent, + startOnNewline: !key || key.type === "block-scalar" + }); + offset = valueProps.end; + if (valueProps.found) { + if (implicitKey) { + if (value?.type === "block-map" && !valueProps.hasNewline) + onError(offset, "BLOCK_AS_IMPLICIT_KEY", "Nested mappings are not allowed in compact mappings"); + if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024) + onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key"); + } + const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep, null, valueProps, onError); + if (ctx.schema.compat) + utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError); + offset = valueNode.range[2]; + const pair = new Pair.Pair(keyNode, valueNode); + if (ctx.options.keepSourceTokens) + pair.srcToken = collItem; + map.items.push(pair); + } else { + if (implicitKey) + onError(keyNode.range, "MISSING_CHAR", "Implicit map keys need to be followed by map values"); + if (valueProps.comment) { + if (keyNode.comment) + keyNode.comment += "\n" + valueProps.comment; + else + keyNode.comment = valueProps.comment; + } + const pair = new Pair.Pair(keyNode); + if (ctx.options.keepSourceTokens) + pair.srcToken = collItem; + map.items.push(pair); + } + } + if (commentEnd && commentEnd < offset) + onError(commentEnd, "IMPOSSIBLE", "Map comment with trailing content"); + map.range = [bm.offset, offset, commentEnd ?? offset]; + return map; } - return p.startsWith('/'); -} -exports.isRooted = isRooted; -/** - * Best effort attempt to determine whether a file exists and is executable. - * @param filePath file path to check - * @param extensions additional file extensions to try - * @return if file exists and is executable, returns the file path. otherwise empty string. - */ -function tryGetExecutablePath(filePath, extensions) { - return __awaiter(this, void 0, void 0, function* () { - let stats = undefined; - try { - // test file exists - stats = yield exports.stat(filePath); + exports2.resolveBlockMap = resolveBlockMap; + } +}); + +// node_modules/yaml/dist/compose/resolve-block-seq.js +var require_resolve_block_seq = __commonJS({ + "node_modules/yaml/dist/compose/resolve-block-seq.js"(exports2) { + "use strict"; + var YAMLSeq = require_YAMLSeq(); + var resolveProps = require_resolve_props(); + var utilFlowIndentCheck = require_util_flow_indent_check(); + function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) { + const NodeClass = tag?.nodeClass ?? YAMLSeq.YAMLSeq; + const seq = new NodeClass(ctx.schema); + if (ctx.atRoot) + ctx.atRoot = false; + if (ctx.atKey) + ctx.atKey = false; + let offset = bs.offset; + let commentEnd = null; + for (const { start, value } of bs.items) { + const props = resolveProps.resolveProps(start, { + indicator: "seq-item-ind", + next: value, + offset, + onError, + parentIndent: bs.indent, + startOnNewline: true + }); + if (!props.found) { + if (props.anchor || props.tag || value) { + if (value && value.type === "block-seq") + onError(props.end, "BAD_INDENT", "All sequence items must start at the same column"); + else + onError(offset, "MISSING_CHAR", "Sequence item without - indicator"); + } else { + commentEnd = props.end; + if (props.comment) + seq.comment = props.comment; + continue; + } } - catch (err) { - if (err.code !== 'ENOENT') { - // eslint-disable-next-line no-console - console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + const node = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError); + if (ctx.schema.compat) + utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError); + offset = node.range[2]; + seq.items.push(node); + } + seq.range = [bs.offset, offset, commentEnd ?? offset]; + return seq; + } + exports2.resolveBlockSeq = resolveBlockSeq; + } +}); + +// node_modules/yaml/dist/compose/resolve-end.js +var require_resolve_end = __commonJS({ + "node_modules/yaml/dist/compose/resolve-end.js"(exports2) { + "use strict"; + function resolveEnd(end, offset, reqSpace, onError) { + let comment = ""; + if (end) { + let hasSpace = false; + let sep = ""; + for (const token of end) { + const { source, type } = token; + switch (type) { + case "space": + hasSpace = true; + break; + case "comment": { + if (reqSpace && !hasSpace) + onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters"); + const cb = source.substring(1) || " "; + if (!comment) + comment = cb; + else + comment += sep + cb; + sep = ""; + break; } + case "newline": + if (comment) + sep += source; + hasSpace = true; + break; + default: + onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`); + } + offset += source.length; } - if (stats && stats.isFile()) { - if (exports.IS_WINDOWS) { - // on Windows, test for valid extension - const upperExt = path.extname(filePath).toUpperCase(); - if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) { - return filePath; - } - } - else { - if (isUnixExecutable(stats)) { - return filePath; - } + } + return { comment, offset }; + } + exports2.resolveEnd = resolveEnd; + } +}); + +// node_modules/yaml/dist/compose/resolve-flow-collection.js +var require_resolve_flow_collection = __commonJS({ + "node_modules/yaml/dist/compose/resolve-flow-collection.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Pair = require_Pair(); + var YAMLMap = require_YAMLMap(); + var YAMLSeq = require_YAMLSeq(); + var resolveEnd = require_resolve_end(); + var resolveProps = require_resolve_props(); + var utilContainsNewline = require_util_contains_newline(); + var utilMapIncludes = require_util_map_includes(); + var blockMsg = "Block collections are not allowed within flow collections"; + var isBlock = (token) => token && (token.type === "block-map" || token.type === "block-seq"); + function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) { + const isMap = fc.start.source === "{"; + const fcName = isMap ? "flow map" : "flow sequence"; + const NodeClass = tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq); + const coll = new NodeClass(ctx.schema); + coll.flow = true; + const atRoot = ctx.atRoot; + if (atRoot) + ctx.atRoot = false; + if (ctx.atKey) + ctx.atKey = false; + let offset = fc.offset + fc.start.source.length; + for (let i = 0; i < fc.items.length; ++i) { + const collItem = fc.items[i]; + const { start, key, sep, value } = collItem; + const props = resolveProps.resolveProps(start, { + flow: fcName, + indicator: "explicit-key-ind", + next: key ?? sep?.[0], + offset, + onError, + parentIndent: fc.indent, + startOnNewline: false + }); + if (!props.found) { + if (!props.anchor && !props.tag && !sep && !value) { + if (i === 0 && props.comma) + onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`); + else if (i < fc.items.length - 1) + onError(props.start, "UNEXPECTED_TOKEN", `Unexpected empty item in ${fcName}`); + if (props.comment) { + if (coll.comment) + coll.comment += "\n" + props.comment; + else + coll.comment = props.comment; } + offset = props.end; + continue; + } + if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key)) + onError( + key, + // checked by containsNewline() + "MULTILINE_IMPLICIT_KEY", + "Implicit keys of flow sequence pairs need to be on a single line" + ); } - // try each extension - const originalFilePath = filePath; - for (const extension of extensions) { - filePath = originalFilePath + extension; - stats = undefined; - try { - stats = yield exports.stat(filePath); + if (i === 0) { + if (props.comma) + onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`); + } else { + if (!props.comma) + onError(props.start, "MISSING_CHAR", `Missing , between ${fcName} items`); + if (props.comment) { + let prevItemComment = ""; + loop: for (const st of start) { + switch (st.type) { + case "comma": + case "space": + break; + case "comment": + prevItemComment = st.source.substring(1); + break loop; + default: + break loop; + } } - catch (err) { - if (err.code !== 'ENOENT') { - // eslint-disable-next-line no-console - console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); - } + if (prevItemComment) { + let prev = coll.items[coll.items.length - 1]; + if (identity.isPair(prev)) + prev = prev.value ?? prev.key; + if (prev.comment) + prev.comment += "\n" + prevItemComment; + else + prev.comment = prevItemComment; + props.comment = props.comment.substring(prevItemComment.length + 1); } - if (stats && stats.isFile()) { - if (exports.IS_WINDOWS) { - // preserve the case of the actual file (since an extension was appended) - try { - const directory = path.dirname(filePath); - const upperName = path.basename(filePath).toUpperCase(); - for (const actualName of yield exports.readdir(directory)) { - if (upperName === actualName.toUpperCase()) { - filePath = path.join(directory, actualName); - break; - } - } - } - catch (err) { - // eslint-disable-next-line no-console - console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); - } - return filePath; - } - else { - if (isUnixExecutable(stats)) { - return filePath; - } + } + } + if (!isMap && !sep && !props.found) { + const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError); + coll.items.push(valueNode); + offset = valueNode.range[2]; + if (isBlock(value)) + onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg); + } else { + ctx.atKey = true; + const keyStart = props.end; + const keyNode = key ? composeNode(ctx, key, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError); + if (isBlock(key)) + onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg); + ctx.atKey = false; + const valueProps = resolveProps.resolveProps(sep ?? [], { + flow: fcName, + indicator: "map-value-ind", + next: value, + offset: keyNode.range[2], + onError, + parentIndent: fc.indent, + startOnNewline: false + }); + if (valueProps.found) { + if (!isMap && !props.found && ctx.options.strict) { + if (sep) + for (const st of sep) { + if (st === valueProps.found) + break; + if (st.type === "newline") { + onError(st, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line"); + break; + } } + if (props.start < valueProps.found.offset - 1024) + onError(valueProps.found, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit flow sequence key"); } + } else if (value) { + if ("source" in value && value.source && value.source[0] === ":") + onError(value, "MISSING_CHAR", `Missing space after : in ${fcName}`); + else + onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`); + } + const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null; + if (valueNode) { + if (isBlock(value)) + onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg); + } else if (valueProps.comment) { + if (keyNode.comment) + keyNode.comment += "\n" + valueProps.comment; + else + keyNode.comment = valueProps.comment; + } + const pair = new Pair.Pair(keyNode, valueNode); + if (ctx.options.keepSourceTokens) + pair.srcToken = collItem; + if (isMap) { + const map = coll; + if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode)) + onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique"); + map.items.push(pair); + } else { + const map = new YAMLMap.YAMLMap(ctx.schema); + map.flow = true; + map.items.push(pair); + const endRange = (valueNode ?? keyNode).range; + map.range = [keyNode.range[0], endRange[1], endRange[2]]; + coll.items.push(map); + } + offset = valueNode ? valueNode.range[2] : valueProps.end; } - return ''; - }); -} -exports.tryGetExecutablePath = tryGetExecutablePath; -function normalizeSeparators(p) { - p = p || ''; - if (exports.IS_WINDOWS) { - // convert slashes on Windows - p = p.replace(/\//g, '\\'); - // remove redundant slashes - return p.replace(/\\\\+/g, '\\'); - } - // remove redundant slashes - return p.replace(/\/\/+/g, '/'); -} -// on Mac/Linux, test the execute bit -// R W X R W X R W X -// 256 128 64 32 16 8 4 2 1 -function isUnixExecutable(stats) { - return ((stats.mode & 1) > 0 || - ((stats.mode & 8) > 0 && stats.gid === process.getgid()) || - ((stats.mode & 64) > 0 && stats.uid === process.getuid())); -} -// Get the path of cmd.exe in windows -function getCmdPath() { - var _a; - return (_a = process.env['COMSPEC']) !== null && _a !== void 0 ? _a : `cmd.exe`; -} -exports.getCmdPath = getCmdPath; -//# sourceMappingURL=io-util.js.map - -/***/ }), - -/***/ 4994: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.findInPath = exports.which = exports.mkdirP = exports.rmRF = exports.mv = exports.cp = void 0; -const assert_1 = __nccwpck_require__(2613); -const path = __importStar(__nccwpck_require__(6928)); -const ioUtil = __importStar(__nccwpck_require__(5207)); -/** - * Copies a file or folder. - * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js - * - * @param source source path - * @param dest destination path - * @param options optional. See CopyOptions. - */ -function cp(source, dest, options = {}) { - return __awaiter(this, void 0, void 0, function* () { - const { force, recursive, copySourceDirectory } = readCopyOptions(options); - const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; - // Dest is an existing file, but not forcing - if (destStat && destStat.isFile() && !force) { - return; + } + const expectedEnd = isMap ? "}" : "]"; + const [ce, ...ee] = fc.end; + let cePos = offset; + if (ce && ce.source === expectedEnd) + cePos = ce.offset + ce.source.length; + else { + const name = fcName[0].toUpperCase() + fcName.substring(1); + const msg = atRoot ? `${name} must end with a ${expectedEnd}` : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`; + onError(offset, atRoot ? "MISSING_CHAR" : "BAD_INDENT", msg); + if (ce && ce.source.length !== 1) + ee.unshift(ce); + } + if (ee.length > 0) { + const end = resolveEnd.resolveEnd(ee, cePos, ctx.options.strict, onError); + if (end.comment) { + if (coll.comment) + coll.comment += "\n" + end.comment; + else + coll.comment = end.comment; } - // If dest is an existing directory, should copy inside. - const newDest = destStat && destStat.isDirectory() && copySourceDirectory - ? path.join(dest, path.basename(source)) - : dest; - if (!(yield ioUtil.exists(source))) { - throw new Error(`no such file or directory: ${source}`); + coll.range = [fc.offset, cePos, end.offset]; + } else { + coll.range = [fc.offset, cePos, cePos]; + } + return coll; + } + exports2.resolveFlowCollection = resolveFlowCollection; + } +}); + +// node_modules/yaml/dist/compose/compose-collection.js +var require_compose_collection = __commonJS({ + "node_modules/yaml/dist/compose/compose-collection.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Scalar = require_Scalar(); + var YAMLMap = require_YAMLMap(); + var YAMLSeq = require_YAMLSeq(); + var resolveBlockMap = require_resolve_block_map(); + var resolveBlockSeq = require_resolve_block_seq(); + var resolveFlowCollection = require_resolve_flow_collection(); + function resolveCollection(CN, ctx, token, onError, tagName, tag) { + const coll = token.type === "block-map" ? resolveBlockMap.resolveBlockMap(CN, ctx, token, onError, tag) : token.type === "block-seq" ? resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError, tag) : resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError, tag); + const Coll = coll.constructor; + if (tagName === "!" || tagName === Coll.tagName) { + coll.tag = Coll.tagName; + return coll; + } + if (tagName) + coll.tag = tagName; + return coll; + } + function composeCollection(CN, ctx, token, props, onError) { + const tagToken = props.tag; + const tagName = !tagToken ? null : ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)); + if (token.type === "block-seq") { + const { anchor, newlineAfterProp: nl } = props; + const lastProp = anchor && tagToken ? anchor.offset > tagToken.offset ? anchor : tagToken : anchor ?? tagToken; + if (lastProp && (!nl || nl.offset < lastProp.offset)) { + const message = "Missing newline after block sequence props"; + onError(lastProp, "MISSING_CHAR", message); } - const sourceStat = yield ioUtil.stat(source); - if (sourceStat.isDirectory()) { - if (!recursive) { - throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); - } - else { - yield cpDirRecursive(source, newDest, 0, force); - } + } + const expType = token.type === "block-map" ? "map" : token.type === "block-seq" ? "seq" : token.start.source === "{" ? "map" : "seq"; + if (!tagToken || !tagName || tagName === "!" || tagName === YAMLMap.YAMLMap.tagName && expType === "map" || tagName === YAMLSeq.YAMLSeq.tagName && expType === "seq") { + return resolveCollection(CN, ctx, token, onError, tagName); + } + let tag = ctx.schema.tags.find((t) => t.tag === tagName && t.collection === expType); + if (!tag) { + const kt = ctx.schema.knownTags[tagName]; + if (kt && kt.collection === expType) { + ctx.schema.tags.push(Object.assign({}, kt, { default: false })); + tag = kt; + } else { + if (kt) { + onError(tagToken, "BAD_COLLECTION_TYPE", `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? "scalar"}`, true); + } else { + onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, true); + } + return resolveCollection(CN, ctx, token, onError, tagName); } - else { - if (path.relative(source, newDest) === '') { - // a file cannot be copied to itself - throw new Error(`'${newDest}' and '${source}' are the same file`); - } - yield copyFile(source, newDest, force); + } + const coll = resolveCollection(CN, ctx, token, onError, tagName, tag); + const res = tag.resolve?.(coll, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg), ctx.options) ?? coll; + const node = identity.isNode(res) ? res : new Scalar.Scalar(res); + node.range = coll.range; + node.tag = tagName; + if (tag?.format) + node.format = tag.format; + return node; + } + exports2.composeCollection = composeCollection; + } +}); + +// node_modules/yaml/dist/compose/resolve-block-scalar.js +var require_resolve_block_scalar = __commonJS({ + "node_modules/yaml/dist/compose/resolve-block-scalar.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + function resolveBlockScalar(ctx, scalar, onError) { + const start = scalar.offset; + const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError); + if (!header) + return { value: "", type: null, comment: "", range: [start, start, start] }; + const type = header.mode === ">" ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL; + const lines = scalar.source ? splitLines(scalar.source) : []; + let chompStart = lines.length; + for (let i = lines.length - 1; i >= 0; --i) { + const content = lines[i][1]; + if (content === "" || content === "\r") + chompStart = i; + else + break; + } + if (chompStart === 0) { + const value2 = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : ""; + let end2 = start + header.length; + if (scalar.source) + end2 += scalar.source.length; + return { value: value2, type, comment: header.comment, range: [start, end2, end2] }; + } + let trimIndent = scalar.indent + header.indent; + let offset = scalar.offset + header.length; + let contentStart = 0; + for (let i = 0; i < chompStart; ++i) { + const [indent, content] = lines[i]; + if (content === "" || content === "\r") { + if (header.indent === 0 && indent.length > trimIndent) + trimIndent = indent.length; + } else { + if (indent.length < trimIndent) { + const message = "Block scalars with more-indented leading empty lines must use an explicit indentation indicator"; + onError(offset + indent.length, "MISSING_CHAR", message); + } + if (header.indent === 0) + trimIndent = indent.length; + contentStart = i; + if (trimIndent === 0 && !ctx.atRoot) { + const message = "Block scalar values in collections must be indented"; + onError(offset, "BAD_INDENT", message); + } + break; } - }); -} -exports.cp = cp; -/** - * Moves a path. - * - * @param source source path - * @param dest destination path - * @param options optional. See MoveOptions. - */ -function mv(source, dest, options = {}) { - return __awaiter(this, void 0, void 0, function* () { - if (yield ioUtil.exists(dest)) { - let destExists = true; - if (yield ioUtil.isDirectory(dest)) { - // If dest is directory copy src into dest - dest = path.join(dest, path.basename(source)); - destExists = yield ioUtil.exists(dest); - } - if (destExists) { - if (options.force == null || options.force) { - yield rmRF(dest); - } - else { - throw new Error('Destination already exists'); - } - } + offset += indent.length + content.length + 1; + } + for (let i = lines.length - 1; i >= chompStart; --i) { + if (lines[i][0].length > trimIndent) + chompStart = i + 1; + } + let value = ""; + let sep = ""; + let prevMoreIndented = false; + for (let i = 0; i < contentStart; ++i) + value += lines[i][0].slice(trimIndent) + "\n"; + for (let i = contentStart; i < chompStart; ++i) { + let [indent, content] = lines[i]; + offset += indent.length + content.length + 1; + const crlf = content[content.length - 1] === "\r"; + if (crlf) + content = content.slice(0, -1); + if (content && indent.length < trimIndent) { + const src = header.indent ? "explicit indentation indicator" : "first line"; + const message = `Block scalar lines must not be less indented than their ${src}`; + onError(offset - content.length - (crlf ? 2 : 1), "BAD_INDENT", message); + indent = ""; } - yield mkdirP(path.dirname(dest)); - yield ioUtil.rename(source, dest); - }); -} -exports.mv = mv; -/** - * Remove a path recursively with force - * - * @param inputPath path to remove - */ -function rmRF(inputPath) { - return __awaiter(this, void 0, void 0, function* () { - if (ioUtil.IS_WINDOWS) { - // Check for invalid characters - // https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file - if (/[*"<>|]/.test(inputPath)) { - throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows'); + if (type === Scalar.Scalar.BLOCK_LITERAL) { + value += sep + indent.slice(trimIndent) + content; + sep = "\n"; + } else if (indent.length > trimIndent || content[0] === " ") { + if (sep === " ") + sep = "\n"; + else if (!prevMoreIndented && sep === "\n") + sep = "\n\n"; + value += sep + indent.slice(trimIndent) + content; + sep = "\n"; + prevMoreIndented = true; + } else if (content === "") { + if (sep === "\n") + value += "\n"; + else + sep = "\n"; + } else { + value += sep + content; + sep = " "; + prevMoreIndented = false; + } + } + switch (header.chomp) { + case "-": + break; + case "+": + for (let i = chompStart; i < lines.length; ++i) + value += "\n" + lines[i][0].slice(trimIndent); + if (value[value.length - 1] !== "\n") + value += "\n"; + break; + default: + value += "\n"; + } + const end = start + header.length + scalar.source.length; + return { value, type, comment: header.comment, range: [start, end, end] }; + } + function parseBlockScalarHeader({ offset, props }, strict, onError) { + if (props[0].type !== "block-scalar-header") { + onError(props[0], "IMPOSSIBLE", "Block scalar header not found"); + return null; + } + const { source } = props[0]; + const mode = source[0]; + let indent = 0; + let chomp = ""; + let error2 = -1; + for (let i = 1; i < source.length; ++i) { + const ch = source[i]; + if (!chomp && (ch === "-" || ch === "+")) + chomp = ch; + else { + const n = Number(ch); + if (!indent && n) + indent = n; + else if (error2 === -1) + error2 = offset + i; + } + } + if (error2 !== -1) + onError(error2, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`); + let hasSpace = false; + let comment = ""; + let length = source.length; + for (let i = 1; i < props.length; ++i) { + const token = props[i]; + switch (token.type) { + case "space": + hasSpace = true; + // fallthrough + case "newline": + length += token.source.length; + break; + case "comment": + if (strict && !hasSpace) { + const message = "Comments must be separated from other tokens by white space characters"; + onError(token, "MISSING_CHAR", message); } + length += token.source.length; + comment = token.source.substring(1); + break; + case "error": + onError(token, "UNEXPECTED_TOKEN", token.message); + length += token.source.length; + break; + /* istanbul ignore next should not happen */ + default: { + const message = `Unexpected token in block scalar header: ${token.type}`; + onError(token, "UNEXPECTED_TOKEN", message); + const ts = token.source; + if (ts && typeof ts === "string") + length += ts.length; + } } - try { - // note if path does not exist, error is silent - yield ioUtil.rm(inputPath, { - force: true, - maxRetries: 3, - recursive: true, - retryDelay: 300 - }); + } + return { mode, indent, chomp, comment, length }; + } + function splitLines(source) { + const split = source.split(/\n( *)/); + const first = split[0]; + const m = first.match(/^( *)/); + const line0 = m?.[1] ? [m[1], first.slice(m[1].length)] : ["", first]; + const lines = [line0]; + for (let i = 1; i < split.length; i += 2) + lines.push([split[i], split[i + 1]]); + return lines; + } + exports2.resolveBlockScalar = resolveBlockScalar; + } +}); + +// node_modules/yaml/dist/compose/resolve-flow-scalar.js +var require_resolve_flow_scalar = __commonJS({ + "node_modules/yaml/dist/compose/resolve-flow-scalar.js"(exports2) { + "use strict"; + var Scalar = require_Scalar(); + var resolveEnd = require_resolve_end(); + function resolveFlowScalar(scalar, strict, onError) { + const { offset, type, source, end } = scalar; + let _type; + let value; + const _onError = (rel, code, msg) => onError(offset + rel, code, msg); + switch (type) { + case "scalar": + _type = Scalar.Scalar.PLAIN; + value = plainValue(source, _onError); + break; + case "single-quoted-scalar": + _type = Scalar.Scalar.QUOTE_SINGLE; + value = singleQuotedValue(source, _onError); + break; + case "double-quoted-scalar": + _type = Scalar.Scalar.QUOTE_DOUBLE; + value = doubleQuotedValue(source, _onError); + break; + /* istanbul ignore next should not happen */ + default: + onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`); + return { + value: "", + type: null, + comment: "", + range: [offset, offset + source.length, offset + source.length] + }; + } + const valueEnd = offset + source.length; + const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError); + return { + value, + type: _type, + comment: re.comment, + range: [offset, valueEnd, re.offset] + }; + } + function plainValue(source, onError) { + let badChar = ""; + switch (source[0]) { + /* istanbul ignore next should not happen */ + case " ": + badChar = "a tab character"; + break; + case ",": + badChar = "flow indicator character ,"; + break; + case "%": + badChar = "directive indicator character %"; + break; + case "|": + case ">": { + badChar = `block scalar indicator ${source[0]}`; + break; + } + case "@": + case "`": { + badChar = `reserved character ${source[0]}`; + break; + } + } + if (badChar) + onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`); + return foldLines(source); + } + function singleQuotedValue(source, onError) { + if (source[source.length - 1] !== "'" || source.length === 1) + onError(source.length, "MISSING_CHAR", "Missing closing 'quote"); + return foldLines(source.slice(1, -1)).replace(/''/g, "'"); + } + function foldLines(source) { + let first, line; + try { + first = new RegExp("(.*?)(? wsStart ? source.slice(wsStart, i + 1) : ch; + } else { + res += ch; } - }); -} -exports.rmRF = rmRF; -/** - * Make a directory. Creates the full path with folders in between - * Will throw if it fails - * - * @param fsPath path to create - * @returns Promise - */ -function mkdirP(fsPath) { - return __awaiter(this, void 0, void 0, function* () { - assert_1.ok(fsPath, 'a path argument must be provided'); - yield ioUtil.mkdir(fsPath, { recursive: true }); - }); -} -exports.mkdirP = mkdirP; -/** - * Returns path of a tool had the tool actually been invoked. Resolves via paths. - * If you check and the tool does not exist, it will throw. - * - * @param tool name of the tool - * @param check whether to check if tool exists - * @returns Promise path to tool - */ -function which(tool, check) { - return __awaiter(this, void 0, void 0, function* () { - if (!tool) { - throw new Error("parameter 'tool' is required"); - } - // recursive when check=true - if (check) { - const result = yield which(tool, false); - if (!result) { - if (ioUtil.IS_WINDOWS) { - throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); - } - else { - throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); - } - } - return result; - } - const matches = yield findInPath(tool); - if (matches && matches.length > 0) { - return matches[0]; - } - return ''; - }); -} -exports.which = which; -/** - * Returns a list of all occurrences of the given tool on the system path. - * - * @returns Promise the paths of the tool - */ -function findInPath(tool) { - return __awaiter(this, void 0, void 0, function* () { - if (!tool) { - throw new Error("parameter 'tool' is required"); - } - // build the list of extensions to try - const extensions = []; - if (ioUtil.IS_WINDOWS && process.env['PATHEXT']) { - for (const extension of process.env['PATHEXT'].split(path.delimiter)) { - if (extension) { - extensions.push(extension); - } - } - } - // if it's rooted, return it if exists. otherwise return empty. - if (ioUtil.isRooted(tool)) { - const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); - if (filePath) { - return [filePath]; - } - return []; - } - // if any path separators, return empty - if (tool.includes(path.sep)) { - return []; - } - // build the list of directories - // - // Note, technically "where" checks the current directory on Windows. From a toolkit perspective, - // it feels like we should not do this. Checking the current directory seems like more of a use - // case of a shell, and the which() function exposed by the toolkit should strive for consistency - // across platforms. - const directories = []; - if (process.env.PATH) { - for (const p of process.env.PATH.split(path.delimiter)) { - if (p) { - directories.push(p); - } - } - } - // find all matches - const matches = []; - for (const directory of directories) { - const filePath = yield ioUtil.tryGetExecutablePath(path.join(directory, tool), extensions); - if (filePath) { - matches.push(filePath); - } - } - return matches; - }); -} -exports.findInPath = findInPath; -function readCopyOptions(options) { - const force = options.force == null ? true : options.force; - const recursive = Boolean(options.recursive); - const copySourceDirectory = options.copySourceDirectory == null - ? true - : Boolean(options.copySourceDirectory); - return { force, recursive, copySourceDirectory }; -} -function cpDirRecursive(sourceDir, destDir, currentDepth, force) { - return __awaiter(this, void 0, void 0, function* () { - // Ensure there is not a run away recursive copy - if (currentDepth >= 255) - return; - currentDepth++; - yield mkdirP(destDir); - const files = yield ioUtil.readdir(sourceDir); - for (const fileName of files) { - const srcFile = `${sourceDir}/${fileName}`; - const destFile = `${destDir}/${fileName}`; - const srcFileStat = yield ioUtil.lstat(srcFile); - if (srcFileStat.isDirectory()) { - // Recurse - yield cpDirRecursive(srcFile, destFile, currentDepth, force); - } - else { - yield copyFile(srcFile, destFile, force); - } - } - // Change the mode for the newly created directory - yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); - }); -} -// Buffered file copy -function copyFile(srcFile, destFile, force) { - return __awaiter(this, void 0, void 0, function* () { - if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { - // unlink/re-link it - try { - yield ioUtil.lstat(destFile); - yield ioUtil.unlink(destFile); - } - catch (e) { - // Try to override file permission - if (e.code === 'EPERM') { - yield ioUtil.chmod(destFile, '0666'); - yield ioUtil.unlink(destFile); - } - // other errors = it doesn't exist, no work to do - } - // Copy over symlink - const symlinkFull = yield ioUtil.readlink(srcFile); - yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null); - } - else if (!(yield ioUtil.exists(destFile)) || force) { - yield ioUtil.copyFile(srcFile, destFile); - } - }); -} -//# sourceMappingURL=io.js.map - -/***/ }), - -/***/ 770: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -module.exports = __nccwpck_require__(218); - - -/***/ }), - -/***/ 218: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var net = __nccwpck_require__(9278); -var tls = __nccwpck_require__(4756); -var http = __nccwpck_require__(8611); -var https = __nccwpck_require__(5692); -var events = __nccwpck_require__(4434); -var assert = __nccwpck_require__(2613); -var util = __nccwpck_require__(9023); - - -exports.httpOverHttp = httpOverHttp; -exports.httpsOverHttp = httpsOverHttp; -exports.httpOverHttps = httpOverHttps; -exports.httpsOverHttps = httpsOverHttps; - - -function httpOverHttp(options) { - var agent = new TunnelingAgent(options); - agent.request = http.request; - return agent; -} - -function httpsOverHttp(options) { - var agent = new TunnelingAgent(options); - agent.request = http.request; - agent.createSocket = createSecureSocket; - agent.defaultPort = 443; - return agent; -} - -function httpOverHttps(options) { - var agent = new TunnelingAgent(options); - agent.request = https.request; - return agent; -} - -function httpsOverHttps(options) { - var agent = new TunnelingAgent(options); - agent.request = https.request; - agent.createSocket = createSecureSocket; - agent.defaultPort = 443; - return agent; -} - - -function TunnelingAgent(options) { - var self = this; - self.options = options || {}; - self.proxyOptions = self.options.proxy || {}; - self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; - self.requests = []; - self.sockets = []; - - self.on('free', function onFree(socket, host, port, localAddress) { - var options = toOptions(host, port, localAddress); - for (var i = 0, len = self.requests.length; i < len; ++i) { - var pending = self.requests[i]; - if (pending.host === options.host && pending.port === options.port) { - // Detect the request to connect same origin server, - // reuse the connection. - self.requests.splice(i, 1); - pending.request.onSocket(socket); - return; } + if (source[source.length - 1] !== '"' || source.length === 1) + onError(source.length, "MISSING_CHAR", 'Missing closing "quote'); + return res; } - socket.destroy(); - self.removeSocket(socket); - }); -} -util.inherits(TunnelingAgent, events.EventEmitter); - -TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { - var self = this; - var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); - - if (self.sockets.length >= this.maxSockets) { - // We are over limit so we'll add it to the queue. - self.requests.push(options); - return; - } - - // If we are under maxSockets create a new one. - self.createSocket(options, function(socket) { - socket.on('free', onFree); - socket.on('close', onCloseOrRemove); - socket.on('agentRemove', onCloseOrRemove); - req.onSocket(socket); - - function onFree() { - self.emit('free', socket, options); - } - - function onCloseOrRemove(err) { - self.removeSocket(socket); - socket.removeListener('free', onFree); - socket.removeListener('close', onCloseOrRemove); - socket.removeListener('agentRemove', onCloseOrRemove); - } - }); -}; - -TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { - var self = this; - var placeholder = {}; - self.sockets.push(placeholder); - - var connectOptions = mergeOptions({}, self.proxyOptions, { - method: 'CONNECT', - path: options.host + ':' + options.port, - agent: false, - headers: { - host: options.host + ':' + options.port + function foldNewline(source, offset) { + let fold = ""; + let ch = source[offset + 1]; + while (ch === " " || ch === " " || ch === "\n" || ch === "\r") { + if (ch === "\r" && source[offset + 2] !== "\n") + break; + if (ch === "\n") + fold += "\n"; + offset += 1; + ch = source[offset + 1]; + } + if (!fold) + fold = " "; + return { fold, offset }; + } + var escapeCodes = { + "0": "\0", + // null character + a: "\x07", + // bell character + b: "\b", + // backspace + e: "\x1B", + // escape character + f: "\f", + // form feed + n: "\n", + // line feed + r: "\r", + // carriage return + t: " ", + // horizontal tab + v: "\v", + // vertical tab + N: "\x85", + // Unicode next line + _: "\xA0", + // Unicode non-breaking space + L: "\u2028", + // Unicode line separator + P: "\u2029", + // Unicode paragraph separator + " ": " ", + '"': '"', + "/": "/", + "\\": "\\", + " ": " " + }; + function parseCharCode(source, offset, length, onError) { + const cc = source.substr(offset, length); + const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc); + const code = ok ? parseInt(cc, 16) : NaN; + if (isNaN(code)) { + const raw = source.substr(offset - 2, length + 2); + onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`); + return raw; + } + return String.fromCodePoint(code); } - }); - if (options.localAddress) { - connectOptions.localAddress = options.localAddress; - } - if (connectOptions.proxyAuth) { - connectOptions.headers = connectOptions.headers || {}; - connectOptions.headers['Proxy-Authorization'] = 'Basic ' + - new Buffer(connectOptions.proxyAuth).toString('base64'); - } - - debug('making CONNECT request'); - var connectReq = self.request(connectOptions); - connectReq.useChunkedEncodingByDefault = false; // for v0.6 - connectReq.once('response', onResponse); // for v0.6 - connectReq.once('upgrade', onUpgrade); // for v0.6 - connectReq.once('connect', onConnect); // for v0.7 or later - connectReq.once('error', onError); - connectReq.end(); - - function onResponse(res) { - // Very hacky. This is necessary to avoid http-parser leaks. - res.upgrade = true; - } - - function onUpgrade(res, socket, head) { - // Hacky. - process.nextTick(function() { - onConnect(res, socket, head); - }); + exports2.resolveFlowScalar = resolveFlowScalar; } +}); - function onConnect(res, socket, head) { - connectReq.removeAllListeners(); - socket.removeAllListeners(); - - if (res.statusCode !== 200) { - debug('tunneling socket could not be established, statusCode=%d', - res.statusCode); - socket.destroy(); - var error = new Error('tunneling socket could not be established, ' + - 'statusCode=' + res.statusCode); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - return; +// node_modules/yaml/dist/compose/compose-scalar.js +var require_compose_scalar = __commonJS({ + "node_modules/yaml/dist/compose/compose-scalar.js"(exports2) { + "use strict"; + var identity = require_identity(); + var Scalar = require_Scalar(); + var resolveBlockScalar = require_resolve_block_scalar(); + var resolveFlowScalar = require_resolve_flow_scalar(); + function composeScalar(ctx, token, tagToken, onError) { + const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError); + const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null; + let tag; + if (ctx.options.stringKeys && ctx.atKey) { + tag = ctx.schema[identity.SCALAR]; + } else if (tagName) + tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError); + else if (token.type === "scalar") + tag = findScalarTagByTest(ctx, value, token, onError); + else + tag = ctx.schema[identity.SCALAR]; + let scalar; + try { + const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options); + scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res); + } catch (error2) { + const msg = error2 instanceof Error ? error2.message : String(error2); + onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg); + scalar = new Scalar.Scalar(value); + } + scalar.range = range; + scalar.source = value; + if (type) + scalar.type = type; + if (tagName) + scalar.tag = tagName; + if (tag.format) + scalar.format = tag.format; + if (comment) + scalar.comment = comment; + return scalar; } - if (head.length > 0) { - debug('got illegal response body from proxy'); - socket.destroy(); - var error = new Error('got illegal response body from proxy'); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - return; + function findScalarTagByName(schema, value, tagName, tagToken, onError) { + if (tagName === "!") + return schema[identity.SCALAR]; + const matchWithTest = []; + for (const tag of schema.tags) { + if (!tag.collection && tag.tag === tagName) { + if (tag.default && tag.test) + matchWithTest.push(tag); + else + return tag; + } + } + for (const tag of matchWithTest) + if (tag.test?.test(value)) + return tag; + const kt = schema.knownTags[tagName]; + if (kt && !kt.collection) { + schema.tags.push(Object.assign({}, kt, { default: false, test: void 0 })); + return kt; + } + onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str"); + return schema[identity.SCALAR]; } - debug('tunneling connection has established'); - self.sockets[self.sockets.indexOf(placeholder)] = socket; - return cb(socket); - } - - function onError(cause) { - connectReq.removeAllListeners(); - - debug('tunneling socket could not be established, cause=%s\n', - cause.message, cause.stack); - var error = new Error('tunneling socket could not be established, ' + - 'cause=' + cause.message); - error.code = 'ECONNRESET'; - options.request.emit('error', error); - self.removeSocket(placeholder); - } -}; - -TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { - var pos = this.sockets.indexOf(socket) - if (pos === -1) { - return; - } - this.sockets.splice(pos, 1); - - var pending = this.requests.shift(); - if (pending) { - // If we have pending requests and a socket gets closed a new one - // needs to be created to take over in the pool for the one that closed. - this.createSocket(pending, function(socket) { - pending.request.onSocket(socket); - }); - } -}; - -function createSecureSocket(options, cb) { - var self = this; - TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { - var hostHeader = options.request.getHeader('host'); - var tlsOptions = mergeOptions({}, self.options, { - socket: socket, - servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host - }); - - // 0 is dummy port for v0.6 - var secureSocket = tls.connect(0, tlsOptions); - self.sockets[self.sockets.indexOf(socket)] = secureSocket; - cb(secureSocket); - }); -} - - -function toOptions(host, port, localAddress) { - if (typeof host === 'string') { // since v0.10 - return { - host: host, - port: port, - localAddress: localAddress - }; - } - return host; // for v0.11 or later -} - -function mergeOptions(target) { - for (var i = 1, len = arguments.length; i < len; ++i) { - var overrides = arguments[i]; - if (typeof overrides === 'object') { - var keys = Object.keys(overrides); - for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { - var k = keys[j]; - if (overrides[k] !== undefined) { - target[k] = overrides[k]; + function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) { + const tag = schema.tags.find((tag2) => (tag2.default === true || atKey && tag2.default === "key") && tag2.test?.test(value)) || schema[identity.SCALAR]; + if (schema.compat) { + const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema[identity.SCALAR]; + if (tag.tag !== compat.tag) { + const ts = directives.tagString(tag.tag); + const cs = directives.tagString(compat.tag); + const msg = `Value may be parsed as either ${ts} or ${cs}`; + onError(token, "TAG_RESOLVE_FAILED", msg, true); } } + return tag; } + exports2.composeScalar = composeScalar; } - return target; -} - +}); -var debug; -if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { - debug = function() { - var args = Array.prototype.slice.call(arguments); - if (typeof args[0] === 'string') { - args[0] = 'TUNNEL: ' + args[0]; - } else { - args.unshift('TUNNEL:'); +// node_modules/yaml/dist/compose/util-empty-scalar-position.js +var require_util_empty_scalar_position = __commonJS({ + "node_modules/yaml/dist/compose/util-empty-scalar-position.js"(exports2) { + "use strict"; + function emptyScalarPosition(offset, before, pos) { + if (before) { + pos ?? (pos = before.length); + for (let i = pos - 1; i >= 0; --i) { + let st = before[i]; + switch (st.type) { + case "space": + case "comment": + case "newline": + offset -= st.source.length; + continue; + } + st = before[++i]; + while (st?.type === "space") { + offset += st.source.length; + st = before[++i]; + } + break; + } + } + return offset; } - console.error.apply(console, args); + exports2.emptyScalarPosition = emptyScalarPosition; } -} else { - debug = function() {}; -} -exports.debug = debug; // for test - - -/***/ }), - -/***/ 4371: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const Client = __nccwpck_require__(6197) -const Dispatcher = __nccwpck_require__(992) -const errors = __nccwpck_require__(8707) -const Pool = __nccwpck_require__(5076) -const BalancedPool = __nccwpck_require__(1093) -const Agent = __nccwpck_require__(9965) -const util = __nccwpck_require__(3440) -const { InvalidArgumentError } = errors -const api = __nccwpck_require__(6615) -const buildConnector = __nccwpck_require__(9136) -const MockClient = __nccwpck_require__(7365) -const MockAgent = __nccwpck_require__(7501) -const MockPool = __nccwpck_require__(4004) -const mockErrors = __nccwpck_require__(2429) -const ProxyAgent = __nccwpck_require__(2720) -const RetryHandler = __nccwpck_require__(3573) -const { getGlobalDispatcher, setGlobalDispatcher } = __nccwpck_require__(2581) -const DecoratorHandler = __nccwpck_require__(8840) -const RedirectHandler = __nccwpck_require__(8299) -const createRedirectInterceptor = __nccwpck_require__(4415) - -let hasCrypto -try { - __nccwpck_require__(6982) - hasCrypto = true -} catch { - hasCrypto = false -} - -Object.assign(Dispatcher.prototype, api) - -module.exports.Dispatcher = Dispatcher -module.exports.Client = Client -module.exports.Pool = Pool -module.exports.BalancedPool = BalancedPool -module.exports.Agent = Agent -module.exports.ProxyAgent = ProxyAgent -module.exports.RetryHandler = RetryHandler - -module.exports.DecoratorHandler = DecoratorHandler -module.exports.RedirectHandler = RedirectHandler -module.exports.createRedirectInterceptor = createRedirectInterceptor - -module.exports.buildConnector = buildConnector -module.exports.errors = errors - -function makeDispatcher (fn) { - return (url, opts, handler) => { - if (typeof opts === 'function') { - handler = opts - opts = null - } - - if (!url || (typeof url !== 'string' && typeof url !== 'object' && !(url instanceof URL))) { - throw new InvalidArgumentError('invalid url') - } - - if (opts != null && typeof opts !== 'object') { - throw new InvalidArgumentError('invalid opts') - } +}); - if (opts && opts.path != null) { - if (typeof opts.path !== 'string') { - throw new InvalidArgumentError('invalid opts.path') +// node_modules/yaml/dist/compose/compose-node.js +var require_compose_node = __commonJS({ + "node_modules/yaml/dist/compose/compose-node.js"(exports2) { + "use strict"; + var Alias = require_Alias(); + var identity = require_identity(); + var composeCollection = require_compose_collection(); + var composeScalar = require_compose_scalar(); + var resolveEnd = require_resolve_end(); + var utilEmptyScalarPosition = require_util_empty_scalar_position(); + var CN = { composeNode, composeEmptyNode }; + function composeNode(ctx, token, props, onError) { + const atKey = ctx.atKey; + const { spaceBefore, comment, anchor, tag } = props; + let node; + let isSrcToken = true; + switch (token.type) { + case "alias": + node = composeAlias(ctx, token, onError); + if (anchor || tag) + onError(token, "ALIAS_PROPS", "An alias node must not specify any properties"); + break; + case "scalar": + case "single-quoted-scalar": + case "double-quoted-scalar": + case "block-scalar": + node = composeScalar.composeScalar(ctx, token, tag, onError); + if (anchor) + node.anchor = anchor.source.substring(1); + break; + case "block-map": + case "block-seq": + case "flow-collection": + node = composeCollection.composeCollection(CN, ctx, token, props, onError); + if (anchor) + node.anchor = anchor.source.substring(1); + break; + default: { + const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`; + onError(token, "UNEXPECTED_TOKEN", message); + node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError); + isSrcToken = false; + } } - - let path = opts.path - if (!opts.path.startsWith('/')) { - path = `/${path}` + if (anchor && node.anchor === "") + onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string"); + if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) { + const msg = "With stringKeys, all keys must be strings"; + onError(tag ?? token, "NON_STRING_KEY", msg); } - - url = new URL(util.parseOrigin(url).origin + path) - } else { - if (!opts) { - opts = typeof url === 'object' ? url : {} + if (spaceBefore) + node.spaceBefore = true; + if (comment) { + if (token.type === "scalar" && token.source === "") + node.comment = comment; + else + node.commentBefore = comment; } - - url = util.parseURL(url) + if (ctx.options.keepSourceTokens && isSrcToken) + node.srcToken = token; + return node; } - - const { agent, dispatcher = getGlobalDispatcher() } = opts - - if (agent) { - throw new InvalidArgumentError('unsupported opts.agent. Did you mean opts.client?') + function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) { + const token = { + type: "scalar", + offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos), + indent: -1, + source: "" + }; + const node = composeScalar.composeScalar(ctx, token, tag, onError); + if (anchor) { + node.anchor = anchor.source.substring(1); + if (node.anchor === "") + onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string"); + } + if (spaceBefore) + node.spaceBefore = true; + if (comment) { + node.comment = comment; + node.range[2] = end; + } + return node; + } + function composeAlias({ options }, { offset, source, end }, onError) { + const alias = new Alias.Alias(source.substring(1)); + if (alias.source === "") + onError(offset, "BAD_ALIAS", "Alias cannot be an empty string"); + if (alias.source.endsWith(":")) + onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true); + const valueEnd = offset + source.length; + const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError); + alias.range = [offset, valueEnd, re.offset]; + if (re.comment) + alias.comment = re.comment; + return alias; } - - return fn.call(dispatcher, { - ...opts, - origin: url.origin, - path: url.search ? `${url.pathname}${url.search}` : url.pathname, - method: opts.method || (opts.body ? 'PUT' : 'GET') - }, handler) + exports2.composeEmptyNode = composeEmptyNode; + exports2.composeNode = composeNode; } -} - -module.exports.setGlobalDispatcher = setGlobalDispatcher -module.exports.getGlobalDispatcher = getGlobalDispatcher - -if (util.nodeMajor > 16 || (util.nodeMajor === 16 && util.nodeMinor >= 8)) { - let fetchImpl = null - module.exports.fetch = async function fetch (resource) { - if (!fetchImpl) { - fetchImpl = (__nccwpck_require__(2315).fetch) - } +}); - try { - return await fetchImpl(...arguments) - } catch (err) { - if (typeof err === 'object') { - Error.captureStackTrace(err, this) +// node_modules/yaml/dist/compose/compose-doc.js +var require_compose_doc = __commonJS({ + "node_modules/yaml/dist/compose/compose-doc.js"(exports2) { + "use strict"; + var Document = require_Document(); + var composeNode = require_compose_node(); + var resolveEnd = require_resolve_end(); + var resolveProps = require_resolve_props(); + function composeDoc(options, directives, { offset, start, value, end }, onError) { + const opts = Object.assign({ _directives: directives }, options); + const doc = new Document.Document(void 0, opts); + const ctx = { + atKey: false, + atRoot: true, + directives: doc.directives, + options: doc.options, + schema: doc.schema + }; + const props = resolveProps.resolveProps(start, { + indicator: "doc-start", + next: value ?? end?.[0], + offset, + onError, + parentIndent: 0, + startOnNewline: true + }); + if (props.found) { + doc.directives.docStart = true; + if (value && (value.type === "block-map" || value.type === "block-seq") && !props.hasNewline) + onError(props.end, "MISSING_CHAR", "Block collection cannot start on same line with directives-end marker"); } - - throw err + doc.contents = value ? composeNode.composeNode(ctx, value, props, onError) : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError); + const contentEnd = doc.contents.range[2]; + const re = resolveEnd.resolveEnd(end, contentEnd, false, onError); + if (re.comment) + doc.comment = re.comment; + doc.range = [offset, contentEnd, re.offset]; + return doc; } + exports2.composeDoc = composeDoc; } - module.exports.Headers = __nccwpck_require__(6349).Headers - module.exports.Response = __nccwpck_require__(8676).Response - module.exports.Request = __nccwpck_require__(5194).Request - module.exports.FormData = __nccwpck_require__(3073).FormData - module.exports.File = __nccwpck_require__(3041).File - module.exports.FileReader = __nccwpck_require__(2160).FileReader - - const { setGlobalOrigin, getGlobalOrigin } = __nccwpck_require__(5628) - - module.exports.setGlobalOrigin = setGlobalOrigin - module.exports.getGlobalOrigin = getGlobalOrigin - - const { CacheStorage } = __nccwpck_require__(4738) - const { kConstruct } = __nccwpck_require__(296) - - // Cache & CacheStorage are tightly coupled with fetch. Even if it may run - // in an older version of Node, it doesn't have any use without fetch. - module.exports.caches = new CacheStorage(kConstruct) -} - -if (util.nodeMajor >= 16) { - const { deleteCookie, getCookies, getSetCookies, setCookie } = __nccwpck_require__(3168) - - module.exports.deleteCookie = deleteCookie - module.exports.getCookies = getCookies - module.exports.getSetCookies = getSetCookies - module.exports.setCookie = setCookie - - const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(4322) - - module.exports.parseMIMEType = parseMIMEType - module.exports.serializeAMimeType = serializeAMimeType -} - -if (util.nodeMajor >= 18 && hasCrypto) { - const { WebSocket } = __nccwpck_require__(5171) - - module.exports.WebSocket = WebSocket -} - -module.exports.request = makeDispatcher(api.request) -module.exports.stream = makeDispatcher(api.stream) -module.exports.pipeline = makeDispatcher(api.pipeline) -module.exports.connect = makeDispatcher(api.connect) -module.exports.upgrade = makeDispatcher(api.upgrade) - -module.exports.MockClient = MockClient -module.exports.MockPool = MockPool -module.exports.MockAgent = MockAgent -module.exports.mockErrors = mockErrors - - -/***/ }), - -/***/ 9965: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - +}); -const { InvalidArgumentError } = __nccwpck_require__(8707) -const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(6443) -const DispatcherBase = __nccwpck_require__(1) -const Pool = __nccwpck_require__(5076) -const Client = __nccwpck_require__(6197) -const util = __nccwpck_require__(3440) -const createRedirectInterceptor = __nccwpck_require__(4415) -const { WeakRef, FinalizationRegistry } = __nccwpck_require__(3194)() - -const kOnConnect = Symbol('onConnect') -const kOnDisconnect = Symbol('onDisconnect') -const kOnConnectionError = Symbol('onConnectionError') -const kMaxRedirections = Symbol('maxRedirections') -const kOnDrain = Symbol('onDrain') -const kFactory = Symbol('factory') -const kFinalizer = Symbol('finalizer') -const kOptions = Symbol('options') - -function defaultFactory (origin, opts) { - return opts && opts.connections === 1 - ? new Client(origin, opts) - : new Pool(origin, opts) -} - -class Agent extends DispatcherBase { - constructor ({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { - super() - - if (typeof factory !== 'function') { - throw new InvalidArgumentError('factory must be a function.') - } - - if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') { - throw new InvalidArgumentError('connect must be a function or an object') - } - - if (!Number.isInteger(maxRedirections) || maxRedirections < 0) { - throw new InvalidArgumentError('maxRedirections must be a positive number') - } - - if (connect && typeof connect !== 'function') { - connect = { ...connect } - } - - this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) - ? options.interceptors.Agent - : [createRedirectInterceptor({ maxRedirections })] - - this[kOptions] = { ...util.deepClone(options), connect } - this[kOptions].interceptors = options.interceptors - ? { ...options.interceptors } - : undefined - this[kMaxRedirections] = maxRedirections - this[kFactory] = factory - this[kClients] = new Map() - this[kFinalizer] = new FinalizationRegistry(/* istanbul ignore next: gc is undeterministic */ key => { - const ref = this[kClients].get(key) - if (ref !== undefined && ref.deref() === undefined) { - this[kClients].delete(key) - } - }) - - const agent = this - - this[kOnDrain] = (origin, targets) => { - agent.emit('drain', origin, [agent, ...targets]) - } - - this[kOnConnect] = (origin, targets) => { - agent.emit('connect', origin, [agent, ...targets]) - } - - this[kOnDisconnect] = (origin, targets, err) => { - agent.emit('disconnect', origin, [agent, ...targets], err) - } - - this[kOnConnectionError] = (origin, targets, err) => { - agent.emit('connectionError', origin, [agent, ...targets], err) +// node_modules/yaml/dist/compose/composer.js +var require_composer = __commonJS({ + "node_modules/yaml/dist/compose/composer.js"(exports2) { + "use strict"; + var node_process = require("process"); + var directives = require_directives(); + var Document = require_Document(); + var errors = require_errors(); + var identity = require_identity(); + var composeDoc = require_compose_doc(); + var resolveEnd = require_resolve_end(); + function getErrorPos(src) { + if (typeof src === "number") + return [src, src + 1]; + if (Array.isArray(src)) + return src.length === 2 ? src : [src[0], src[1]]; + const { offset, source } = src; + return [offset, offset + (typeof source === "string" ? source.length : 1)]; + } + function parsePrelude(prelude) { + let comment = ""; + let atComment = false; + let afterEmptyLine = false; + for (let i = 0; i < prelude.length; ++i) { + const source = prelude[i]; + switch (source[0]) { + case "#": + comment += (comment === "" ? "" : afterEmptyLine ? "\n\n" : "\n") + (source.substring(1) || " "); + atComment = true; + afterEmptyLine = false; + break; + case "%": + if (prelude[i + 1]?.[0] !== "#") + i += 1; + atComment = false; + break; + default: + if (!atComment) + afterEmptyLine = true; + atComment = false; + } + } + return { comment, afterEmptyLine }; } + var Composer = class { + constructor(options = {}) { + this.doc = null; + this.atDirectives = false; + this.prelude = []; + this.errors = []; + this.warnings = []; + this.onError = (source, code, message, warning) => { + const pos = getErrorPos(source); + if (warning) + this.warnings.push(new errors.YAMLWarning(pos, code, message)); + else + this.errors.push(new errors.YAMLParseError(pos, code, message)); + }; + this.directives = new directives.Directives({ version: options.version || "1.2" }); + this.options = options; + } + decorate(doc, afterDoc) { + const { comment, afterEmptyLine } = parsePrelude(this.prelude); + if (comment) { + const dc = doc.contents; + if (afterDoc) { + doc.comment = doc.comment ? `${doc.comment} +${comment}` : comment; + } else if (afterEmptyLine || doc.directives.docStart || !dc) { + doc.commentBefore = comment; + } else if (identity.isCollection(dc) && !dc.flow && dc.items.length > 0) { + let it = dc.items[0]; + if (identity.isPair(it)) + it = it.key; + const cb = it.commentBefore; + it.commentBefore = cb ? `${comment} +${cb}` : comment; + } else { + const cb = dc.commentBefore; + dc.commentBefore = cb ? `${comment} +${cb}` : comment; + } + } + if (afterDoc) { + Array.prototype.push.apply(doc.errors, this.errors); + Array.prototype.push.apply(doc.warnings, this.warnings); + } else { + doc.errors = this.errors; + doc.warnings = this.warnings; + } + this.prelude = []; + this.errors = []; + this.warnings = []; + } + /** + * Current stream status information. + * + * Mostly useful at the end of input for an empty stream. + */ + streamInfo() { + return { + comment: parsePrelude(this.prelude).comment, + directives: this.directives, + errors: this.errors, + warnings: this.warnings + }; + } + /** + * Compose tokens into documents. + * + * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document. + * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly. + */ + *compose(tokens, forceDoc = false, endOffset = -1) { + for (const token of tokens) + yield* this.next(token); + yield* this.end(forceDoc, endOffset); + } + /** Advance the composer by one CST token. */ + *next(token) { + if (node_process.env.LOG_STREAM) + console.dir(token, { depth: null }); + switch (token.type) { + case "directive": + this.directives.add(token.source, (offset, message, warning) => { + const pos = getErrorPos(token); + pos[0] += offset; + this.onError(pos, "BAD_DIRECTIVE", message, warning); + }); + this.prelude.push(token.source); + this.atDirectives = true; + break; + case "document": { + const doc = composeDoc.composeDoc(this.options, this.directives, token, this.onError); + if (this.atDirectives && !doc.directives.docStart) + this.onError(token, "MISSING_CHAR", "Missing directives-end/doc-start indicator line"); + this.decorate(doc, false); + if (this.doc) + yield this.doc; + this.doc = doc; + this.atDirectives = false; + break; + } + case "byte-order-mark": + case "space": + break; + case "comment": + case "newline": + this.prelude.push(token.source); + break; + case "error": { + const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message; + const error2 = new errors.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg); + if (this.atDirectives || !this.doc) + this.errors.push(error2); + else + this.doc.errors.push(error2); + break; + } + case "doc-end": { + if (!this.doc) { + const msg = "Unexpected doc-end without preceding document"; + this.errors.push(new errors.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg)); + break; + } + this.doc.directives.docEnd = true; + const end = resolveEnd.resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError); + this.decorate(this.doc, true); + if (end.comment) { + const dc = this.doc.comment; + this.doc.comment = dc ? `${dc} +${end.comment}` : end.comment; + } + this.doc.range[2] = end.offset; + break; + } + default: + this.errors.push(new errors.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`)); + } + } + /** + * Call at end of input to yield any remaining document. + * + * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document. + * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly. + */ + *end(forceDoc = false, endOffset = -1) { + if (this.doc) { + this.decorate(this.doc, true); + yield this.doc; + this.doc = null; + } else if (forceDoc) { + const opts = Object.assign({ _directives: this.directives }, this.options); + const doc = new Document.Document(void 0, opts); + if (this.atDirectives) + this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line"); + doc.range = [0, endOffset, endOffset]; + this.decorate(doc, false); + yield doc; + } + } + }; + exports2.Composer = Composer; } +}); - get [kRunning] () { - let ret = 0 - for (const ref of this[kClients].values()) { - const client = ref.deref() - /* istanbul ignore next: gc is undeterministic */ - if (client) { - ret += client[kRunning] +// node_modules/yaml/dist/parse/cst-scalar.js +var require_cst_scalar = __commonJS({ + "node_modules/yaml/dist/parse/cst-scalar.js"(exports2) { + "use strict"; + var resolveBlockScalar = require_resolve_block_scalar(); + var resolveFlowScalar = require_resolve_flow_scalar(); + var errors = require_errors(); + var stringifyString = require_stringifyString(); + function resolveAsScalar(token, strict = true, onError) { + if (token) { + const _onError = (pos, code, message) => { + const offset = typeof pos === "number" ? pos : Array.isArray(pos) ? pos[0] : pos.offset; + if (onError) + onError(offset, code, message); + else + throw new errors.YAMLParseError([offset, offset + 1], code, message); + }; + switch (token.type) { + case "scalar": + case "single-quoted-scalar": + case "double-quoted-scalar": + return resolveFlowScalar.resolveFlowScalar(token, strict, _onError); + case "block-scalar": + return resolveBlockScalar.resolveBlockScalar({ options: { strict } }, token, _onError); + } } + return null; } - return ret - } - - [kDispatch] (opts, handler) { - let key - if (opts.origin && (typeof opts.origin === 'string' || opts.origin instanceof URL)) { - key = String(opts.origin) - } else { - throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.') + function createScalarToken(value, context) { + const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context; + const source = stringifyString.stringifyString({ type, value }, { + implicitKey, + indent: indent > 0 ? " ".repeat(indent) : "", + inFlow, + options: { blockQuote: true, lineWidth: -1 } + }); + const end = context.end ?? [ + { type: "newline", offset: -1, indent, source: "\n" } + ]; + switch (source[0]) { + case "|": + case ">": { + const he = source.indexOf("\n"); + const head = source.substring(0, he); + const body = source.substring(he + 1) + "\n"; + const props = [ + { type: "block-scalar-header", offset, indent, source: head } + ]; + if (!addEndtoBlockProps(props, end)) + props.push({ type: "newline", offset: -1, indent, source: "\n" }); + return { type: "block-scalar", offset, indent, props, source: body }; + } + case '"': + return { type: "double-quoted-scalar", offset, indent, source, end }; + case "'": + return { type: "single-quoted-scalar", offset, indent, source, end }; + default: + return { type: "scalar", offset, indent, source, end }; + } } - - const ref = this[kClients].get(key) - - let dispatcher = ref ? ref.deref() : null - if (!dispatcher) { - dispatcher = this[kFactory](opts.origin, this[kOptions]) - .on('drain', this[kOnDrain]) - .on('connect', this[kOnConnect]) - .on('disconnect', this[kOnDisconnect]) - .on('connectionError', this[kOnConnectionError]) - - this[kClients].set(key, new WeakRef(dispatcher)) - this[kFinalizer].register(dispatcher, key) + function setScalarValue(token, value, context = {}) { + let { afterKey = false, implicitKey = false, inFlow = false, type } = context; + let indent = "indent" in token ? token.indent : null; + if (afterKey && typeof indent === "number") + indent += 2; + if (!type) + switch (token.type) { + case "single-quoted-scalar": + type = "QUOTE_SINGLE"; + break; + case "double-quoted-scalar": + type = "QUOTE_DOUBLE"; + break; + case "block-scalar": { + const header = token.props[0]; + if (header.type !== "block-scalar-header") + throw new Error("Invalid block scalar header"); + type = header.source[0] === ">" ? "BLOCK_FOLDED" : "BLOCK_LITERAL"; + break; + } + default: + type = "PLAIN"; + } + const source = stringifyString.stringifyString({ type, value }, { + implicitKey: implicitKey || indent === null, + indent: indent !== null && indent > 0 ? " ".repeat(indent) : "", + inFlow, + options: { blockQuote: true, lineWidth: -1 } + }); + switch (source[0]) { + case "|": + case ">": + setBlockScalarValue(token, source); + break; + case '"': + setFlowScalarValue(token, source, "double-quoted-scalar"); + break; + case "'": + setFlowScalarValue(token, source, "single-quoted-scalar"); + break; + default: + setFlowScalarValue(token, source, "scalar"); + } } - - return dispatcher.dispatch(opts, handler) - } - - async [kClose] () { - const closePromises = [] - for (const ref of this[kClients].values()) { - const client = ref.deref() - /* istanbul ignore else: gc is undeterministic */ - if (client) { - closePromises.push(client.close()) + function setBlockScalarValue(token, source) { + const he = source.indexOf("\n"); + const head = source.substring(0, he); + const body = source.substring(he + 1) + "\n"; + if (token.type === "block-scalar") { + const header = token.props[0]; + if (header.type !== "block-scalar-header") + throw new Error("Invalid block scalar header"); + header.source = head; + token.source = body; + } else { + const { offset } = token; + const indent = "indent" in token ? token.indent : -1; + const props = [ + { type: "block-scalar-header", offset, indent, source: head } + ]; + if (!addEndtoBlockProps(props, "end" in token ? token.end : void 0)) + props.push({ type: "newline", offset: -1, indent, source: "\n" }); + for (const key of Object.keys(token)) + if (key !== "type" && key !== "offset") + delete token[key]; + Object.assign(token, { type: "block-scalar", indent, props, source: body }); } } - - await Promise.all(closePromises) - } - - async [kDestroy] (err) { - const destroyPromises = [] - for (const ref of this[kClients].values()) { - const client = ref.deref() - /* istanbul ignore else: gc is undeterministic */ - if (client) { - destroyPromises.push(client.destroy(err)) + function addEndtoBlockProps(props, end) { + if (end) + for (const st of end) + switch (st.type) { + case "space": + case "comment": + props.push(st); + break; + case "newline": + props.push(st); + return true; + } + return false; + } + function setFlowScalarValue(token, source, type) { + switch (token.type) { + case "scalar": + case "double-quoted-scalar": + case "single-quoted-scalar": + token.type = type; + token.source = source; + break; + case "block-scalar": { + const end = token.props.slice(1); + let oa = source.length; + if (token.props[0].type === "block-scalar-header") + oa -= token.props[0].source.length; + for (const tok of end) + tok.offset += oa; + delete token.props; + Object.assign(token, { type, source, end }); + break; + } + case "block-map": + case "block-seq": { + const offset = token.offset + source.length; + const nl = { type: "newline", offset, indent: token.indent, source: "\n" }; + delete token.items; + Object.assign(token, { type, source, end: [nl] }); + break; + } + default: { + const indent = "indent" in token ? token.indent : -1; + const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st) => st.type === "space" || st.type === "comment" || st.type === "newline") : []; + for (const key of Object.keys(token)) + if (key !== "type" && key !== "offset") + delete token[key]; + Object.assign(token, { type, indent, source, end }); + } } } - - await Promise.all(destroyPromises) - } -} - -module.exports = Agent - - -/***/ }), - -/***/ 158: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -const { addAbortListener } = __nccwpck_require__(3440) -const { RequestAbortedError } = __nccwpck_require__(8707) - -const kListener = Symbol('kListener') -const kSignal = Symbol('kSignal') - -function abort (self) { - if (self.abort) { - self.abort() - } else { - self.onError(new RequestAbortedError()) - } -} - -function addSignal (self, signal) { - self[kSignal] = null - self[kListener] = null - - if (!signal) { - return - } - - if (signal.aborted) { - abort(self) - return - } - - self[kSignal] = signal - self[kListener] = () => { - abort(self) - } - - addAbortListener(self[kSignal], self[kListener]) -} - -function removeSignal (self) { - if (!self[kSignal]) { - return - } - - if ('removeEventListener' in self[kSignal]) { - self[kSignal].removeEventListener('abort', self[kListener]) - } else { - self[kSignal].removeListener('abort', self[kListener]) + exports2.createScalarToken = createScalarToken; + exports2.resolveAsScalar = resolveAsScalar; + exports2.setScalarValue = setScalarValue; } +}); - self[kSignal] = null - self[kListener] = null -} - -module.exports = { - addSignal, - removeSignal -} - - -/***/ }), - -/***/ 4660: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { AsyncResource } = __nccwpck_require__(290) -const { InvalidArgumentError, RequestAbortedError, SocketError } = __nccwpck_require__(8707) -const util = __nccwpck_require__(3440) -const { addSignal, removeSignal } = __nccwpck_require__(158) - -class ConnectHandler extends AsyncResource { - constructor (opts, callback) { - if (!opts || typeof opts !== 'object') { - throw new InvalidArgumentError('invalid opts') - } - - if (typeof callback !== 'function') { - throw new InvalidArgumentError('invalid callback') +// node_modules/yaml/dist/parse/cst-stringify.js +var require_cst_stringify = __commonJS({ + "node_modules/yaml/dist/parse/cst-stringify.js"(exports2) { + "use strict"; + var stringify2 = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst); + function stringifyToken(token) { + switch (token.type) { + case "block-scalar": { + let res = ""; + for (const tok of token.props) + res += stringifyToken(tok); + return res + token.source; + } + case "block-map": + case "block-seq": { + let res = ""; + for (const item of token.items) + res += stringifyItem(item); + return res; + } + case "flow-collection": { + let res = token.start.source; + for (const item of token.items) + res += stringifyItem(item); + for (const st of token.end) + res += st.source; + return res; + } + case "document": { + let res = stringifyItem(token); + if (token.end) + for (const st of token.end) + res += st.source; + return res; + } + default: { + let res = token.source; + if ("end" in token && token.end) + for (const st of token.end) + res += st.source; + return res; + } + } } - - const { signal, opaque, responseHeaders } = opts - - if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { - throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + function stringifyItem({ start, key, sep, value }) { + let res = ""; + for (const st of start) + res += st.source; + if (key) + res += stringifyToken(key); + if (sep) + for (const st of sep) + res += st.source; + if (value) + res += stringifyToken(value); + return res; } - - super('UNDICI_CONNECT') - - this.opaque = opaque || null - this.responseHeaders = responseHeaders || null - this.callback = callback - this.abort = null - - addSignal(this, signal) + exports2.stringify = stringify2; } +}); - onConnect (abort, context) { - if (!this.callback) { - throw new RequestAbortedError() +// node_modules/yaml/dist/parse/cst-visit.js +var require_cst_visit = __commonJS({ + "node_modules/yaml/dist/parse/cst-visit.js"(exports2) { + "use strict"; + var BREAK = Symbol("break visit"); + var SKIP = Symbol("skip children"); + var REMOVE = Symbol("remove item"); + function visit(cst, visitor) { + if ("type" in cst && cst.type === "document") + cst = { start: cst.start, value: cst.value }; + _visit(Object.freeze([]), cst, visitor); + } + visit.BREAK = BREAK; + visit.SKIP = SKIP; + visit.REMOVE = REMOVE; + visit.itemAtPath = (cst, path2) => { + let item = cst; + for (const [field, index] of path2) { + const tok = item?.[field]; + if (tok && "items" in tok) { + item = tok.items[index]; + } else + return void 0; + } + return item; + }; + visit.parentCollection = (cst, path2) => { + const parent = visit.itemAtPath(cst, path2.slice(0, -1)); + const field = path2[path2.length - 1][0]; + const coll = parent?.[field]; + if (coll && "items" in coll) + return coll; + throw new Error("Parent collection not found"); + }; + function _visit(path2, item, visitor) { + let ctrl = visitor(item, path2); + if (typeof ctrl === "symbol") + return ctrl; + for (const field of ["key", "value"]) { + const token = item[field]; + if (token && "items" in token) { + for (let i = 0; i < token.items.length; ++i) { + const ci = _visit(Object.freeze(path2.concat([[field, i]])), token.items[i], visitor); + if (typeof ci === "number") + i = ci - 1; + else if (ci === BREAK) + return BREAK; + else if (ci === REMOVE) { + token.items.splice(i, 1); + i -= 1; + } + } + if (typeof ctrl === "function" && field === "key") + ctrl = ctrl(item, path2); + } + } + return typeof ctrl === "function" ? ctrl(item, path2) : ctrl; } - - this.abort = abort - this.context = context - } - - onHeaders () { - throw new SocketError('bad connect', null) + exports2.visit = visit; } +}); - onUpgrade (statusCode, rawHeaders, socket) { - const { callback, opaque, context } = this - - removeSignal(this) - - this.callback = null - - let headers = rawHeaders - // Indicates is an HTTP2Session - if (headers != null) { - headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) +// node_modules/yaml/dist/parse/cst.js +var require_cst = __commonJS({ + "node_modules/yaml/dist/parse/cst.js"(exports2) { + "use strict"; + var cstScalar = require_cst_scalar(); + var cstStringify = require_cst_stringify(); + var cstVisit = require_cst_visit(); + var BOM = "\uFEFF"; + var DOCUMENT = ""; + var FLOW_END = ""; + var SCALAR = ""; + var isCollection = (token) => !!token && "items" in token; + var isScalar = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar"); + function prettyToken(token) { + switch (token) { + case BOM: + return ""; + case DOCUMENT: + return ""; + case FLOW_END: + return ""; + case SCALAR: + return ""; + default: + return JSON.stringify(token); + } } - - this.runInAsyncScope(callback, null, null, { - statusCode, - headers, - socket, - opaque, - context - }) - } - - onError (err) { - const { callback, opaque } = this - - removeSignal(this) - - if (callback) { - this.callback = null - queueMicrotask(() => { - this.runInAsyncScope(callback, null, err, { opaque }) - }) + function tokenType(source) { + switch (source) { + case BOM: + return "byte-order-mark"; + case DOCUMENT: + return "doc-mode"; + case FLOW_END: + return "flow-error-end"; + case SCALAR: + return "scalar"; + case "---": + return "doc-start"; + case "...": + return "doc-end"; + case "": + case "\n": + case "\r\n": + return "newline"; + case "-": + return "seq-item-ind"; + case "?": + return "explicit-key-ind"; + case ":": + return "map-value-ind"; + case "{": + return "flow-map-start"; + case "}": + return "flow-map-end"; + case "[": + return "flow-seq-start"; + case "]": + return "flow-seq-end"; + case ",": + return "comma"; + } + switch (source[0]) { + case " ": + case " ": + return "space"; + case "#": + return "comment"; + case "%": + return "directive-line"; + case "*": + return "alias"; + case "&": + return "anchor"; + case "!": + return "tag"; + case "'": + return "single-quoted-scalar"; + case '"': + return "double-quoted-scalar"; + case "|": + case ">": + return "block-scalar-header"; + } + return null; } + exports2.createScalarToken = cstScalar.createScalarToken; + exports2.resolveAsScalar = cstScalar.resolveAsScalar; + exports2.setScalarValue = cstScalar.setScalarValue; + exports2.stringify = cstStringify.stringify; + exports2.visit = cstVisit.visit; + exports2.BOM = BOM; + exports2.DOCUMENT = DOCUMENT; + exports2.FLOW_END = FLOW_END; + exports2.SCALAR = SCALAR; + exports2.isCollection = isCollection; + exports2.isScalar = isScalar; + exports2.prettyToken = prettyToken; + exports2.tokenType = tokenType; } -} - -function connect (opts, callback) { - if (callback === undefined) { - return new Promise((resolve, reject) => { - connect.call(this, opts, (err, data) => { - return err ? reject(err) : resolve(data) - }) - }) - } +}); - try { - const connectHandler = new ConnectHandler(opts, callback) - this.dispatch({ ...opts, method: 'CONNECT' }, connectHandler) - } catch (err) { - if (typeof callback !== 'function') { - throw err +// node_modules/yaml/dist/parse/lexer.js +var require_lexer = __commonJS({ + "node_modules/yaml/dist/parse/lexer.js"(exports2) { + "use strict"; + var cst = require_cst(); + function isEmpty(ch) { + switch (ch) { + case void 0: + case " ": + case "\n": + case "\r": + case " ": + return true; + default: + return false; + } } - const opaque = opts && opts.opaque - queueMicrotask(() => callback(err, { opaque })) - } -} - -module.exports = connect - - -/***/ }), - -/***/ 6862: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { - Readable, - Duplex, - PassThrough -} = __nccwpck_require__(2203) -const { - InvalidArgumentError, - InvalidReturnValueError, - RequestAbortedError -} = __nccwpck_require__(8707) -const util = __nccwpck_require__(3440) -const { AsyncResource } = __nccwpck_require__(290) -const { addSignal, removeSignal } = __nccwpck_require__(158) -const assert = __nccwpck_require__(2613) - -const kResume = Symbol('resume') - -class PipelineRequest extends Readable { - constructor () { - super({ autoDestroy: true }) - - this[kResume] = null - } - - _read () { - const { [kResume]: resume } = this - - if (resume) { - this[kResume] = null - resume() - } - } - - _destroy (err, callback) { - this._read() - - callback(err) - } -} - -class PipelineResponse extends Readable { - constructor (resume) { - super({ autoDestroy: true }) - this[kResume] = resume - } - - _read () { - this[kResume]() - } - - _destroy (err, callback) { - if (!err && !this._readableState.endEmitted) { - err = new RequestAbortedError() - } - - callback(err) - } -} - -class PipelineHandler extends AsyncResource { - constructor (opts, handler) { - if (!opts || typeof opts !== 'object') { - throw new InvalidArgumentError('invalid opts') - } - - if (typeof handler !== 'function') { - throw new InvalidArgumentError('invalid handler') - } - - const { signal, method, opaque, onInfo, responseHeaders } = opts - - if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { - throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') - } - - if (method === 'CONNECT') { - throw new InvalidArgumentError('invalid method') - } - - if (onInfo && typeof onInfo !== 'function') { - throw new InvalidArgumentError('invalid onInfo callback') - } - - super('UNDICI_PIPELINE') - - this.opaque = opaque || null - this.responseHeaders = responseHeaders || null - this.handler = handler - this.abort = null - this.context = null - this.onInfo = onInfo || null - - this.req = new PipelineRequest().on('error', util.nop) - - this.ret = new Duplex({ - readableObjectMode: opts.objectMode, - autoDestroy: true, - read: () => { - const { body } = this - - if (body && body.resume) { - body.resume() + var hexDigits = new Set("0123456789ABCDEFabcdef"); + var tagChars = new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()"); + var flowIndicatorChars = new Set(",[]{}"); + var invalidAnchorChars = new Set(" ,[]{}\n\r "); + var isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch); + var Lexer = class { + constructor() { + this.atEnd = false; + this.blockScalarIndent = -1; + this.blockScalarKeep = false; + this.buffer = ""; + this.flowKey = false; + this.flowLevel = 0; + this.indentNext = 0; + this.indentValue = 0; + this.lineEndPos = null; + this.next = null; + this.pos = 0; + } + /** + * Generate YAML tokens from the `source` string. If `incomplete`, + * a part of the last line may be left as a buffer for the next call. + * + * @returns A generator of lexical tokens + */ + *lex(source, incomplete = false) { + if (source) { + if (typeof source !== "string") + throw TypeError("source is not a string"); + this.buffer = this.buffer ? this.buffer + source : source; + this.lineEndPos = null; } - }, - write: (chunk, encoding, callback) => { - const { req } = this - - if (req.push(chunk, encoding) || req._readableState.destroyed) { - callback() - } else { - req[kResume] = callback + this.atEnd = !incomplete; + let next = this.next ?? "stream"; + while (next && (incomplete || this.hasChars(1))) + next = yield* this.parseNext(next); + } + atLineEnd() { + let i = this.pos; + let ch = this.buffer[i]; + while (ch === " " || ch === " ") + ch = this.buffer[++i]; + if (!ch || ch === "#" || ch === "\n") + return true; + if (ch === "\r") + return this.buffer[i + 1] === "\n"; + return false; + } + charAt(n) { + return this.buffer[this.pos + n]; + } + continueScalar(offset) { + let ch = this.buffer[offset]; + if (this.indentNext > 0) { + let indent = 0; + while (ch === " ") + ch = this.buffer[++indent + offset]; + if (ch === "\r") { + const next = this.buffer[indent + offset + 1]; + if (next === "\n" || !next && !this.atEnd) + return offset + indent + 1; + } + return ch === "\n" || indent >= this.indentNext || !ch && !this.atEnd ? offset + indent : -1; } - }, - destroy: (err, callback) => { - const { body, req, res, ret, abort } = this - - if (!err && !ret._readableState.endEmitted) { - err = new RequestAbortedError() + if (ch === "-" || ch === ".") { + const dt = this.buffer.substr(offset, 3); + if ((dt === "---" || dt === "...") && isEmpty(this.buffer[offset + 3])) + return -1; } - - if (abort && err) { - abort() + return offset; + } + getLine() { + let end = this.lineEndPos; + if (typeof end !== "number" || end !== -1 && end < this.pos) { + end = this.buffer.indexOf("\n", this.pos); + this.lineEndPos = end; } - - util.destroy(body, err) - util.destroy(req, err) - util.destroy(res, err) - - removeSignal(this) - - callback(err) + if (end === -1) + return this.atEnd ? this.buffer.substring(this.pos) : null; + if (this.buffer[end - 1] === "\r") + end -= 1; + return this.buffer.substring(this.pos, end); } - }).on('prefinish', () => { - const { req } = this - - // Node < 15 does not call _final in same tick. - req.push(null) - }) - - this.res = null - - addSignal(this, signal) - } - - onConnect (abort, context) { - const { ret, res } = this - - assert(!res, 'pipeline cannot be retried') - - if (ret.destroyed) { - throw new RequestAbortedError() - } - - this.abort = abort - this.context = context - } - - onHeaders (statusCode, rawHeaders, resume) { - const { opaque, handler, context } = this - - if (statusCode < 200) { - if (this.onInfo) { - const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) - this.onInfo({ statusCode, headers }) + hasChars(n) { + return this.pos + n <= this.buffer.length; } - return - } - - this.res = new PipelineResponse(resume) - - let body - try { - this.handler = null - const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) - body = this.runInAsyncScope(handler, null, { - statusCode, - headers, - opaque, - body: this.res, - context - }) - } catch (err) { - this.res.on('error', util.nop) - throw err - } - - if (!body || typeof body.on !== 'function') { - throw new InvalidReturnValueError('expected Readable') - } - - body - .on('data', (chunk) => { - const { ret, body } = this - - if (!ret.push(chunk) && body.pause) { - body.pause() + setNext(state) { + this.buffer = this.buffer.substring(this.pos); + this.pos = 0; + this.lineEndPos = null; + this.next = state; + return null; + } + peek(n) { + return this.buffer.substr(this.pos, n); + } + *parseNext(next) { + switch (next) { + case "stream": + return yield* this.parseStream(); + case "line-start": + return yield* this.parseLineStart(); + case "block-start": + return yield* this.parseBlockStart(); + case "doc": + return yield* this.parseDocument(); + case "flow": + return yield* this.parseFlowCollection(); + case "quoted-scalar": + return yield* this.parseQuotedScalar(); + case "block-scalar": + return yield* this.parseBlockScalar(); + case "plain-scalar": + return yield* this.parsePlainScalar(); + } + } + *parseStream() { + let line = this.getLine(); + if (line === null) + return this.setNext("stream"); + if (line[0] === cst.BOM) { + yield* this.pushCount(1); + line = line.substring(1); + } + if (line[0] === "%") { + let dirEnd = line.length; + let cs = line.indexOf("#"); + while (cs !== -1) { + const ch = line[cs - 1]; + if (ch === " " || ch === " ") { + dirEnd = cs - 1; + break; + } else { + cs = line.indexOf("#", cs + 1); + } + } + while (true) { + const ch = line[dirEnd - 1]; + if (ch === " " || ch === " ") + dirEnd -= 1; + else + break; + } + const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true)); + yield* this.pushCount(line.length - n); + this.pushNewline(); + return "stream"; } - }) - .on('error', (err) => { - const { ret } = this - - util.destroy(ret, err) - }) - .on('end', () => { - const { ret } = this - - ret.push(null) - }) - .on('close', () => { - const { ret } = this - - if (!ret._readableState.ended) { - util.destroy(ret, new RequestAbortedError()) + if (this.atLineEnd()) { + const sp = yield* this.pushSpaces(true); + yield* this.pushCount(line.length - sp); + yield* this.pushNewline(); + return "stream"; } - }) - - this.body = body - } - - onData (chunk) { - const { res } = this - return res.push(chunk) - } - - onComplete (trailers) { - const { res } = this - res.push(null) - } - - onError (err) { - const { ret } = this - this.handler = null - util.destroy(ret, err) - } -} - -function pipeline (opts, handler) { - try { - const pipelineHandler = new PipelineHandler(opts, handler) - this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler) - return pipelineHandler.ret - } catch (err) { - return new PassThrough().destroy(err) - } -} - -module.exports = pipeline - - -/***/ }), - -/***/ 6424: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const Readable = __nccwpck_require__(9927) -const { - InvalidArgumentError, - RequestAbortedError -} = __nccwpck_require__(8707) -const util = __nccwpck_require__(3440) -const { getResolveErrorBodyCallback } = __nccwpck_require__(7655) -const { AsyncResource } = __nccwpck_require__(290) -const { addSignal, removeSignal } = __nccwpck_require__(158) - -class RequestHandler extends AsyncResource { - constructor (opts, callback) { - if (!opts || typeof opts !== 'object') { - throw new InvalidArgumentError('invalid opts') - } - - const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts - - try { - if (typeof callback !== 'function') { - throw new InvalidArgumentError('invalid callback') - } - - if (highWaterMark && (typeof highWaterMark !== 'number' || highWaterMark < 0)) { - throw new InvalidArgumentError('invalid highWaterMark') + yield cst.DOCUMENT; + return yield* this.parseLineStart(); } - - if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { - throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + *parseLineStart() { + const ch = this.charAt(0); + if (!ch && !this.atEnd) + return this.setNext("line-start"); + if (ch === "-" || ch === ".") { + if (!this.atEnd && !this.hasChars(4)) + return this.setNext("line-start"); + const s = this.peek(3); + if ((s === "---" || s === "...") && isEmpty(this.charAt(3))) { + yield* this.pushCount(3); + this.indentValue = 0; + this.indentNext = 0; + return s === "---" ? "doc" : "stream"; + } + } + this.indentValue = yield* this.pushSpaces(false); + if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1))) + this.indentNext = this.indentValue; + return yield* this.parseBlockStart(); } - - if (method === 'CONNECT') { - throw new InvalidArgumentError('invalid method') + *parseBlockStart() { + const [ch0, ch1] = this.peek(2); + if (!ch1 && !this.atEnd) + return this.setNext("block-start"); + if ((ch0 === "-" || ch0 === "?" || ch0 === ":") && isEmpty(ch1)) { + const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)); + this.indentNext = this.indentValue + 1; + this.indentValue += n; + return yield* this.parseBlockStart(); + } + return "doc"; } - - if (onInfo && typeof onInfo !== 'function') { - throw new InvalidArgumentError('invalid onInfo callback') + *parseDocument() { + yield* this.pushSpaces(true); + const line = this.getLine(); + if (line === null) + return this.setNext("doc"); + let n = yield* this.pushIndicators(); + switch (line[n]) { + case "#": + yield* this.pushCount(line.length - n); + // fallthrough + case void 0: + yield* this.pushNewline(); + return yield* this.parseLineStart(); + case "{": + case "[": + yield* this.pushCount(1); + this.flowKey = false; + this.flowLevel = 1; + return "flow"; + case "}": + case "]": + yield* this.pushCount(1); + return "doc"; + case "*": + yield* this.pushUntil(isNotAnchorChar); + return "doc"; + case '"': + case "'": + return yield* this.parseQuotedScalar(); + case "|": + case ">": + n += yield* this.parseBlockScalarHeader(); + n += yield* this.pushSpaces(true); + yield* this.pushCount(line.length - n); + yield* this.pushNewline(); + return yield* this.parseBlockScalar(); + default: + return yield* this.parsePlainScalar(); + } } - - super('UNDICI_REQUEST') - } catch (err) { - if (util.isStream(body)) { - util.destroy(body.on('error', util.nop), err) + *parseFlowCollection() { + let nl, sp; + let indent = -1; + do { + nl = yield* this.pushNewline(); + if (nl > 0) { + sp = yield* this.pushSpaces(false); + this.indentValue = indent = sp; + } else { + sp = 0; + } + sp += yield* this.pushSpaces(true); + } while (nl + sp > 0); + const line = this.getLine(); + if (line === null) + return this.setNext("flow"); + if (indent !== -1 && indent < this.indentNext && line[0] !== "#" || indent === 0 && (line.startsWith("---") || line.startsWith("...")) && isEmpty(line[3])) { + const atFlowEndMarker = indent === this.indentNext - 1 && this.flowLevel === 1 && (line[0] === "]" || line[0] === "}"); + if (!atFlowEndMarker) { + this.flowLevel = 0; + yield cst.FLOW_END; + return yield* this.parseLineStart(); + } + } + let n = 0; + while (line[n] === ",") { + n += yield* this.pushCount(1); + n += yield* this.pushSpaces(true); + this.flowKey = false; + } + n += yield* this.pushIndicators(); + switch (line[n]) { + case void 0: + return "flow"; + case "#": + yield* this.pushCount(line.length - n); + return "flow"; + case "{": + case "[": + yield* this.pushCount(1); + this.flowKey = false; + this.flowLevel += 1; + return "flow"; + case "}": + case "]": + yield* this.pushCount(1); + this.flowKey = true; + this.flowLevel -= 1; + return this.flowLevel ? "flow" : "doc"; + case "*": + yield* this.pushUntil(isNotAnchorChar); + return "flow"; + case '"': + case "'": + this.flowKey = true; + return yield* this.parseQuotedScalar(); + case ":": { + const next = this.charAt(1); + if (this.flowKey || isEmpty(next) || next === ",") { + this.flowKey = false; + yield* this.pushCount(1); + yield* this.pushSpaces(true); + return "flow"; + } + } + // fallthrough + default: + this.flowKey = false; + return yield* this.parsePlainScalar(); + } } - throw err - } - - this.responseHeaders = responseHeaders || null - this.opaque = opaque || null - this.callback = callback - this.res = null - this.abort = null - this.body = body - this.trailers = {} - this.context = null - this.onInfo = onInfo || null - this.throwOnError = throwOnError - this.highWaterMark = highWaterMark - - if (util.isStream(body)) { - body.on('error', (err) => { - this.onError(err) - }) - } - - addSignal(this, signal) - } - - onConnect (abort, context) { - if (!this.callback) { - throw new RequestAbortedError() - } - - this.abort = abort - this.context = context - } - - onHeaders (statusCode, rawHeaders, resume, statusMessage) { - const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this - - const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) - - if (statusCode < 200) { - if (this.onInfo) { - this.onInfo({ statusCode, headers }) + *parseQuotedScalar() { + const quote = this.charAt(0); + let end = this.buffer.indexOf(quote, this.pos + 1); + if (quote === "'") { + while (end !== -1 && this.buffer[end + 1] === "'") + end = this.buffer.indexOf("'", end + 2); + } else { + while (end !== -1) { + let n = 0; + while (this.buffer[end - 1 - n] === "\\") + n += 1; + if (n % 2 === 0) + break; + end = this.buffer.indexOf('"', end + 1); + } + } + const qb = this.buffer.substring(0, end); + let nl = qb.indexOf("\n", this.pos); + if (nl !== -1) { + while (nl !== -1) { + const cs = this.continueScalar(nl + 1); + if (cs === -1) + break; + nl = qb.indexOf("\n", cs); + } + if (nl !== -1) { + end = nl - (qb[nl - 1] === "\r" ? 2 : 1); + } + } + if (end === -1) { + if (!this.atEnd) + return this.setNext("quoted-scalar"); + end = this.buffer.length; + } + yield* this.pushToIndex(end + 1, false); + return this.flowLevel ? "flow" : "doc"; } - return - } - - const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers - const contentType = parsedHeaders['content-type'] - const body = new Readable({ resume, abort, contentType, highWaterMark }) - - this.callback = null - this.res = body - if (callback !== null) { - if (this.throwOnError && statusCode >= 400) { - this.runInAsyncScope(getResolveErrorBodyCallback, null, - { callback, body, contentType, statusCode, statusMessage, headers } - ) - } else { - this.runInAsyncScope(callback, null, null, { - statusCode, - headers, - trailers: this.trailers, - opaque, - body, - context - }) + *parseBlockScalarHeader() { + this.blockScalarIndent = -1; + this.blockScalarKeep = false; + let i = this.pos; + while (true) { + const ch = this.buffer[++i]; + if (ch === "+") + this.blockScalarKeep = true; + else if (ch > "0" && ch <= "9") + this.blockScalarIndent = Number(ch) - 1; + else if (ch !== "-") + break; + } + return yield* this.pushUntil((ch) => isEmpty(ch) || ch === "#"); } - } - } - - onData (chunk) { - const { res } = this - return res.push(chunk) - } - - onComplete (trailers) { - const { res } = this - - removeSignal(this) - - util.parseHeaders(trailers, this.trailers) - - res.push(null) - } - - onError (err) { - const { res, callback, body, opaque } = this - - removeSignal(this) - - if (callback) { - // TODO: Does this need queueMicrotask? - this.callback = null - queueMicrotask(() => { - this.runInAsyncScope(callback, null, err, { opaque }) - }) - } - - if (res) { - this.res = null - // Ensure all queued handlers are invoked before destroying res. - queueMicrotask(() => { - util.destroy(res, err) - }) - } - - if (body) { - this.body = null - util.destroy(body, err) - } - } -} - -function request (opts, callback) { - if (callback === undefined) { - return new Promise((resolve, reject) => { - request.call(this, opts, (err, data) => { - return err ? reject(err) : resolve(data) - }) - }) - } - - try { - this.dispatch(opts, new RequestHandler(opts, callback)) - } catch (err) { - if (typeof callback !== 'function') { - throw err - } - const opaque = opts && opts.opaque - queueMicrotask(() => callback(err, { opaque })) - } -} - -module.exports = request -module.exports.RequestHandler = RequestHandler - - -/***/ }), - -/***/ 3560: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { finished, PassThrough } = __nccwpck_require__(2203) -const { - InvalidArgumentError, - InvalidReturnValueError, - RequestAbortedError -} = __nccwpck_require__(8707) -const util = __nccwpck_require__(3440) -const { getResolveErrorBodyCallback } = __nccwpck_require__(7655) -const { AsyncResource } = __nccwpck_require__(290) -const { addSignal, removeSignal } = __nccwpck_require__(158) - -class StreamHandler extends AsyncResource { - constructor (opts, factory, callback) { - if (!opts || typeof opts !== 'object') { - throw new InvalidArgumentError('invalid opts') - } - - const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts - - try { - if (typeof callback !== 'function') { - throw new InvalidArgumentError('invalid callback') + *parseBlockScalar() { + let nl = this.pos - 1; + let indent = 0; + let ch; + loop: for (let i2 = this.pos; ch = this.buffer[i2]; ++i2) { + switch (ch) { + case " ": + indent += 1; + break; + case "\n": + nl = i2; + indent = 0; + break; + case "\r": { + const next = this.buffer[i2 + 1]; + if (!next && !this.atEnd) + return this.setNext("block-scalar"); + if (next === "\n") + break; + } + // fallthrough + default: + break loop; + } + } + if (!ch && !this.atEnd) + return this.setNext("block-scalar"); + if (indent >= this.indentNext) { + if (this.blockScalarIndent === -1) + this.indentNext = indent; + else { + this.indentNext = this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext); + } + do { + const cs = this.continueScalar(nl + 1); + if (cs === -1) + break; + nl = this.buffer.indexOf("\n", cs); + } while (nl !== -1); + if (nl === -1) { + if (!this.atEnd) + return this.setNext("block-scalar"); + nl = this.buffer.length; + } + } + let i = nl + 1; + ch = this.buffer[i]; + while (ch === " ") + ch = this.buffer[++i]; + if (ch === " ") { + while (ch === " " || ch === " " || ch === "\r" || ch === "\n") + ch = this.buffer[++i]; + nl = i - 1; + } else if (!this.blockScalarKeep) { + do { + let i2 = nl - 1; + let ch2 = this.buffer[i2]; + if (ch2 === "\r") + ch2 = this.buffer[--i2]; + const lastChar = i2; + while (ch2 === " ") + ch2 = this.buffer[--i2]; + if (ch2 === "\n" && i2 >= this.pos && i2 + 1 + indent > lastChar) + nl = i2; + else + break; + } while (true); + } + yield cst.SCALAR; + yield* this.pushToIndex(nl + 1, true); + return yield* this.parseLineStart(); } - - if (typeof factory !== 'function') { - throw new InvalidArgumentError('invalid factory') + *parsePlainScalar() { + const inFlow = this.flowLevel > 0; + let end = this.pos - 1; + let i = this.pos - 1; + let ch; + while (ch = this.buffer[++i]) { + if (ch === ":") { + const next = this.buffer[i + 1]; + if (isEmpty(next) || inFlow && flowIndicatorChars.has(next)) + break; + end = i; + } else if (isEmpty(ch)) { + let next = this.buffer[i + 1]; + if (ch === "\r") { + if (next === "\n") { + i += 1; + ch = "\n"; + next = this.buffer[i + 1]; + } else + end = i; + } + if (next === "#" || inFlow && flowIndicatorChars.has(next)) + break; + if (ch === "\n") { + const cs = this.continueScalar(i + 1); + if (cs === -1) + break; + i = Math.max(i, cs - 2); + } + } else { + if (inFlow && flowIndicatorChars.has(ch)) + break; + end = i; + } + } + if (!ch && !this.atEnd) + return this.setNext("plain-scalar"); + yield cst.SCALAR; + yield* this.pushToIndex(end + 1, true); + return inFlow ? "flow" : "doc"; } - - if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { - throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + *pushCount(n) { + if (n > 0) { + yield this.buffer.substr(this.pos, n); + this.pos += n; + return n; + } + return 0; } - - if (method === 'CONNECT') { - throw new InvalidArgumentError('invalid method') + *pushToIndex(i, allowEmpty) { + const s = this.buffer.slice(this.pos, i); + if (s) { + yield s; + this.pos += s.length; + return s.length; + } else if (allowEmpty) + yield ""; + return 0; } - - if (onInfo && typeof onInfo !== 'function') { - throw new InvalidArgumentError('invalid onInfo callback') + *pushIndicators() { + switch (this.charAt(0)) { + case "!": + return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators()); + case "&": + return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators()); + case "-": + // this is an error + case "?": + // this is an error outside flow collections + case ":": { + const inFlow = this.flowLevel > 0; + const ch1 = this.charAt(1); + if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) { + if (!inFlow) + this.indentNext = this.indentValue + 1; + else if (this.flowKey) + this.flowKey = false; + return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators()); + } + } + } + return 0; } - - super('UNDICI_STREAM') - } catch (err) { - if (util.isStream(body)) { - util.destroy(body.on('error', util.nop), err) + *pushTag() { + if (this.charAt(1) === "<") { + let i = this.pos + 2; + let ch = this.buffer[i]; + while (!isEmpty(ch) && ch !== ">") + ch = this.buffer[++i]; + return yield* this.pushToIndex(ch === ">" ? i + 1 : i, false); + } else { + let i = this.pos + 1; + let ch = this.buffer[i]; + while (ch) { + if (tagChars.has(ch)) + ch = this.buffer[++i]; + else if (ch === "%" && hexDigits.has(this.buffer[i + 1]) && hexDigits.has(this.buffer[i + 2])) { + ch = this.buffer[i += 3]; + } else + break; + } + return yield* this.pushToIndex(i, false); + } } - throw err - } - - this.responseHeaders = responseHeaders || null - this.opaque = opaque || null - this.factory = factory - this.callback = callback - this.res = null - this.abort = null - this.context = null - this.trailers = null - this.body = body - this.onInfo = onInfo || null - this.throwOnError = throwOnError || false - - if (util.isStream(body)) { - body.on('error', (err) => { - this.onError(err) - }) - } - - addSignal(this, signal) - } - - onConnect (abort, context) { - if (!this.callback) { - throw new RequestAbortedError() - } - - this.abort = abort - this.context = context - } - - onHeaders (statusCode, rawHeaders, resume, statusMessage) { - const { factory, opaque, context, callback, responseHeaders } = this - - const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) - - if (statusCode < 200) { - if (this.onInfo) { - this.onInfo({ statusCode, headers }) + *pushNewline() { + const ch = this.buffer[this.pos]; + if (ch === "\n") + return yield* this.pushCount(1); + else if (ch === "\r" && this.charAt(1) === "\n") + return yield* this.pushCount(2); + else + return 0; } - return - } - - this.factory = null - - let res - - if (this.throwOnError && statusCode >= 400) { - const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers - const contentType = parsedHeaders['content-type'] - res = new PassThrough() - - this.callback = null - this.runInAsyncScope(getResolveErrorBodyCallback, null, - { callback, body: res, contentType, statusCode, statusMessage, headers } - ) - } else { - if (factory === null) { - return + *pushSpaces(allowTabs) { + let i = this.pos - 1; + let ch; + do { + ch = this.buffer[++i]; + } while (ch === " " || allowTabs && ch === " "); + const n = i - this.pos; + if (n > 0) { + yield this.buffer.substr(this.pos, n); + this.pos = i; + } + return n; } - - res = this.runInAsyncScope(factory, null, { - statusCode, - headers, - opaque, - context - }) - - if ( - !res || - typeof res.write !== 'function' || - typeof res.end !== 'function' || - typeof res.on !== 'function' - ) { - throw new InvalidReturnValueError('expected Writable') + *pushUntil(test) { + let i = this.pos; + let ch = this.buffer[i]; + while (!test(ch)) + ch = this.buffer[++i]; + return yield* this.pushToIndex(i, false); } - - // TODO: Avoid finished. It registers an unnecessary amount of listeners. - finished(res, { readable: false }, (err) => { - const { callback, res, opaque, trailers, abort } = this - - this.res = null - if (err || !res.readable) { - util.destroy(res, err) - } - - this.callback = null - this.runInAsyncScope(callback, null, err || null, { opaque, trailers }) - - if (err) { - abort() - } - }) - } - - res.on('drain', resume) - - this.res = res - - const needDrain = res.writableNeedDrain !== undefined - ? res.writableNeedDrain - : res._writableState && res._writableState.needDrain - - return needDrain !== true - } - - onData (chunk) { - const { res } = this - - return res ? res.write(chunk) : true - } - - onComplete (trailers) { - const { res } = this - - removeSignal(this) - - if (!res) { - return - } - - this.trailers = util.parseHeaders(trailers) - - res.end() - } - - onError (err) { - const { res, callback, opaque, body } = this - - removeSignal(this) - - this.factory = null - - if (res) { - this.res = null - util.destroy(res, err) - } else if (callback) { - this.callback = null - queueMicrotask(() => { - this.runInAsyncScope(callback, null, err, { opaque }) - }) - } - - if (body) { - this.body = null - util.destroy(body, err) - } - } -} - -function stream (opts, factory, callback) { - if (callback === undefined) { - return new Promise((resolve, reject) => { - stream.call(this, opts, factory, (err, data) => { - return err ? reject(err) : resolve(data) - }) - }) + }; + exports2.Lexer = Lexer; } +}); - try { - this.dispatch(opts, new StreamHandler(opts, factory, callback)) - } catch (err) { - if (typeof callback !== 'function') { - throw err - } - const opaque = opts && opts.opaque - queueMicrotask(() => callback(err, { opaque })) +// node_modules/yaml/dist/parse/line-counter.js +var require_line_counter = __commonJS({ + "node_modules/yaml/dist/parse/line-counter.js"(exports2) { + "use strict"; + var LineCounter = class { + constructor() { + this.lineStarts = []; + this.addNewLine = (offset) => this.lineStarts.push(offset); + this.linePos = (offset) => { + let low = 0; + let high = this.lineStarts.length; + while (low < high) { + const mid = low + high >> 1; + if (this.lineStarts[mid] < offset) + low = mid + 1; + else + high = mid; + } + if (this.lineStarts[low] === offset) + return { line: low + 1, col: 1 }; + if (low === 0) + return { line: 0, col: offset }; + const start = this.lineStarts[low - 1]; + return { line: low, col: offset - start + 1 }; + }; + } + }; + exports2.LineCounter = LineCounter; } -} - -module.exports = stream - - -/***/ }), - -/***/ 1882: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { InvalidArgumentError, RequestAbortedError, SocketError } = __nccwpck_require__(8707) -const { AsyncResource } = __nccwpck_require__(290) -const util = __nccwpck_require__(3440) -const { addSignal, removeSignal } = __nccwpck_require__(158) -const assert = __nccwpck_require__(2613) +}); -class UpgradeHandler extends AsyncResource { - constructor (opts, callback) { - if (!opts || typeof opts !== 'object') { - throw new InvalidArgumentError('invalid opts') +// node_modules/yaml/dist/parse/parser.js +var require_parser = __commonJS({ + "node_modules/yaml/dist/parse/parser.js"(exports2) { + "use strict"; + var node_process = require("process"); + var cst = require_cst(); + var lexer = require_lexer(); + function includesToken(list, type) { + for (let i = 0; i < list.length; ++i) + if (list[i].type === type) + return true; + return false; } - - if (typeof callback !== 'function') { - throw new InvalidArgumentError('invalid callback') + function findNonEmptyIndex(list) { + for (let i = 0; i < list.length; ++i) { + switch (list[i].type) { + case "space": + case "comment": + case "newline": + break; + default: + return i; + } + } + return -1; } - - const { signal, opaque, responseHeaders } = opts - - if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { - throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + function isFlowToken(token) { + switch (token?.type) { + case "alias": + case "scalar": + case "single-quoted-scalar": + case "double-quoted-scalar": + case "flow-collection": + return true; + default: + return false; + } } - - super('UNDICI_UPGRADE') - - this.responseHeaders = responseHeaders || null - this.opaque = opaque || null - this.callback = callback - this.abort = null - this.context = null - - addSignal(this, signal) - } - - onConnect (abort, context) { - if (!this.callback) { - throw new RequestAbortedError() + function getPrevProps(parent) { + switch (parent.type) { + case "document": + return parent.start; + case "block-map": { + const it = parent.items[parent.items.length - 1]; + return it.sep ?? it.start; + } + case "block-seq": + return parent.items[parent.items.length - 1].start; + /* istanbul ignore next should not happen */ + default: + return []; + } } - - this.abort = abort - this.context = null - } - - onHeaders () { - throw new SocketError('bad upgrade', null) - } - - onUpgrade (statusCode, rawHeaders, socket) { - const { callback, opaque, context } = this - - assert.strictEqual(statusCode, 101) - - removeSignal(this) - - this.callback = null - const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) - this.runInAsyncScope(callback, null, null, { - headers, - socket, - opaque, - context - }) - } - - onError (err) { - const { callback, opaque } = this - - removeSignal(this) - - if (callback) { - this.callback = null - queueMicrotask(() => { - this.runInAsyncScope(callback, null, err, { opaque }) - }) + function getFirstKeyStartProps(prev) { + if (prev.length === 0) + return []; + let i = prev.length; + loop: while (--i >= 0) { + switch (prev[i].type) { + case "doc-start": + case "explicit-key-ind": + case "map-value-ind": + case "seq-item-ind": + case "newline": + break loop; + } + } + while (prev[++i]?.type === "space") { + } + return prev.splice(i, prev.length); } - } -} - -function upgrade (opts, callback) { - if (callback === undefined) { - return new Promise((resolve, reject) => { - upgrade.call(this, opts, (err, data) => { - return err ? reject(err) : resolve(data) - }) - }) - } - - try { - const upgradeHandler = new UpgradeHandler(opts, callback) - this.dispatch({ - ...opts, - method: opts.method || 'GET', - upgrade: opts.protocol || 'Websocket' - }, upgradeHandler) - } catch (err) { - if (typeof callback !== 'function') { - throw err + function fixFlowSeqItems(fc) { + if (fc.start.type === "flow-seq-start") { + for (const it of fc.items) { + if (it.sep && !it.value && !includesToken(it.start, "explicit-key-ind") && !includesToken(it.sep, "map-value-ind")) { + if (it.key) + it.value = it.key; + delete it.key; + if (isFlowToken(it.value)) { + if (it.value.end) + Array.prototype.push.apply(it.value.end, it.sep); + else + it.value.end = it.sep; + } else + Array.prototype.push.apply(it.start, it.sep); + delete it.sep; + } + } + } } - const opaque = opts && opts.opaque - queueMicrotask(() => callback(err, { opaque })) - } -} - -module.exports = upgrade - - -/***/ }), - -/***/ 6615: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -module.exports.request = __nccwpck_require__(6424) -module.exports.stream = __nccwpck_require__(3560) -module.exports.pipeline = __nccwpck_require__(6862) -module.exports.upgrade = __nccwpck_require__(1882) -module.exports.connect = __nccwpck_require__(4660) - - -/***/ }), - -/***/ 9927: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; -// Ported from https://github.com/nodejs/undici/pull/907 - - - -const assert = __nccwpck_require__(2613) -const { Readable } = __nccwpck_require__(2203) -const { RequestAbortedError, NotSupportedError, InvalidArgumentError } = __nccwpck_require__(8707) -const util = __nccwpck_require__(3440) -const { ReadableStreamFrom, toUSVString } = __nccwpck_require__(3440) - -let Blob - -const kConsume = Symbol('kConsume') -const kReading = Symbol('kReading') -const kBody = Symbol('kBody') -const kAbort = Symbol('abort') -const kContentType = Symbol('kContentType') - -const noop = () => {} - -module.exports = class BodyReadable extends Readable { - constructor ({ - resume, - abort, - contentType = '', - highWaterMark = 64 * 1024 // Same as nodejs fs streams. - }) { - super({ - autoDestroy: true, - read: resume, - highWaterMark - }) - - this._readableState.dataEmitted = false - - this[kAbort] = abort - this[kConsume] = null - this[kBody] = null - this[kContentType] = contentType - - // Is stream being consumed through Readable API? - // This is an optimization so that we avoid checking - // for 'data' and 'readable' listeners in the hot path - // inside push(). - this[kReading] = false - } - - destroy (err) { - if (this.destroyed) { - // Node < 16 - return this - } - - if (!err && !this._readableState.endEmitted) { - err = new RequestAbortedError() - } - - if (err) { - this[kAbort]() - } - - return super.destroy(err) - } - - emit (ev, ...args) { - if (ev === 'data') { - // Node < 16.7 - this._readableState.dataEmitted = true - } else if (ev === 'error') { - // Node < 16 - this._readableState.errorEmitted = true - } - return super.emit(ev, ...args) - } - - on (ev, ...args) { - if (ev === 'data' || ev === 'readable') { - this[kReading] = true - } - return super.on(ev, ...args) - } - - addListener (ev, ...args) { - return this.on(ev, ...args) - } - - off (ev, ...args) { - const ret = super.off(ev, ...args) - if (ev === 'data' || ev === 'readable') { - this[kReading] = ( - this.listenerCount('data') > 0 || - this.listenerCount('readable') > 0 - ) - } - return ret - } - - removeListener (ev, ...args) { - return this.off(ev, ...args) - } - - push (chunk) { - if (this[kConsume] && chunk !== null && this.readableLength === 0) { - consumePush(this[kConsume], chunk) - return this[kReading] ? super.push(chunk) : true - } - return super.push(chunk) - } - - // https://fetch.spec.whatwg.org/#dom-body-text - async text () { - return consume(this, 'text') - } - - // https://fetch.spec.whatwg.org/#dom-body-json - async json () { - return consume(this, 'json') - } - - // https://fetch.spec.whatwg.org/#dom-body-blob - async blob () { - return consume(this, 'blob') - } - - // https://fetch.spec.whatwg.org/#dom-body-arraybuffer - async arrayBuffer () { - return consume(this, 'arrayBuffer') - } - - // https://fetch.spec.whatwg.org/#dom-body-formdata - async formData () { - // TODO: Implement. - throw new NotSupportedError() - } - - // https://fetch.spec.whatwg.org/#dom-body-bodyused - get bodyUsed () { - return util.isDisturbed(this) - } - - // https://fetch.spec.whatwg.org/#dom-body-body - get body () { - if (!this[kBody]) { - this[kBody] = ReadableStreamFrom(this) - if (this[kConsume]) { - // TODO: Is this the best way to force a lock? - this[kBody].getReader() // Ensure stream is locked. - assert(this[kBody].locked) + var Parser = class { + /** + * @param onNewLine - If defined, called separately with the start position of + * each new line (in `parse()`, including the start of input). + */ + constructor(onNewLine) { + this.atNewLine = true; + this.atScalar = false; + this.indent = 0; + this.offset = 0; + this.onKeyLine = false; + this.stack = []; + this.source = ""; + this.type = ""; + this.lexer = new lexer.Lexer(); + this.onNewLine = onNewLine; } - } - return this[kBody] - } - - dump (opts) { - let limit = opts && Number.isFinite(opts.limit) ? opts.limit : 262144 - const signal = opts && opts.signal - - if (signal) { - try { - if (typeof signal !== 'object' || !('aborted' in signal)) { - throw new InvalidArgumentError('signal must be an AbortSignal') - } - util.throwIfAborted(signal) - } catch (err) { - return Promise.reject(err) + /** + * Parse `source` as a YAML stream. + * If `incomplete`, a part of the last line may be left as a buffer for the next call. + * + * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens. + * + * @returns A generator of tokens representing each directive, document, and other structure. + */ + *parse(source, incomplete = false) { + if (this.onNewLine && this.offset === 0) + this.onNewLine(0); + for (const lexeme of this.lexer.lex(source, incomplete)) + yield* this.next(lexeme); + if (!incomplete) + yield* this.end(); } - } - - if (this.closed) { - return Promise.resolve(null) - } - - return new Promise((resolve, reject) => { - const signalListenerCleanup = signal - ? util.addAbortListener(signal, () => { - this.destroy() - }) - : noop - - this - .on('close', function () { - signalListenerCleanup() - if (signal && signal.aborted) { - reject(signal.reason || Object.assign(new Error('The operation was aborted'), { name: 'AbortError' })) - } else { - resolve(null) - } - }) - .on('error', noop) - .on('data', function (chunk) { - limit -= chunk.length - if (limit <= 0) { - this.destroy() + /** + * Advance the parser by the `source` of one lexical token. + */ + *next(source) { + this.source = source; + if (node_process.env.LOG_TOKENS) + console.log("|", cst.prettyToken(source)); + if (this.atScalar) { + this.atScalar = false; + yield* this.step(); + this.offset += source.length; + return; + } + const type = cst.tokenType(source); + if (!type) { + const message = `Not a YAML token: ${source}`; + yield* this.pop({ type: "error", offset: this.offset, message, source }); + this.offset += source.length; + } else if (type === "scalar") { + this.atNewLine = false; + this.atScalar = true; + this.type = "scalar"; + } else { + this.type = type; + yield* this.step(); + switch (type) { + case "newline": + this.atNewLine = true; + this.indent = 0; + if (this.onNewLine) + this.onNewLine(this.offset + source.length); + break; + case "space": + if (this.atNewLine && source[0] === " ") + this.indent += source.length; + break; + case "explicit-key-ind": + case "map-value-ind": + case "seq-item-ind": + if (this.atNewLine) + this.indent += source.length; + break; + case "doc-mode": + case "flow-error-end": + return; + default: + this.atNewLine = false; } - }) - .resume() - }) - } -} - -// https://streams.spec.whatwg.org/#readablestream-locked -function isLocked (self) { - // Consume is an implicit lock. - return (self[kBody] && self[kBody].locked === true) || self[kConsume] -} - -// https://fetch.spec.whatwg.org/#body-unusable -function isUnusable (self) { - return util.isDisturbed(self) || isLocked(self) -} - -async function consume (stream, type) { - if (isUnusable(stream)) { - throw new TypeError('unusable') - } - - assert(!stream[kConsume]) - - return new Promise((resolve, reject) => { - stream[kConsume] = { - type, - stream, - resolve, - reject, - length: 0, - body: [] - } - - stream - .on('error', function (err) { - consumeFinish(this[kConsume], err) - }) - .on('close', function () { - if (this[kConsume].body !== null) { - consumeFinish(this[kConsume], new RequestAbortedError()) + this.offset += source.length; } - }) - - process.nextTick(consumeStart, stream[kConsume]) - }) -} - -function consumeStart (consume) { - if (consume.body === null) { - return - } - - const { _readableState: state } = consume.stream - - for (const chunk of state.buffer) { - consumePush(consume, chunk) - } - - if (state.endEmitted) { - consumeEnd(this[kConsume]) - } else { - consume.stream.on('end', function () { - consumeEnd(this[kConsume]) - }) - } - - consume.stream.resume() - - while (consume.stream.read() != null) { - // Loop - } -} - -function consumeEnd (consume) { - const { type, body, resolve, stream, length } = consume - - try { - if (type === 'text') { - resolve(toUSVString(Buffer.concat(body))) - } else if (type === 'json') { - resolve(JSON.parse(Buffer.concat(body))) - } else if (type === 'arrayBuffer') { - const dst = new Uint8Array(length) - - let pos = 0 - for (const buf of body) { - dst.set(buf, pos) - pos += buf.byteLength } - - resolve(dst.buffer) - } else if (type === 'blob') { - if (!Blob) { - Blob = (__nccwpck_require__(181).Blob) + /** Call at end of input to push out any remaining constructions */ + *end() { + while (this.stack.length > 0) + yield* this.pop(); } - resolve(new Blob(body, { type: stream[kContentType] })) - } - - consumeFinish(consume) - } catch (err) { - stream.destroy(err) - } -} - -function consumePush (consume, chunk) { - consume.length += chunk.length - consume.body.push(chunk) -} - -function consumeFinish (consume, err) { - if (consume.body === null) { - return - } - - if (err) { - consume.reject(err) - } else { - consume.resolve() - } - - consume.type = null - consume.stream = null - consume.resolve = null - consume.reject = null - consume.length = 0 - consume.body = null -} - - -/***/ }), - -/***/ 7655: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -const assert = __nccwpck_require__(2613) -const { - ResponseStatusCodeError -} = __nccwpck_require__(8707) -const { toUSVString } = __nccwpck_require__(3440) - -async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) { - assert(body) - - let chunks = [] - let limit = 0 - - for await (const chunk of body) { - chunks.push(chunk) - limit += chunk.length - if (limit > 128 * 1024) { - chunks = null - break - } - } - - if (statusCode === 204 || !contentType || !chunks) { - process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers)) - return - } - - try { - if (contentType.startsWith('application/json')) { - const payload = JSON.parse(toUSVString(Buffer.concat(chunks))) - process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers, payload)) - return - } - - if (contentType.startsWith('text/')) { - const payload = toUSVString(Buffer.concat(chunks)) - process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers, payload)) - return - } - } catch (err) { - // Process in a fallback if error - } - - process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`, statusCode, headers)) -} - -module.exports = { getResolveErrorBodyCallback } - - -/***/ }), - -/***/ 1093: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { - BalancedPoolMissingUpstreamError, - InvalidArgumentError -} = __nccwpck_require__(8707) -const { - PoolBase, - kClients, - kNeedDrain, - kAddClient, - kRemoveClient, - kGetDispatcher -} = __nccwpck_require__(8640) -const Pool = __nccwpck_require__(5076) -const { kUrl, kInterceptors } = __nccwpck_require__(6443) -const { parseOrigin } = __nccwpck_require__(3440) -const kFactory = Symbol('factory') - -const kOptions = Symbol('options') -const kGreatestCommonDivisor = Symbol('kGreatestCommonDivisor') -const kCurrentWeight = Symbol('kCurrentWeight') -const kIndex = Symbol('kIndex') -const kWeight = Symbol('kWeight') -const kMaxWeightPerServer = Symbol('kMaxWeightPerServer') -const kErrorPenalty = Symbol('kErrorPenalty') - -function getGreatestCommonDivisor (a, b) { - if (b === 0) return a - return getGreatestCommonDivisor(b, a % b) -} - -function defaultFactory (origin, opts) { - return new Pool(origin, opts) -} - -class BalancedPool extends PoolBase { - constructor (upstreams = [], { factory = defaultFactory, ...opts } = {}) { - super() - - this[kOptions] = opts - this[kIndex] = -1 - this[kCurrentWeight] = 0 - - this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100 - this[kErrorPenalty] = this[kOptions].errorPenalty || 15 - - if (!Array.isArray(upstreams)) { - upstreams = [upstreams] - } - - if (typeof factory !== 'function') { - throw new InvalidArgumentError('factory must be a function.') - } - - this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) - ? opts.interceptors.BalancedPool - : [] - this[kFactory] = factory - - for (const upstream of upstreams) { - this.addUpstream(upstream) - } - this._updateBalancedPoolStats() - } - - addUpstream (upstream) { - const upstreamOrigin = parseOrigin(upstream).origin - - if (this[kClients].find((pool) => ( - pool[kUrl].origin === upstreamOrigin && - pool.closed !== true && - pool.destroyed !== true - ))) { - return this - } - const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions])) - - this[kAddClient](pool) - pool.on('connect', () => { - pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]) - }) - - pool.on('connectionError', () => { - pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]) - this._updateBalancedPoolStats() - }) - - pool.on('disconnect', (...args) => { - const err = args[2] - if (err && err.code === 'UND_ERR_SOCKET') { - // decrease the weight of the pool. - pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]) - this._updateBalancedPoolStats() - } - }) - - for (const client of this[kClients]) { - client[kWeight] = this[kMaxWeightPerServer] - } - - this._updateBalancedPoolStats() - - return this - } - - _updateBalancedPoolStats () { - this[kGreatestCommonDivisor] = this[kClients].map(p => p[kWeight]).reduce(getGreatestCommonDivisor, 0) - } - - removeUpstream (upstream) { - const upstreamOrigin = parseOrigin(upstream).origin - - const pool = this[kClients].find((pool) => ( - pool[kUrl].origin === upstreamOrigin && - pool.closed !== true && - pool.destroyed !== true - )) - - if (pool) { - this[kRemoveClient](pool) - } - - return this - } - - get upstreams () { - return this[kClients] - .filter(dispatcher => dispatcher.closed !== true && dispatcher.destroyed !== true) - .map((p) => p[kUrl].origin) - } - - [kGetDispatcher] () { - // We validate that pools is greater than 0, - // otherwise we would have to wait until an upstream - // is added, which might never happen. - if (this[kClients].length === 0) { - throw new BalancedPoolMissingUpstreamError() - } - - const dispatcher = this[kClients].find(dispatcher => ( - !dispatcher[kNeedDrain] && - dispatcher.closed !== true && - dispatcher.destroyed !== true - )) - - if (!dispatcher) { - return - } - - const allClientsBusy = this[kClients].map(pool => pool[kNeedDrain]).reduce((a, b) => a && b, true) - - if (allClientsBusy) { - return - } - - let counter = 0 - - let maxWeightIndex = this[kClients].findIndex(pool => !pool[kNeedDrain]) - - while (counter++ < this[kClients].length) { - this[kIndex] = (this[kIndex] + 1) % this[kClients].length - const pool = this[kClients][this[kIndex]] - - // find pool index with the largest weight - if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) { - maxWeightIndex = this[kIndex] + get sourceToken() { + const st = { + type: this.type, + offset: this.offset, + indent: this.indent, + source: this.source + }; + return st; } - - // decrease the current weight every `this[kClients].length`. - if (this[kIndex] === 0) { - // Set the current weight to the next lower weight. - this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor] - - if (this[kCurrentWeight] <= 0) { - this[kCurrentWeight] = this[kMaxWeightPerServer] + *step() { + const top = this.peek(1); + if (this.type === "doc-end" && (!top || top.type !== "doc-end")) { + while (this.stack.length > 0) + yield* this.pop(); + this.stack.push({ + type: "doc-end", + offset: this.offset, + source: this.source + }); + return; + } + if (!top) + return yield* this.stream(); + switch (top.type) { + case "document": + return yield* this.document(top); + case "alias": + case "scalar": + case "single-quoted-scalar": + case "double-quoted-scalar": + return yield* this.scalar(top); + case "block-scalar": + return yield* this.blockScalar(top); + case "block-map": + return yield* this.blockMap(top); + case "block-seq": + return yield* this.blockSequence(top); + case "flow-collection": + return yield* this.flowCollection(top); + case "doc-end": + return yield* this.documentEnd(top); } + yield* this.pop(); } - if (pool[kWeight] >= this[kCurrentWeight] && (!pool[kNeedDrain])) { - return pool + peek(n) { + return this.stack[this.stack.length - n]; } - } - - this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight] - this[kIndex] = maxWeightIndex - return this[kClients][maxWeightIndex] - } -} - -module.exports = BalancedPool - - -/***/ }), - -/***/ 479: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { kConstruct } = __nccwpck_require__(296) -const { urlEquals, fieldValues: getFieldValues } = __nccwpck_require__(3993) -const { kEnumerableProperty, isDisturbed } = __nccwpck_require__(3440) -const { kHeadersList } = __nccwpck_require__(6443) -const { webidl } = __nccwpck_require__(4222) -const { Response, cloneResponse } = __nccwpck_require__(8676) -const { Request } = __nccwpck_require__(5194) -const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(9710) -const { fetching } = __nccwpck_require__(2315) -const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = __nccwpck_require__(5523) -const assert = __nccwpck_require__(2613) -const { getGlobalDispatcher } = __nccwpck_require__(2581) - -/** - * @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation - * @typedef {Object} CacheBatchOperation - * @property {'delete' | 'put'} type - * @property {any} request - * @property {any} response - * @property {import('../../types/cache').CacheQueryOptions} options - */ - -/** - * @see https://w3c.github.io/ServiceWorker/#dfn-request-response-list - * @typedef {[any, any][]} requestResponseList - */ - -class Cache { - /** - * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list - * @type {requestResponseList} - */ - #relevantRequestResponseList - - constructor () { - if (arguments[0] !== kConstruct) { - webidl.illegalConstructor() - } - - this.#relevantRequestResponseList = arguments[1] - } - - async match (request, options = {}) { - webidl.brandCheck(this, Cache) - webidl.argumentLengthCheck(arguments, 1, { header: 'Cache.match' }) - - request = webidl.converters.RequestInfo(request) - options = webidl.converters.CacheQueryOptions(options) - - const p = await this.matchAll(request, options) - - if (p.length === 0) { - return - } - - return p[0] - } - - async matchAll (request = undefined, options = {}) { - webidl.brandCheck(this, Cache) - - if (request !== undefined) request = webidl.converters.RequestInfo(request) - options = webidl.converters.CacheQueryOptions(options) - - // 1. - let r = null - - // 2. - if (request !== undefined) { - if (request instanceof Request) { - // 2.1.1 - r = request[kState] - - // 2.1.2 - if (r.method !== 'GET' && !options.ignoreMethod) { - return [] - } - } else if (typeof request === 'string') { - // 2.2.1 - r = new Request(request)[kState] - } - } - - // 5. - // 5.1 - const responses = [] - - // 5.2 - if (request === undefined) { - // 5.2.1 - for (const requestResponse of this.#relevantRequestResponseList) { - responses.push(requestResponse[1]) - } - } else { // 5.3 - // 5.3.1 - const requestResponses = this.#queryCache(r, options) - - // 5.3.2 - for (const requestResponse of requestResponses) { - responses.push(requestResponse[1]) - } - } - - // 5.4 - // We don't implement CORs so we don't need to loop over the responses, yay! - - // 5.5.1 - const responseList = [] - - // 5.5.2 - for (const response of responses) { - // 5.5.2.1 - const responseObject = new Response(response.body?.source ?? null) - const body = responseObject[kState].body - responseObject[kState] = response - responseObject[kState].body = body - responseObject[kHeaders][kHeadersList] = response.headersList - responseObject[kHeaders][kGuard] = 'immutable' - - responseList.push(responseObject) - } - - // 6. - return Object.freeze(responseList) - } - - async add (request) { - webidl.brandCheck(this, Cache) - webidl.argumentLengthCheck(arguments, 1, { header: 'Cache.add' }) - - request = webidl.converters.RequestInfo(request) - - // 1. - const requests = [request] - - // 2. - const responseArrayPromise = this.addAll(requests) - - // 3. - return await responseArrayPromise - } - - async addAll (requests) { - webidl.brandCheck(this, Cache) - webidl.argumentLengthCheck(arguments, 1, { header: 'Cache.addAll' }) - - requests = webidl.converters['sequence'](requests) - - // 1. - const responsePromises = [] - - // 2. - const requestList = [] - - // 3. - for (const request of requests) { - if (typeof request === 'string') { - continue - } - - // 3.1 - const r = request[kState] - - // 3.2 - if (!urlIsHttpHttpsScheme(r.url) || r.method !== 'GET') { - throw webidl.errors.exception({ - header: 'Cache.addAll', - message: 'Expected http/s scheme when method is not GET.' - }) - } - } - - // 4. - /** @type {ReturnType[]} */ - const fetchControllers = [] - - // 5. - for (const request of requests) { - // 5.1 - const r = new Request(request)[kState] - - // 5.2 - if (!urlIsHttpHttpsScheme(r.url)) { - throw webidl.errors.exception({ - header: 'Cache.addAll', - message: 'Expected http/s scheme.' - }) - } - - // 5.4 - r.initiator = 'fetch' - r.destination = 'subresource' - - // 5.5 - requestList.push(r) - - // 5.6 - const responsePromise = createDeferredPromise() - - // 5.7 - fetchControllers.push(fetching({ - request: r, - dispatcher: getGlobalDispatcher(), - processResponse (response) { - // 1. - if (response.type === 'error' || response.status === 206 || response.status < 200 || response.status > 299) { - responsePromise.reject(webidl.errors.exception({ - header: 'Cache.addAll', - message: 'Received an invalid status code or the request failed.' - })) - } else if (response.headersList.contains('vary')) { // 2. - // 2.1 - const fieldValues = getFieldValues(response.headersList.get('vary')) - - // 2.2 - for (const fieldValue of fieldValues) { - // 2.2.1 - if (fieldValue === '*') { - responsePromise.reject(webidl.errors.exception({ - header: 'Cache.addAll', - message: 'invalid vary field value' - })) - - for (const controller of fetchControllers) { - controller.abort() - } - - return + *pop(error2) { + const token = error2 ?? this.stack.pop(); + if (!token) { + const message = "Tried to pop an empty stack"; + yield { type: "error", offset: this.offset, source: "", message }; + } else if (this.stack.length === 0) { + yield token; + } else { + const top = this.peek(1); + if (token.type === "block-scalar") { + token.indent = "indent" in top ? top.indent : 0; + } else if (token.type === "flow-collection" && top.type === "document") { + token.indent = 0; + } + if (token.type === "flow-collection") + fixFlowSeqItems(token); + switch (top.type) { + case "document": + top.value = token; + break; + case "block-scalar": + top.props.push(token); + break; + case "block-map": { + const it = top.items[top.items.length - 1]; + if (it.value) { + top.items.push({ start: [], key: token, sep: [] }); + this.onKeyLine = true; + return; + } else if (it.sep) { + it.value = token; + } else { + Object.assign(it, { key: token, sep: [] }); + this.onKeyLine = !it.explicitKey; + return; } + break; + } + case "block-seq": { + const it = top.items[top.items.length - 1]; + if (it.value) + top.items.push({ start: [], value: token }); + else + it.value = token; + break; + } + case "flow-collection": { + const it = top.items[top.items.length - 1]; + if (!it || it.value) + top.items.push({ start: [], key: token, sep: [] }); + else if (it.sep) + it.value = token; + else + Object.assign(it, { key: token, sep: [] }); + return; } + /* istanbul ignore next should not happen */ + default: + yield* this.pop(); + yield* this.pop(token); } - }, - processResponseEndOfBody (response) { - // 1. - if (response.aborted) { - responsePromise.reject(new DOMException('aborted', 'AbortError')) - return + if ((top.type === "document" || top.type === "block-map" || top.type === "block-seq") && (token.type === "block-map" || token.type === "block-seq")) { + const last = token.items[token.items.length - 1]; + if (last && !last.sep && !last.value && last.start.length > 0 && findNonEmptyIndex(last.start) === -1 && (token.indent === 0 || last.start.every((st) => st.type !== "comment" || st.indent < token.indent))) { + if (top.type === "document") + top.end = last.start; + else + top.items.push({ start: last.start }); + token.items.splice(-1, 1); + } } - - // 2. - responsePromise.resolve(response) - } - })) - - // 5.8 - responsePromises.push(responsePromise.promise) - } - - // 6. - const p = Promise.all(responsePromises) - - // 7. - const responses = await p - - // 7.1 - const operations = [] - - // 7.2 - let index = 0 - - // 7.3 - for (const response of responses) { - // 7.3.1 - /** @type {CacheBatchOperation} */ - const operation = { - type: 'put', // 7.3.2 - request: requestList[index], // 7.3.3 - response // 7.3.4 - } - - operations.push(operation) // 7.3.5 - - index++ // 7.3.6 - } - - // 7.5 - const cacheJobPromise = createDeferredPromise() - - // 7.6.1 - let errorData = null - - // 7.6.2 - try { - this.#batchCacheOperations(operations) - } catch (e) { - errorData = e - } - - // 7.6.3 - queueMicrotask(() => { - // 7.6.3.1 - if (errorData === null) { - cacheJobPromise.resolve(undefined) - } else { - // 7.6.3.2 - cacheJobPromise.reject(errorData) - } - }) - - // 7.7 - return cacheJobPromise.promise - } - - async put (request, response) { - webidl.brandCheck(this, Cache) - webidl.argumentLengthCheck(arguments, 2, { header: 'Cache.put' }) - - request = webidl.converters.RequestInfo(request) - response = webidl.converters.Response(response) - - // 1. - let innerRequest = null - - // 2. - if (request instanceof Request) { - innerRequest = request[kState] - } else { // 3. - innerRequest = new Request(request)[kState] - } - - // 4. - if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== 'GET') { - throw webidl.errors.exception({ - header: 'Cache.put', - message: 'Expected an http/s scheme when method is not GET' - }) - } - - // 5. - const innerResponse = response[kState] - - // 6. - if (innerResponse.status === 206) { - throw webidl.errors.exception({ - header: 'Cache.put', - message: 'Got 206 status' - }) - } - - // 7. - if (innerResponse.headersList.contains('vary')) { - // 7.1. - const fieldValues = getFieldValues(innerResponse.headersList.get('vary')) - - // 7.2. - for (const fieldValue of fieldValues) { - // 7.2.1 - if (fieldValue === '*') { - throw webidl.errors.exception({ - header: 'Cache.put', - message: 'Got * vary field value' - }) } } - } - - // 8. - if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) { - throw webidl.errors.exception({ - header: 'Cache.put', - message: 'Response body is locked or disturbed' - }) - } - - // 9. - const clonedResponse = cloneResponse(innerResponse) - - // 10. - const bodyReadPromise = createDeferredPromise() - - // 11. - if (innerResponse.body != null) { - // 11.1 - const stream = innerResponse.body.stream - - // 11.2 - const reader = stream.getReader() - - // 11.3 - readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject) - } else { - bodyReadPromise.resolve(undefined) - } - - // 12. - /** @type {CacheBatchOperation[]} */ - const operations = [] - - // 13. - /** @type {CacheBatchOperation} */ - const operation = { - type: 'put', // 14. - request: innerRequest, // 15. - response: clonedResponse // 16. - } - - // 17. - operations.push(operation) - - // 19. - const bytes = await bodyReadPromise.promise - - if (clonedResponse.body != null) { - clonedResponse.body.source = bytes - } - - // 19.1 - const cacheJobPromise = createDeferredPromise() - - // 19.2.1 - let errorData = null - - // 19.2.2 - try { - this.#batchCacheOperations(operations) - } catch (e) { - errorData = e - } - - // 19.2.3 - queueMicrotask(() => { - // 19.2.3.1 - if (errorData === null) { - cacheJobPromise.resolve() - } else { // 19.2.3.2 - cacheJobPromise.reject(errorData) - } - }) - - return cacheJobPromise.promise - } - - async delete (request, options = {}) { - webidl.brandCheck(this, Cache) - webidl.argumentLengthCheck(arguments, 1, { header: 'Cache.delete' }) - - request = webidl.converters.RequestInfo(request) - options = webidl.converters.CacheQueryOptions(options) - - /** - * @type {Request} - */ - let r = null - - if (request instanceof Request) { - r = request[kState] - - if (r.method !== 'GET' && !options.ignoreMethod) { - return false - } - } else { - assert(typeof request === 'string') - - r = new Request(request)[kState] - } - - /** @type {CacheBatchOperation[]} */ - const operations = [] - - /** @type {CacheBatchOperation} */ - const operation = { - type: 'delete', - request: r, - options - } - - operations.push(operation) - - const cacheJobPromise = createDeferredPromise() - - let errorData = null - let requestResponses - - try { - requestResponses = this.#batchCacheOperations(operations) - } catch (e) { - errorData = e - } - - queueMicrotask(() => { - if (errorData === null) { - cacheJobPromise.resolve(!!requestResponses?.length) - } else { - cacheJobPromise.reject(errorData) - } - }) - - return cacheJobPromise.promise - } - - /** - * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys - * @param {any} request - * @param {import('../../types/cache').CacheQueryOptions} options - * @returns {readonly Request[]} - */ - async keys (request = undefined, options = {}) { - webidl.brandCheck(this, Cache) - - if (request !== undefined) request = webidl.converters.RequestInfo(request) - options = webidl.converters.CacheQueryOptions(options) - - // 1. - let r = null - - // 2. - if (request !== undefined) { - // 2.1 - if (request instanceof Request) { - // 2.1.1 - r = request[kState] - - // 2.1.2 - if (r.method !== 'GET' && !options.ignoreMethod) { - return [] + *stream() { + switch (this.type) { + case "directive-line": + yield { type: "directive", offset: this.offset, source: this.source }; + return; + case "byte-order-mark": + case "space": + case "comment": + case "newline": + yield this.sourceToken; + return; + case "doc-mode": + case "doc-start": { + const doc = { + type: "document", + offset: this.offset, + start: [] + }; + if (this.type === "doc-start") + doc.start.push(this.sourceToken); + this.stack.push(doc); + return; + } } - } else if (typeof request === 'string') { // 2.2 - r = new Request(request)[kState] - } - } - - // 4. - const promise = createDeferredPromise() - - // 5. - // 5.1 - const requests = [] - - // 5.2 - if (request === undefined) { - // 5.2.1 - for (const requestResponse of this.#relevantRequestResponseList) { - // 5.2.1.1 - requests.push(requestResponse[0]) - } - } else { // 5.3 - // 5.3.1 - const requestResponses = this.#queryCache(r, options) - - // 5.3.2 - for (const requestResponse of requestResponses) { - // 5.3.2.1 - requests.push(requestResponse[0]) - } - } - - // 5.4 - queueMicrotask(() => { - // 5.4.1 - const requestList = [] - - // 5.4.2 - for (const request of requests) { - const requestObject = new Request('https://a') - requestObject[kState] = request - requestObject[kHeaders][kHeadersList] = request.headersList - requestObject[kHeaders][kGuard] = 'immutable' - requestObject[kRealm] = request.client - - // 5.4.2.1 - requestList.push(requestObject) + yield { + type: "error", + offset: this.offset, + message: `Unexpected ${this.type} token in YAML stream`, + source: this.source + }; } - - // 5.4.3 - promise.resolve(Object.freeze(requestList)) - }) - - return promise.promise - } - - /** - * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm - * @param {CacheBatchOperation[]} operations - * @returns {requestResponseList} - */ - #batchCacheOperations (operations) { - // 1. - const cache = this.#relevantRequestResponseList - - // 2. - const backupCache = [...cache] - - // 3. - const addedItems = [] - - // 4.1 - const resultList = [] - - try { - // 4.2 - for (const operation of operations) { - // 4.2.1 - if (operation.type !== 'delete' && operation.type !== 'put') { - throw webidl.errors.exception({ - header: 'Cache.#batchCacheOperations', - message: 'operation type does not match "delete" or "put"' - }) + *document(doc) { + if (doc.value) + return yield* this.lineEnd(doc); + switch (this.type) { + case "doc-start": { + if (findNonEmptyIndex(doc.start) !== -1) { + yield* this.pop(); + yield* this.step(); + } else + doc.start.push(this.sourceToken); + return; + } + case "anchor": + case "tag": + case "space": + case "comment": + case "newline": + doc.start.push(this.sourceToken); + return; } - - // 4.2.2 - if (operation.type === 'delete' && operation.response != null) { - throw webidl.errors.exception({ - header: 'Cache.#batchCacheOperations', - message: 'delete operation should not have an associated response' - }) + const bv = this.startBlockValue(doc); + if (bv) + this.stack.push(bv); + else { + yield { + type: "error", + offset: this.offset, + message: `Unexpected ${this.type} token in YAML document`, + source: this.source + }; + } + } + *scalar(scalar) { + if (this.type === "map-value-ind") { + const prev = getPrevProps(this.peek(2)); + const start = getFirstKeyStartProps(prev); + let sep; + if (scalar.end) { + sep = scalar.end; + sep.push(this.sourceToken); + delete scalar.end; + } else + sep = [this.sourceToken]; + const map = { + type: "block-map", + offset: scalar.offset, + indent: scalar.indent, + items: [{ start, key: scalar, sep }] + }; + this.onKeyLine = true; + this.stack[this.stack.length - 1] = map; + } else + yield* this.lineEnd(scalar); + } + *blockScalar(scalar) { + switch (this.type) { + case "space": + case "comment": + case "newline": + scalar.props.push(this.sourceToken); + return; + case "scalar": + scalar.source = this.source; + this.atNewLine = true; + this.indent = 0; + if (this.onNewLine) { + let nl = this.source.indexOf("\n") + 1; + while (nl !== 0) { + this.onNewLine(this.offset + nl); + nl = this.source.indexOf("\n", nl) + 1; + } + } + yield* this.pop(); + break; + /* istanbul ignore next should not happen */ + default: + yield* this.pop(); + yield* this.step(); } - - // 4.2.3 - if (this.#queryCache(operation.request, operation.options, addedItems).length) { - throw new DOMException('???', 'InvalidStateError') + } + *blockMap(map) { + const it = map.items[map.items.length - 1]; + switch (this.type) { + case "newline": + this.onKeyLine = false; + if (it.value) { + const end = "end" in it.value ? it.value.end : void 0; + const last = Array.isArray(end) ? end[end.length - 1] : void 0; + if (last?.type === "comment") + end?.push(this.sourceToken); + else + map.items.push({ start: [this.sourceToken] }); + } else if (it.sep) { + it.sep.push(this.sourceToken); + } else { + it.start.push(this.sourceToken); + } + return; + case "space": + case "comment": + if (it.value) { + map.items.push({ start: [this.sourceToken] }); + } else if (it.sep) { + it.sep.push(this.sourceToken); + } else { + if (this.atIndentedComment(it.start, map.indent)) { + const prev = map.items[map.items.length - 2]; + const end = prev?.value?.end; + if (Array.isArray(end)) { + Array.prototype.push.apply(end, it.start); + end.push(this.sourceToken); + map.items.pop(); + return; + } + } + it.start.push(this.sourceToken); + } + return; } - - // 4.2.4 - let requestResponses - - // 4.2.5 - if (operation.type === 'delete') { - // 4.2.5.1 - requestResponses = this.#queryCache(operation.request, operation.options) - - // TODO: the spec is wrong, this is needed to pass WPTs - if (requestResponses.length === 0) { - return [] - } - - // 4.2.5.2 - for (const requestResponse of requestResponses) { - const idx = cache.indexOf(requestResponse) - assert(idx !== -1) - - // 4.2.5.2.1 - cache.splice(idx, 1) - } - } else if (operation.type === 'put') { // 4.2.6 - // 4.2.6.1 - if (operation.response == null) { - throw webidl.errors.exception({ - header: 'Cache.#batchCacheOperations', - message: 'put operation should have an associated response' - }) - } - - // 4.2.6.2 - const r = operation.request - - // 4.2.6.3 - if (!urlIsHttpHttpsScheme(r.url)) { - throw webidl.errors.exception({ - header: 'Cache.#batchCacheOperations', - message: 'expected http or https scheme' - }) - } - - // 4.2.6.4 - if (r.method !== 'GET') { - throw webidl.errors.exception({ - header: 'Cache.#batchCacheOperations', - message: 'not get method' - }) - } - - // 4.2.6.5 - if (operation.options != null) { - throw webidl.errors.exception({ - header: 'Cache.#batchCacheOperations', - message: 'options must not be defined' - }) + if (this.indent >= map.indent) { + const atMapIndent = !this.onKeyLine && this.indent === map.indent; + const atNextItem = atMapIndent && (it.sep || it.explicitKey) && this.type !== "seq-item-ind"; + let start = []; + if (atNextItem && it.sep && !it.value) { + const nl = []; + for (let i = 0; i < it.sep.length; ++i) { + const st = it.sep[i]; + switch (st.type) { + case "newline": + nl.push(i); + break; + case "space": + break; + case "comment": + if (st.indent > map.indent) + nl.length = 0; + break; + default: + nl.length = 0; + } + } + if (nl.length >= 2) + start = it.sep.splice(nl[1]); } - - // 4.2.6.6 - requestResponses = this.#queryCache(operation.request) - - // 4.2.6.7 - for (const requestResponse of requestResponses) { - const idx = cache.indexOf(requestResponse) - assert(idx !== -1) - - // 4.2.6.7.1 - cache.splice(idx, 1) + switch (this.type) { + case "anchor": + case "tag": + if (atNextItem || it.value) { + start.push(this.sourceToken); + map.items.push({ start }); + this.onKeyLine = true; + } else if (it.sep) { + it.sep.push(this.sourceToken); + } else { + it.start.push(this.sourceToken); + } + return; + case "explicit-key-ind": + if (!it.sep && !it.explicitKey) { + it.start.push(this.sourceToken); + it.explicitKey = true; + } else if (atNextItem || it.value) { + start.push(this.sourceToken); + map.items.push({ start, explicitKey: true }); + } else { + this.stack.push({ + type: "block-map", + offset: this.offset, + indent: this.indent, + items: [{ start: [this.sourceToken], explicitKey: true }] + }); + } + this.onKeyLine = true; + return; + case "map-value-ind": + if (it.explicitKey) { + if (!it.sep) { + if (includesToken(it.start, "newline")) { + Object.assign(it, { key: null, sep: [this.sourceToken] }); + } else { + const start2 = getFirstKeyStartProps(it.start); + this.stack.push({ + type: "block-map", + offset: this.offset, + indent: this.indent, + items: [{ start: start2, key: null, sep: [this.sourceToken] }] + }); + } + } else if (it.value) { + map.items.push({ start: [], key: null, sep: [this.sourceToken] }); + } else if (includesToken(it.sep, "map-value-ind")) { + this.stack.push({ + type: "block-map", + offset: this.offset, + indent: this.indent, + items: [{ start, key: null, sep: [this.sourceToken] }] + }); + } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) { + const start2 = getFirstKeyStartProps(it.start); + const key = it.key; + const sep = it.sep; + sep.push(this.sourceToken); + delete it.key; + delete it.sep; + this.stack.push({ + type: "block-map", + offset: this.offset, + indent: this.indent, + items: [{ start: start2, key, sep }] + }); + } else if (start.length > 0) { + it.sep = it.sep.concat(start, this.sourceToken); + } else { + it.sep.push(this.sourceToken); + } + } else { + if (!it.sep) { + Object.assign(it, { key: null, sep: [this.sourceToken] }); + } else if (it.value || atNextItem) { + map.items.push({ start, key: null, sep: [this.sourceToken] }); + } else if (includesToken(it.sep, "map-value-ind")) { + this.stack.push({ + type: "block-map", + offset: this.offset, + indent: this.indent, + items: [{ start: [], key: null, sep: [this.sourceToken] }] + }); + } else { + it.sep.push(this.sourceToken); + } + } + this.onKeyLine = true; + return; + case "alias": + case "scalar": + case "single-quoted-scalar": + case "double-quoted-scalar": { + const fs = this.flowScalar(this.type); + if (atNextItem || it.value) { + map.items.push({ start, key: fs, sep: [] }); + this.onKeyLine = true; + } else if (it.sep) { + this.stack.push(fs); + } else { + Object.assign(it, { key: fs, sep: [] }); + this.onKeyLine = true; + } + return; + } + default: { + const bv = this.startBlockValue(map); + if (bv) { + if (bv.type === "block-seq") { + if (!it.explicitKey && it.sep && !includesToken(it.sep, "newline")) { + yield* this.pop({ + type: "error", + offset: this.offset, + message: "Unexpected block-seq-ind on same line with key", + source: this.source + }); + return; + } + } else if (atMapIndent) { + map.items.push({ start }); + } + this.stack.push(bv); + return; + } + } } - - // 4.2.6.8 - cache.push([operation.request, operation.response]) - - // 4.2.6.10 - addedItems.push([operation.request, operation.response]) - } - - // 4.2.7 - resultList.push([operation.request, operation.response]) - } - - // 4.3 - return resultList - } catch (e) { // 5. - // 5.1 - this.#relevantRequestResponseList.length = 0 - - // 5.2 - this.#relevantRequestResponseList = backupCache - - // 5.3 - throw e - } - } - - /** - * @see https://w3c.github.io/ServiceWorker/#query-cache - * @param {any} requestQuery - * @param {import('../../types/cache').CacheQueryOptions} options - * @param {requestResponseList} targetStorage - * @returns {requestResponseList} - */ - #queryCache (requestQuery, options, targetStorage) { - /** @type {requestResponseList} */ - const resultList = [] - - const storage = targetStorage ?? this.#relevantRequestResponseList - - for (const requestResponse of storage) { - const [cachedRequest, cachedResponse] = requestResponse - if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) { - resultList.push(requestResponse) - } - } - - return resultList - } - - /** - * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm - * @param {any} requestQuery - * @param {any} request - * @param {any | null} response - * @param {import('../../types/cache').CacheQueryOptions | undefined} options - * @returns {boolean} - */ - #requestMatchesCachedItem (requestQuery, request, response = null, options) { - // if (options?.ignoreMethod === false && request.method === 'GET') { - // return false - // } - - const queryURL = new URL(requestQuery.url) - - const cachedURL = new URL(request.url) - - if (options?.ignoreSearch) { - cachedURL.search = '' - - queryURL.search = '' - } - - if (!urlEquals(queryURL, cachedURL, true)) { - return false - } - - if ( - response == null || - options?.ignoreVary || - !response.headersList.contains('vary') - ) { - return true - } - - const fieldValues = getFieldValues(response.headersList.get('vary')) - - for (const fieldValue of fieldValues) { - if (fieldValue === '*') { - return false - } - - const requestValue = request.headersList.get(fieldValue) - const queryValue = requestQuery.headersList.get(fieldValue) - - // If one has the header and the other doesn't, or one has - // a different value than the other, return false - if (requestValue !== queryValue) { - return false - } - } - - return true - } -} - -Object.defineProperties(Cache.prototype, { - [Symbol.toStringTag]: { - value: 'Cache', - configurable: true - }, - match: kEnumerableProperty, - matchAll: kEnumerableProperty, - add: kEnumerableProperty, - addAll: kEnumerableProperty, - put: kEnumerableProperty, - delete: kEnumerableProperty, - keys: kEnumerableProperty -}) - -const cacheQueryOptionConverters = [ - { - key: 'ignoreSearch', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'ignoreMethod', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'ignoreVary', - converter: webidl.converters.boolean, - defaultValue: false - } -] - -webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters) - -webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([ - ...cacheQueryOptionConverters, - { - key: 'cacheName', - converter: webidl.converters.DOMString - } -]) - -webidl.converters.Response = webidl.interfaceConverter(Response) - -webidl.converters['sequence'] = webidl.sequenceConverter( - webidl.converters.RequestInfo -) - -module.exports = { - Cache -} - - -/***/ }), - -/***/ 4738: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { kConstruct } = __nccwpck_require__(296) -const { Cache } = __nccwpck_require__(479) -const { webidl } = __nccwpck_require__(4222) -const { kEnumerableProperty } = __nccwpck_require__(3440) - -class CacheStorage { - /** - * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map - * @type {Map} - */ - async has (cacheName) { - webidl.brandCheck(this, CacheStorage) - webidl.argumentLengthCheck(arguments, 1, { header: 'CacheStorage.has' }) - - cacheName = webidl.converters.DOMString(cacheName) - - // 2.1.1 - // 2.2 - return this.#caches.has(cacheName) - } - - /** - * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open - * @param {string} cacheName - * @returns {Promise} - */ - async open (cacheName) { - webidl.brandCheck(this, CacheStorage) - webidl.argumentLengthCheck(arguments, 1, { header: 'CacheStorage.open' }) - - cacheName = webidl.converters.DOMString(cacheName) - - // 2.1 - if (this.#caches.has(cacheName)) { - // await caches.open('v1') !== await caches.open('v1') - - // 2.1.1 - const cache = this.#caches.get(cacheName) - - // 2.1.1.1 - return new Cache(kConstruct, cache) - } - - // 2.2 - const cache = [] - - // 2.3 - this.#caches.set(cacheName, cache) - - // 2.4 - return new Cache(kConstruct, cache) - } - - /** - * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete - * @param {string} cacheName - * @returns {Promise} - */ - async delete (cacheName) { - webidl.brandCheck(this, CacheStorage) - webidl.argumentLengthCheck(arguments, 1, { header: 'CacheStorage.delete' }) - - cacheName = webidl.converters.DOMString(cacheName) - - return this.#caches.delete(cacheName) - } - - /** - * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys - * @returns {string[]} - */ - async keys () { - webidl.brandCheck(this, CacheStorage) - - // 2.1 - const keys = this.#caches.keys() - - // 2.2 - return [...keys] - } -} - -Object.defineProperties(CacheStorage.prototype, { - [Symbol.toStringTag]: { - value: 'CacheStorage', - configurable: true - }, - match: kEnumerableProperty, - has: kEnumerableProperty, - open: kEnumerableProperty, - delete: kEnumerableProperty, - keys: kEnumerableProperty -}) - -module.exports = { - CacheStorage -} - - -/***/ }), - -/***/ 296: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -module.exports = { - kConstruct: (__nccwpck_require__(6443).kConstruct) -} - - -/***/ }), - -/***/ 3993: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const assert = __nccwpck_require__(2613) -const { URLSerializer } = __nccwpck_require__(4322) -const { isValidHeaderName } = __nccwpck_require__(5523) - -/** - * @see https://url.spec.whatwg.org/#concept-url-equals - * @param {URL} A - * @param {URL} B - * @param {boolean | undefined} excludeFragment - * @returns {boolean} - */ -function urlEquals (A, B, excludeFragment = false) { - const serializedA = URLSerializer(A, excludeFragment) - - const serializedB = URLSerializer(B, excludeFragment) - - return serializedA === serializedB -} - -/** - * @see https://github.com/chromium/chromium/blob/694d20d134cb553d8d89e5500b9148012b1ba299/content/browser/cache_storage/cache_storage_cache.cc#L260-L262 - * @param {string} header - */ -function fieldValues (header) { - assert(header !== null) - - const values = [] - - for (let value of header.split(',')) { - value = value.trim() - - if (!value.length) { - continue - } else if (!isValidHeaderName(value)) { - continue - } - - values.push(value) - } - - return values -} - -module.exports = { - urlEquals, - fieldValues -} - - -/***/ }), - -/***/ 6197: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; -// @ts-check - - - -/* global WebAssembly */ - -const assert = __nccwpck_require__(2613) -const net = __nccwpck_require__(9278) -const http = __nccwpck_require__(8611) -const { pipeline } = __nccwpck_require__(2203) -const util = __nccwpck_require__(3440) -const timers = __nccwpck_require__(8804) -const Request = __nccwpck_require__(4655) -const DispatcherBase = __nccwpck_require__(1) -const { - RequestContentLengthMismatchError, - ResponseContentLengthMismatchError, - InvalidArgumentError, - RequestAbortedError, - HeadersTimeoutError, - HeadersOverflowError, - SocketError, - InformationalError, - BodyTimeoutError, - HTTPParserError, - ResponseExceededMaxSizeError, - ClientDestroyedError -} = __nccwpck_require__(8707) -const buildConnector = __nccwpck_require__(9136) -const { - kUrl, - kReset, - kServerName, - kClient, - kBusy, - kParser, - kConnect, - kBlocking, - kResuming, - kRunning, - kPending, - kSize, - kWriting, - kQueue, - kConnected, - kConnecting, - kNeedDrain, - kNoRef, - kKeepAliveDefaultTimeout, - kHostHeader, - kPendingIdx, - kRunningIdx, - kError, - kPipelining, - kSocket, - kKeepAliveTimeoutValue, - kMaxHeadersSize, - kKeepAliveMaxTimeout, - kKeepAliveTimeoutThreshold, - kHeadersTimeout, - kBodyTimeout, - kStrictContentLength, - kConnector, - kMaxRedirections, - kMaxRequests, - kCounter, - kClose, - kDestroy, - kDispatch, - kInterceptors, - kLocalAddress, - kMaxResponseSize, - kHTTPConnVersion, - // HTTP2 - kHost, - kHTTP2Session, - kHTTP2SessionState, - kHTTP2BuildRequest, - kHTTP2CopyHeaders, - kHTTP1BuildRequest -} = __nccwpck_require__(6443) - -/** @type {import('http2')} */ -let http2 -try { - http2 = __nccwpck_require__(5675) -} catch { - // @ts-ignore - http2 = { constants: {} } -} - -const { - constants: { - HTTP2_HEADER_AUTHORITY, - HTTP2_HEADER_METHOD, - HTTP2_HEADER_PATH, - HTTP2_HEADER_SCHEME, - HTTP2_HEADER_CONTENT_LENGTH, - HTTP2_HEADER_EXPECT, - HTTP2_HEADER_STATUS - } -} = http2 - -// Experimental -let h2ExperimentalWarned = false - -const FastBuffer = Buffer[Symbol.species] - -const kClosedResolve = Symbol('kClosedResolve') - -const channels = {} - -try { - const diagnosticsChannel = __nccwpck_require__(1637) - channels.sendHeaders = diagnosticsChannel.channel('undici:client:sendHeaders') - channels.beforeConnect = diagnosticsChannel.channel('undici:client:beforeConnect') - channels.connectError = diagnosticsChannel.channel('undici:client:connectError') - channels.connected = diagnosticsChannel.channel('undici:client:connected') -} catch { - channels.sendHeaders = { hasSubscribers: false } - channels.beforeConnect = { hasSubscribers: false } - channels.connectError = { hasSubscribers: false } - channels.connected = { hasSubscribers: false } -} - -/** - * @type {import('../types/client').default} - */ -class Client extends DispatcherBase { - /** - * - * @param {string|URL} url - * @param {import('../types/client').Client.Options} options - */ - constructor (url, { - interceptors, - maxHeaderSize, - headersTimeout, - socketTimeout, - requestTimeout, - connectTimeout, - bodyTimeout, - idleTimeout, - keepAlive, - keepAliveTimeout, - maxKeepAliveTimeout, - keepAliveMaxTimeout, - keepAliveTimeoutThreshold, - socketPath, - pipelining, - tls, - strictContentLength, - maxCachedSessions, - maxRedirections, - connect, - maxRequestsPerClient, - localAddress, - maxResponseSize, - autoSelectFamily, - autoSelectFamilyAttemptTimeout, - // h2 - allowH2, - maxConcurrentStreams - } = {}) { - super() - - if (keepAlive !== undefined) { - throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead') - } - - if (socketTimeout !== undefined) { - throw new InvalidArgumentError('unsupported socketTimeout, use headersTimeout & bodyTimeout instead') - } - - if (requestTimeout !== undefined) { - throw new InvalidArgumentError('unsupported requestTimeout, use headersTimeout & bodyTimeout instead') - } - - if (idleTimeout !== undefined) { - throw new InvalidArgumentError('unsupported idleTimeout, use keepAliveTimeout instead') - } - - if (maxKeepAliveTimeout !== undefined) { - throw new InvalidArgumentError('unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead') - } - - if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) { - throw new InvalidArgumentError('invalid maxHeaderSize') - } - - if (socketPath != null && typeof socketPath !== 'string') { - throw new InvalidArgumentError('invalid socketPath') - } - - if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) { - throw new InvalidArgumentError('invalid connectTimeout') - } - - if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) { - throw new InvalidArgumentError('invalid keepAliveTimeout') - } - - if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) { - throw new InvalidArgumentError('invalid keepAliveMaxTimeout') - } - - if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) { - throw new InvalidArgumentError('invalid keepAliveTimeoutThreshold') - } - - if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) { - throw new InvalidArgumentError('headersTimeout must be a positive integer or zero') - } - - if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) { - throw new InvalidArgumentError('bodyTimeout must be a positive integer or zero') - } - - if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') { - throw new InvalidArgumentError('connect must be a function or an object') - } - - if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { - throw new InvalidArgumentError('maxRedirections must be a positive number') - } - - if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) { - throw new InvalidArgumentError('maxRequestsPerClient must be a positive number') - } - - if (localAddress != null && (typeof localAddress !== 'string' || net.isIP(localAddress) === 0)) { - throw new InvalidArgumentError('localAddress must be valid string IP address') - } - - if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) { - throw new InvalidArgumentError('maxResponseSize must be a positive number') - } - - if ( - autoSelectFamilyAttemptTimeout != null && - (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1) - ) { - throw new InvalidArgumentError('autoSelectFamilyAttemptTimeout must be a positive number') - } - - // h2 - if (allowH2 != null && typeof allowH2 !== 'boolean') { - throw new InvalidArgumentError('allowH2 must be a valid boolean value') - } - - if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== 'number' || maxConcurrentStreams < 1)) { - throw new InvalidArgumentError('maxConcurrentStreams must be a possitive integer, greater than 0') - } - - if (typeof connect !== 'function') { - connect = buildConnector({ - ...tls, - maxCachedSessions, - allowH2, - socketPath, - timeout: connectTimeout, - ...(util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined), - ...connect - }) - } - - this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) - ? interceptors.Client - : [createRedirectInterceptor({ maxRedirections })] - this[kUrl] = util.parseOrigin(url) - this[kConnector] = connect - this[kSocket] = null - this[kPipelining] = pipelining != null ? pipelining : 1 - this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize - this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout - this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 600e3 : keepAliveMaxTimeout - this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold - this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout] - this[kServerName] = null - this[kLocalAddress] = localAddress != null ? localAddress : null - this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming - this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming - this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n` - this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300e3 - this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300e3 - this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength - this[kMaxRedirections] = maxRedirections - this[kMaxRequests] = maxRequestsPerClient - this[kClosedResolve] = null - this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1 - this[kHTTPConnVersion] = 'h1' - - // HTTP/2 - this[kHTTP2Session] = null - this[kHTTP2SessionState] = !allowH2 - ? null - : { - // streams: null, // Fixed queue of streams - For future support of `push` - openStreams: 0, // Keep track of them to decide wether or not unref the session - maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100 // Max peerConcurrentStreams for a Node h2 server - } - this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}` - - // kQueue is built up of 3 sections separated by - // the kRunningIdx and kPendingIdx indices. - // | complete | running | pending | - // ^ kRunningIdx ^ kPendingIdx ^ kQueue.length - // kRunningIdx points to the first running element. - // kPendingIdx points to the first pending element. - // This implements a fast queue with an amortized - // time of O(1). - - this[kQueue] = [] - this[kRunningIdx] = 0 - this[kPendingIdx] = 0 - } - - get pipelining () { - return this[kPipelining] - } - - set pipelining (value) { - this[kPipelining] = value - resume(this, true) - } - - get [kPending] () { - return this[kQueue].length - this[kPendingIdx] - } - - get [kRunning] () { - return this[kPendingIdx] - this[kRunningIdx] - } - - get [kSize] () { - return this[kQueue].length - this[kRunningIdx] - } - - get [kConnected] () { - return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed - } - - get [kBusy] () { - const socket = this[kSocket] - return ( - (socket && (socket[kReset] || socket[kWriting] || socket[kBlocking])) || - (this[kSize] >= (this[kPipelining] || 1)) || - this[kPending] > 0 - ) - } - - /* istanbul ignore: only used for test */ - [kConnect] (cb) { - connect(this) - this.once('connect', cb) - } - - [kDispatch] (opts, handler) { - const origin = opts.origin || this[kUrl].origin - - const request = this[kHTTPConnVersion] === 'h2' - ? Request[kHTTP2BuildRequest](origin, opts, handler) - : Request[kHTTP1BuildRequest](origin, opts, handler) - - this[kQueue].push(request) - if (this[kResuming]) { - // Do nothing. - } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) { - // Wait a tick in case stream/iterator is ended in the same tick. - this[kResuming] = 1 - process.nextTick(resume, this) - } else { - resume(this, true) - } - - if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) { - this[kNeedDrain] = 2 - } - - return this[kNeedDrain] < 2 - } - - async [kClose] () { - // TODO: for H2 we need to gracefully flush the remaining enqueued - // request and close each stream. - return new Promise((resolve) => { - if (!this[kSize]) { - resolve(null) - } else { - this[kClosedResolve] = resolve - } - }) - } - - async [kDestroy] (err) { - return new Promise((resolve) => { - const requests = this[kQueue].splice(this[kPendingIdx]) - for (let i = 0; i < requests.length; i++) { - const request = requests[i] - errorRequest(this, request, err) - } - - const callback = () => { - if (this[kClosedResolve]) { - // TODO (fix): Should we error here with ClientDestroyedError? - this[kClosedResolve]() - this[kClosedResolve] = null - } - resolve() - } - - if (this[kHTTP2Session] != null) { - util.destroy(this[kHTTP2Session], err) - this[kHTTP2Session] = null - this[kHTTP2SessionState] = null - } - - if (!this[kSocket]) { - queueMicrotask(callback) - } else { - util.destroy(this[kSocket].on('close', callback), err) - } - - resume(this) - }) - } -} - -function onHttp2SessionError (err) { - assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID') - - this[kSocket][kError] = err - - onError(this[kClient], err) -} - -function onHttp2FrameError (type, code, id) { - const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`) - - if (id === 0) { - this[kSocket][kError] = err - onError(this[kClient], err) - } -} - -function onHttp2SessionEnd () { - util.destroy(this, new SocketError('other side closed')) - util.destroy(this[kSocket], new SocketError('other side closed')) -} - -function onHTTP2GoAway (code) { - const client = this[kClient] - const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`) - client[kSocket] = null - client[kHTTP2Session] = null - - if (client.destroyed) { - assert(this[kPending] === 0) - - // Fail entire queue. - const requests = client[kQueue].splice(client[kRunningIdx]) - for (let i = 0; i < requests.length; i++) { - const request = requests[i] - errorRequest(this, request, err) - } - } else if (client[kRunning] > 0) { - // Fail head of pipeline. - const request = client[kQueue][client[kRunningIdx]] - client[kQueue][client[kRunningIdx]++] = null - - errorRequest(client, request, err) - } - - client[kPendingIdx] = client[kRunningIdx] - - assert(client[kRunning] === 0) - - client.emit('disconnect', - client[kUrl], - [client], - err - ) - - resume(client) -} - -const constants = __nccwpck_require__(2824) -const createRedirectInterceptor = __nccwpck_require__(4415) -const EMPTY_BUF = Buffer.alloc(0) - -async function lazyllhttp () { - const llhttpWasmData = process.env.JEST_WORKER_ID ? __nccwpck_require__(3870) : undefined - - let mod - try { - mod = await WebAssembly.compile(Buffer.from(__nccwpck_require__(3434), 'base64')) - } catch (e) { - /* istanbul ignore next */ - - // We could check if the error was caused by the simd option not - // being enabled, but the occurring of this other error - // * https://github.com/emscripten-core/emscripten/issues/11495 - // got me to remove that check to avoid breaking Node 12. - mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || __nccwpck_require__(3870), 'base64')) - } - - return await WebAssembly.instantiate(mod, { - env: { - /* eslint-disable camelcase */ - - wasm_on_url: (p, at, len) => { - /* istanbul ignore next */ - return 0 - }, - wasm_on_status: (p, at, len) => { - assert.strictEqual(currentParser.ptr, p) - const start = at - currentBufferPtr + currentBufferRef.byteOffset - return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0 - }, - wasm_on_message_begin: (p) => { - assert.strictEqual(currentParser.ptr, p) - return currentParser.onMessageBegin() || 0 - }, - wasm_on_header_field: (p, at, len) => { - assert.strictEqual(currentParser.ptr, p) - const start = at - currentBufferPtr + currentBufferRef.byteOffset - return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0 - }, - wasm_on_header_value: (p, at, len) => { - assert.strictEqual(currentParser.ptr, p) - const start = at - currentBufferPtr + currentBufferRef.byteOffset - return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0 - }, - wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { - assert.strictEqual(currentParser.ptr, p) - return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0 - }, - wasm_on_body: (p, at, len) => { - assert.strictEqual(currentParser.ptr, p) - const start = at - currentBufferPtr + currentBufferRef.byteOffset - return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0 - }, - wasm_on_message_complete: (p) => { - assert.strictEqual(currentParser.ptr, p) - return currentParser.onMessageComplete() || 0 - } - - /* eslint-enable camelcase */ - } - }) -} - -let llhttpInstance = null -let llhttpPromise = lazyllhttp() -llhttpPromise.catch() - -let currentParser = null -let currentBufferRef = null -let currentBufferSize = 0 -let currentBufferPtr = null - -const TIMEOUT_HEADERS = 1 -const TIMEOUT_BODY = 2 -const TIMEOUT_IDLE = 3 - -class Parser { - constructor (client, socket, { exports }) { - assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0) - - this.llhttp = exports - this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE) - this.client = client - this.socket = socket - this.timeout = null - this.timeoutValue = null - this.timeoutType = null - this.statusCode = null - this.statusText = '' - this.upgrade = false - this.headers = [] - this.headersSize = 0 - this.headersMaxSize = client[kMaxHeadersSize] - this.shouldKeepAlive = false - this.paused = false - this.resume = this.resume.bind(this) - - this.bytesRead = 0 - - this.keepAlive = '' - this.contentLength = '' - this.connection = '' - this.maxResponseSize = client[kMaxResponseSize] - } - - setTimeout (value, type) { - this.timeoutType = type - if (value !== this.timeoutValue) { - timers.clearTimeout(this.timeout) - if (value) { - this.timeout = timers.setTimeout(onParserTimeout, value, this) - // istanbul ignore else: only for jest - if (this.timeout.unref) { - this.timeout.unref() - } - } else { - this.timeout = null - } - this.timeoutValue = value - } else if (this.timeout) { - // istanbul ignore else: only for jest - if (this.timeout.refresh) { - this.timeout.refresh() - } - } - } - - resume () { - if (this.socket.destroyed || !this.paused) { - return - } - - assert(this.ptr != null) - assert(currentParser == null) - - this.llhttp.llhttp_resume(this.ptr) - - assert(this.timeoutType === TIMEOUT_BODY) - if (this.timeout) { - // istanbul ignore else: only for jest - if (this.timeout.refresh) { - this.timeout.refresh() - } - } - - this.paused = false - this.execute(this.socket.read() || EMPTY_BUF) // Flush parser. - this.readMore() - } - - readMore () { - while (!this.paused && this.ptr) { - const chunk = this.socket.read() - if (chunk === null) { - break - } - this.execute(chunk) - } - } - - execute (data) { - assert(this.ptr != null) - assert(currentParser == null) - assert(!this.paused) - - const { socket, llhttp } = this - - if (data.length > currentBufferSize) { - if (currentBufferPtr) { - llhttp.free(currentBufferPtr) - } - currentBufferSize = Math.ceil(data.length / 4096) * 4096 - currentBufferPtr = llhttp.malloc(currentBufferSize) - } - - new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data) - - // Call `execute` on the wasm parser. - // We pass the `llhttp_parser` pointer address, the pointer address of buffer view data, - // and finally the length of bytes to parse. - // The return value is an error code or `constants.ERROR.OK`. - try { - let ret - - try { - currentBufferRef = data - currentParser = this - ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length) - /* eslint-disable-next-line no-useless-catch */ - } catch (err) { - /* istanbul ignore next: difficult to make a test case for */ - throw err - } finally { - currentParser = null - currentBufferRef = null - } - - const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr - - if (ret === constants.ERROR.PAUSED_UPGRADE) { - this.onUpgrade(data.slice(offset)) - } else if (ret === constants.ERROR.PAUSED) { - this.paused = true - socket.unshift(data.slice(offset)) - } else if (ret !== constants.ERROR.OK) { - const ptr = llhttp.llhttp_get_error_reason(this.ptr) - let message = '' - /* istanbul ignore else: difficult to make a test case for */ - if (ptr) { - const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0) - message = - 'Response does not match the HTTP/1.1 protocol (' + - Buffer.from(llhttp.memory.buffer, ptr, len).toString() + - ')' - } - throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)) - } - } catch (err) { - util.destroy(socket, err) - } - } - - destroy () { - assert(this.ptr != null) - assert(currentParser == null) - - this.llhttp.llhttp_free(this.ptr) - this.ptr = null - - timers.clearTimeout(this.timeout) - this.timeout = null - this.timeoutValue = null - this.timeoutType = null - - this.paused = false - } - - onStatus (buf) { - this.statusText = buf.toString() - } - - onMessageBegin () { - const { socket, client } = this - - /* istanbul ignore next: difficult to make a test case for */ - if (socket.destroyed) { - return -1 - } - - const request = client[kQueue][client[kRunningIdx]] - if (!request) { - return -1 - } - } - - onHeaderField (buf) { - const len = this.headers.length - - if ((len & 1) === 0) { - this.headers.push(buf) - } else { - this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]) - } - - this.trackHeader(buf.length) - } - - onHeaderValue (buf) { - let len = this.headers.length - - if ((len & 1) === 1) { - this.headers.push(buf) - len += 1 - } else { - this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]) - } - - const key = this.headers[len - 2] - if (key.length === 10 && key.toString().toLowerCase() === 'keep-alive') { - this.keepAlive += buf.toString() - } else if (key.length === 10 && key.toString().toLowerCase() === 'connection') { - this.connection += buf.toString() - } else if (key.length === 14 && key.toString().toLowerCase() === 'content-length') { - this.contentLength += buf.toString() - } - - this.trackHeader(buf.length) - } - - trackHeader (len) { - this.headersSize += len - if (this.headersSize >= this.headersMaxSize) { - util.destroy(this.socket, new HeadersOverflowError()) - } - } - - onUpgrade (head) { - const { upgrade, client, socket, headers, statusCode } = this - - assert(upgrade) - - const request = client[kQueue][client[kRunningIdx]] - assert(request) - - assert(!socket.destroyed) - assert(socket === client[kSocket]) - assert(!this.paused) - assert(request.upgrade || request.method === 'CONNECT') - - this.statusCode = null - this.statusText = '' - this.shouldKeepAlive = null - - assert(this.headers.length % 2 === 0) - this.headers = [] - this.headersSize = 0 - - socket.unshift(head) - - socket[kParser].destroy() - socket[kParser] = null - - socket[kClient] = null - socket[kError] = null - socket - .removeListener('error', onSocketError) - .removeListener('readable', onSocketReadable) - .removeListener('end', onSocketEnd) - .removeListener('close', onSocketClose) - - client[kSocket] = null - client[kQueue][client[kRunningIdx]++] = null - client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade')) - - try { - request.onUpgrade(statusCode, headers, socket) - } catch (err) { - util.destroy(socket, err) - } - - resume(client) - } - - onHeadersComplete (statusCode, upgrade, shouldKeepAlive) { - const { client, socket, headers, statusText } = this - - /* istanbul ignore next: difficult to make a test case for */ - if (socket.destroyed) { - return -1 - } - - const request = client[kQueue][client[kRunningIdx]] - - /* istanbul ignore next: difficult to make a test case for */ - if (!request) { - return -1 - } - - assert(!this.upgrade) - assert(this.statusCode < 200) - - if (statusCode === 100) { - util.destroy(socket, new SocketError('bad response', util.getSocketInfo(socket))) - return -1 - } - - /* this can only happen if server is misbehaving */ - if (upgrade && !request.upgrade) { - util.destroy(socket, new SocketError('bad upgrade', util.getSocketInfo(socket))) - return -1 - } - - assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS) - - this.statusCode = statusCode - this.shouldKeepAlive = ( - shouldKeepAlive || - // Override llhttp value which does not allow keepAlive for HEAD. - (request.method === 'HEAD' && !socket[kReset] && this.connection.toLowerCase() === 'keep-alive') - ) - - if (this.statusCode >= 200) { - const bodyTimeout = request.bodyTimeout != null - ? request.bodyTimeout - : client[kBodyTimeout] - this.setTimeout(bodyTimeout, TIMEOUT_BODY) - } else if (this.timeout) { - // istanbul ignore else: only for jest - if (this.timeout.refresh) { - this.timeout.refresh() - } - } - - if (request.method === 'CONNECT') { - assert(client[kRunning] === 1) - this.upgrade = true - return 2 - } - - if (upgrade) { - assert(client[kRunning] === 1) - this.upgrade = true - return 2 - } - - assert(this.headers.length % 2 === 0) - this.headers = [] - this.headersSize = 0 - - if (this.shouldKeepAlive && client[kPipelining]) { - const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null - - if (keepAliveTimeout != null) { - const timeout = Math.min( - keepAliveTimeout - client[kKeepAliveTimeoutThreshold], - client[kKeepAliveMaxTimeout] - ) - if (timeout <= 0) { - socket[kReset] = true - } else { - client[kKeepAliveTimeoutValue] = timeout - } - } else { - client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout] - } - } else { - // Stop more requests from being dispatched. - socket[kReset] = true - } - - const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false - - if (request.aborted) { - return -1 - } - - if (request.method === 'HEAD') { - return 1 - } - - if (statusCode < 200) { - return 1 - } - - if (socket[kBlocking]) { - socket[kBlocking] = false - resume(client) - } - - return pause ? constants.ERROR.PAUSED : 0 - } - - onBody (buf) { - const { client, socket, statusCode, maxResponseSize } = this - - if (socket.destroyed) { - return -1 - } - - const request = client[kQueue][client[kRunningIdx]] - assert(request) - - assert.strictEqual(this.timeoutType, TIMEOUT_BODY) - if (this.timeout) { - // istanbul ignore else: only for jest - if (this.timeout.refresh) { - this.timeout.refresh() - } - } - - assert(statusCode >= 200) - - if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) { - util.destroy(socket, new ResponseExceededMaxSizeError()) - return -1 - } - - this.bytesRead += buf.length - - if (request.onData(buf) === false) { - return constants.ERROR.PAUSED - } - } - - onMessageComplete () { - const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this - - if (socket.destroyed && (!statusCode || shouldKeepAlive)) { - return -1 - } - - if (upgrade) { - return - } - - const request = client[kQueue][client[kRunningIdx]] - assert(request) - - assert(statusCode >= 100) - - this.statusCode = null - this.statusText = '' - this.bytesRead = 0 - this.contentLength = '' - this.keepAlive = '' - this.connection = '' - - assert(this.headers.length % 2 === 0) - this.headers = [] - this.headersSize = 0 - - if (statusCode < 200) { - return - } - - /* istanbul ignore next: should be handled by llhttp? */ - if (request.method !== 'HEAD' && contentLength && bytesRead !== parseInt(contentLength, 10)) { - util.destroy(socket, new ResponseContentLengthMismatchError()) - return -1 - } - - request.onComplete(headers) - - client[kQueue][client[kRunningIdx]++] = null - - if (socket[kWriting]) { - assert.strictEqual(client[kRunning], 0) - // Response completed before request. - util.destroy(socket, new InformationalError('reset')) - return constants.ERROR.PAUSED - } else if (!shouldKeepAlive) { - util.destroy(socket, new InformationalError('reset')) - return constants.ERROR.PAUSED - } else if (socket[kReset] && client[kRunning] === 0) { - // Destroy socket once all requests have completed. - // The request at the tail of the pipeline is the one - // that requested reset and no further requests should - // have been queued since then. - util.destroy(socket, new InformationalError('reset')) - return constants.ERROR.PAUSED - } else if (client[kPipelining] === 1) { - // We must wait a full event loop cycle to reuse this socket to make sure - // that non-spec compliant servers are not closing the connection even if they - // said they won't. - setImmediate(resume, client) - } else { - resume(client) - } - } -} - -function onParserTimeout (parser) { - const { socket, timeoutType, client } = parser - - /* istanbul ignore else */ - if (timeoutType === TIMEOUT_HEADERS) { - if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { - assert(!parser.paused, 'cannot be paused while waiting for headers') - util.destroy(socket, new HeadersTimeoutError()) - } - } else if (timeoutType === TIMEOUT_BODY) { - if (!parser.paused) { - util.destroy(socket, new BodyTimeoutError()) - } - } else if (timeoutType === TIMEOUT_IDLE) { - assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]) - util.destroy(socket, new InformationalError('socket idle timeout')) - } -} - -function onSocketReadable () { - const { [kParser]: parser } = this - if (parser) { - parser.readMore() - } -} - -function onSocketError (err) { - const { [kClient]: client, [kParser]: parser } = this - - assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID') - - if (client[kHTTPConnVersion] !== 'h2') { - // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded - // to the user. - if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) { - // We treat all incoming data so for as a valid response. - parser.onMessageComplete() - return - } - } - - this[kError] = err - - onError(this[kClient], err) -} - -function onError (client, err) { - if ( - client[kRunning] === 0 && - err.code !== 'UND_ERR_INFO' && - err.code !== 'UND_ERR_SOCKET' - ) { - // Error is not caused by running request and not a recoverable - // socket error. - - assert(client[kPendingIdx] === client[kRunningIdx]) - - const requests = client[kQueue].splice(client[kRunningIdx]) - for (let i = 0; i < requests.length; i++) { - const request = requests[i] - errorRequest(client, request, err) - } - assert(client[kSize] === 0) - } -} - -function onSocketEnd () { - const { [kParser]: parser, [kClient]: client } = this - - if (client[kHTTPConnVersion] !== 'h2') { - if (parser.statusCode && !parser.shouldKeepAlive) { - // We treat all incoming data so far as a valid response. - parser.onMessageComplete() - return - } - } - - util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this))) -} - -function onSocketClose () { - const { [kClient]: client, [kParser]: parser } = this - - if (client[kHTTPConnVersion] === 'h1' && parser) { - if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) { - // We treat all incoming data so far as a valid response. - parser.onMessageComplete() - } - - this[kParser].destroy() - this[kParser] = null - } - - const err = this[kError] || new SocketError('closed', util.getSocketInfo(this)) - - client[kSocket] = null - - if (client.destroyed) { - assert(client[kPending] === 0) - - // Fail entire queue. - const requests = client[kQueue].splice(client[kRunningIdx]) - for (let i = 0; i < requests.length; i++) { - const request = requests[i] - errorRequest(client, request, err) - } - } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') { - // Fail head of pipeline. - const request = client[kQueue][client[kRunningIdx]] - client[kQueue][client[kRunningIdx]++] = null - - errorRequest(client, request, err) - } - - client[kPendingIdx] = client[kRunningIdx] - - assert(client[kRunning] === 0) - - client.emit('disconnect', client[kUrl], [client], err) - - resume(client) -} - -async function connect (client) { - assert(!client[kConnecting]) - assert(!client[kSocket]) - - let { host, hostname, protocol, port } = client[kUrl] - - // Resolve ipv6 - if (hostname[0] === '[') { - const idx = hostname.indexOf(']') - - assert(idx !== -1) - const ip = hostname.substring(1, idx) - - assert(net.isIP(ip)) - hostname = ip - } - - client[kConnecting] = true - - if (channels.beforeConnect.hasSubscribers) { - channels.beforeConnect.publish({ - connectParams: { - host, - hostname, - protocol, - port, - servername: client[kServerName], - localAddress: client[kLocalAddress] - }, - connector: client[kConnector] - }) - } - - try { - const socket = await new Promise((resolve, reject) => { - client[kConnector]({ - host, - hostname, - protocol, - port, - servername: client[kServerName], - localAddress: client[kLocalAddress] - }, (err, socket) => { - if (err) { - reject(err) - } else { - resolve(socket) - } - }) - }) - - if (client.destroyed) { - util.destroy(socket.on('error', () => {}), new ClientDestroyedError()) - return - } - - client[kConnecting] = false - - assert(socket) - - const isH2 = socket.alpnProtocol === 'h2' - if (isH2) { - if (!h2ExperimentalWarned) { - h2ExperimentalWarned = true - process.emitWarning('H2 support is experimental, expect them to change at any time.', { - code: 'UNDICI-H2' - }) - } - - const session = http2.connect(client[kUrl], { - createConnection: () => socket, - peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams - }) - - client[kHTTPConnVersion] = 'h2' - session[kClient] = client - session[kSocket] = socket - session.on('error', onHttp2SessionError) - session.on('frameError', onHttp2FrameError) - session.on('end', onHttp2SessionEnd) - session.on('goaway', onHTTP2GoAway) - session.on('close', onSocketClose) - session.unref() - - client[kHTTP2Session] = session - socket[kHTTP2Session] = session - } else { - if (!llhttpInstance) { - llhttpInstance = await llhttpPromise - llhttpPromise = null - } - - socket[kNoRef] = false - socket[kWriting] = false - socket[kReset] = false - socket[kBlocking] = false - socket[kParser] = new Parser(client, socket, llhttpInstance) - } - - socket[kCounter] = 0 - socket[kMaxRequests] = client[kMaxRequests] - socket[kClient] = client - socket[kError] = null - - socket - .on('error', onSocketError) - .on('readable', onSocketReadable) - .on('end', onSocketEnd) - .on('close', onSocketClose) - - client[kSocket] = socket - - if (channels.connected.hasSubscribers) { - channels.connected.publish({ - connectParams: { - host, - hostname, - protocol, - port, - servername: client[kServerName], - localAddress: client[kLocalAddress] - }, - connector: client[kConnector], - socket - }) - } - client.emit('connect', client[kUrl], [client]) - } catch (err) { - if (client.destroyed) { - return - } - - client[kConnecting] = false - - if (channels.connectError.hasSubscribers) { - channels.connectError.publish({ - connectParams: { - host, - hostname, - protocol, - port, - servername: client[kServerName], - localAddress: client[kLocalAddress] - }, - connector: client[kConnector], - error: err - }) - } - - if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') { - assert(client[kRunning] === 0) - while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { - const request = client[kQueue][client[kPendingIdx]++] - errorRequest(client, request, err) - } - } else { - onError(client, err) - } - - client.emit('connectionError', client[kUrl], [client], err) - } - - resume(client) -} - -function emitDrain (client) { - client[kNeedDrain] = 0 - client.emit('drain', client[kUrl], [client]) -} - -function resume (client, sync) { - if (client[kResuming] === 2) { - return - } - - client[kResuming] = 2 - - _resume(client, sync) - client[kResuming] = 0 - - if (client[kRunningIdx] > 256) { - client[kQueue].splice(0, client[kRunningIdx]) - client[kPendingIdx] -= client[kRunningIdx] - client[kRunningIdx] = 0 - } -} - -function _resume (client, sync) { - while (true) { - if (client.destroyed) { - assert(client[kPending] === 0) - return - } - - if (client[kClosedResolve] && !client[kSize]) { - client[kClosedResolve]() - client[kClosedResolve] = null - return - } - - const socket = client[kSocket] - - if (socket && !socket.destroyed && socket.alpnProtocol !== 'h2') { - if (client[kSize] === 0) { - if (!socket[kNoRef] && socket.unref) { - socket.unref() - socket[kNoRef] = true - } - } else if (socket[kNoRef] && socket.ref) { - socket.ref() - socket[kNoRef] = false - } - - if (client[kSize] === 0) { - if (socket[kParser].timeoutType !== TIMEOUT_IDLE) { - socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE) - } - } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) { - if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) { - const request = client[kQueue][client[kRunningIdx]] - const headersTimeout = request.headersTimeout != null - ? request.headersTimeout - : client[kHeadersTimeout] - socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS) - } - } - } - - if (client[kBusy]) { - client[kNeedDrain] = 2 - } else if (client[kNeedDrain] === 2) { - if (sync) { - client[kNeedDrain] = 1 - process.nextTick(emitDrain, client) - } else { - emitDrain(client) - } - continue - } - - if (client[kPending] === 0) { - return - } - - if (client[kRunning] >= (client[kPipelining] || 1)) { - return - } - - const request = client[kQueue][client[kPendingIdx]] - - if (client[kUrl].protocol === 'https:' && client[kServerName] !== request.servername) { - if (client[kRunning] > 0) { - return - } - - client[kServerName] = request.servername - - if (socket && socket.servername !== request.servername) { - util.destroy(socket, new InformationalError('servername changed')) - return - } - } - - if (client[kConnecting]) { - return - } - - if (!socket && !client[kHTTP2Session]) { - connect(client) - return - } - - if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) { - return - } - - if (client[kRunning] > 0 && !request.idempotent) { - // Non-idempotent request cannot be retried. - // Ensure that no other requests are inflight and - // could cause failure. - return - } - - if (client[kRunning] > 0 && (request.upgrade || request.method === 'CONNECT')) { - // Don't dispatch an upgrade until all preceding requests have completed. - // A misbehaving server might upgrade the connection before all pipelined - // request has completed. - return - } - - if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && - (util.isStream(request.body) || util.isAsyncIterable(request.body))) { - // Request with stream or iterator body can error while other requests - // are inflight and indirectly error those as well. - // Ensure this doesn't happen by waiting for inflight - // to complete before dispatching. - - // Request with stream or iterator body cannot be retried. - // Ensure that no other requests are inflight and - // could cause failure. - return - } - - if (!request.aborted && write(client, request)) { - client[kPendingIdx]++ - } else { - client[kQueue].splice(client[kPendingIdx], 1) - } - } -} - -// https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2 -function shouldSendContentLength (method) { - return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT' -} - -function write (client, request) { - if (client[kHTTPConnVersion] === 'h2') { - writeH2(client, client[kHTTP2Session], request) - return - } - - const { body, method, path, host, upgrade, headers, blocking, reset } = request - - // https://tools.ietf.org/html/rfc7231#section-4.3.1 - // https://tools.ietf.org/html/rfc7231#section-4.3.2 - // https://tools.ietf.org/html/rfc7231#section-4.3.5 - - // Sending a payload body on a request that does not - // expect it can cause undefined behavior on some - // servers and corrupt connection state. Do not - // re-use the connection for further requests. - - const expectsPayload = ( - method === 'PUT' || - method === 'POST' || - method === 'PATCH' - ) - - if (body && typeof body.read === 'function') { - // Try to read EOF in order to get length. - body.read(0) - } - - const bodyLength = util.bodyLength(body) - - let contentLength = bodyLength - - if (contentLength === null) { - contentLength = request.contentLength - } - - if (contentLength === 0 && !expectsPayload) { - // https://tools.ietf.org/html/rfc7230#section-3.3.2 - // A user agent SHOULD NOT send a Content-Length header field when - // the request message does not contain a payload body and the method - // semantics do not anticipate such a body. - - contentLength = null - } - - // https://github.com/nodejs/undici/issues/2046 - // A user agent may send a Content-Length header with 0 value, this should be allowed. - if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) { - if (client[kStrictContentLength]) { - errorRequest(client, request, new RequestContentLengthMismatchError()) - return false - } - - process.emitWarning(new RequestContentLengthMismatchError()) - } - - const socket = client[kSocket] - - try { - request.onConnect((err) => { - if (request.aborted || request.completed) { - return - } - - errorRequest(client, request, err || new RequestAbortedError()) - - util.destroy(socket, new InformationalError('aborted')) - }) - } catch (err) { - errorRequest(client, request, err) - } - - if (request.aborted) { - return false - } - - if (method === 'HEAD') { - // https://github.com/mcollina/undici/issues/258 - // Close after a HEAD request to interop with misbehaving servers - // that may send a body in the response. - - socket[kReset] = true - } - - if (upgrade || method === 'CONNECT') { - // On CONNECT or upgrade, block pipeline from dispatching further - // requests on this connection. - - socket[kReset] = true - } - - if (reset != null) { - socket[kReset] = reset - } - - if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { - socket[kReset] = true - } - - if (blocking) { - socket[kBlocking] = true - } - - let header = `${method} ${path} HTTP/1.1\r\n` - - if (typeof host === 'string') { - header += `host: ${host}\r\n` - } else { - header += client[kHostHeader] - } - - if (upgrade) { - header += `connection: upgrade\r\nupgrade: ${upgrade}\r\n` - } else if (client[kPipelining] && !socket[kReset]) { - header += 'connection: keep-alive\r\n' - } else { - header += 'connection: close\r\n' - } - - if (headers) { - header += headers - } - - if (channels.sendHeaders.hasSubscribers) { - channels.sendHeaders.publish({ request, headers: header, socket }) - } - - /* istanbul ignore else: assertion */ - if (!body || bodyLength === 0) { - if (contentLength === 0) { - socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1') - } else { - assert(contentLength === null, 'no body must not have content length') - socket.write(`${header}\r\n`, 'latin1') - } - request.onRequestSent() - } else if (util.isBuffer(body)) { - assert(contentLength === body.byteLength, 'buffer body must have content length') - - socket.cork() - socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1') - socket.write(body) - socket.uncork() - request.onBodySent(body) - request.onRequestSent() - if (!expectsPayload) { - socket[kReset] = true - } - } else if (util.isBlobLike(body)) { - if (typeof body.stream === 'function') { - writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload }) - } else { - writeBlob({ body, client, request, socket, contentLength, header, expectsPayload }) - } - } else if (util.isStream(body)) { - writeStream({ body, client, request, socket, contentLength, header, expectsPayload }) - } else if (util.isIterable(body)) { - writeIterable({ body, client, request, socket, contentLength, header, expectsPayload }) - } else { - assert(false) - } - - return true -} - -function writeH2 (client, session, request) { - const { body, method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request - - let headers - if (typeof reqHeaders === 'string') headers = Request[kHTTP2CopyHeaders](reqHeaders.trim()) - else headers = reqHeaders - - if (upgrade) { - errorRequest(client, request, new Error('Upgrade not supported for H2')) - return false - } - - try { - // TODO(HTTP/2): Should we call onConnect immediately or on stream ready event? - request.onConnect((err) => { - if (request.aborted || request.completed) { - return - } - - errorRequest(client, request, err || new RequestAbortedError()) - }) - } catch (err) { - errorRequest(client, request, err) - } - - if (request.aborted) { - return false - } - - /** @type {import('node:http2').ClientHttp2Stream} */ - let stream - const h2State = client[kHTTP2SessionState] - - headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost] - headers[HTTP2_HEADER_METHOD] = method - - if (method === 'CONNECT') { - session.ref() - // we are already connected, streams are pending, first request - // will create a new stream. We trigger a request to create the stream and wait until - // `ready` event is triggered - // We disabled endStream to allow the user to write to the stream - stream = session.request(headers, { endStream: false, signal }) - - if (stream.id && !stream.pending) { - request.onUpgrade(null, null, stream) - ++h2State.openStreams - } else { - stream.once('ready', () => { - request.onUpgrade(null, null, stream) - ++h2State.openStreams - }) - } - - stream.once('close', () => { - h2State.openStreams -= 1 - // TODO(HTTP/2): unref only if current streams count is 0 - if (h2State.openStreams === 0) session.unref() - }) - - return true - } - - // https://tools.ietf.org/html/rfc7540#section-8.3 - // :path and :scheme headers must be omited when sending CONNECT - - headers[HTTP2_HEADER_PATH] = path - headers[HTTP2_HEADER_SCHEME] = 'https' - - // https://tools.ietf.org/html/rfc7231#section-4.3.1 - // https://tools.ietf.org/html/rfc7231#section-4.3.2 - // https://tools.ietf.org/html/rfc7231#section-4.3.5 - - // Sending a payload body on a request that does not - // expect it can cause undefined behavior on some - // servers and corrupt connection state. Do not - // re-use the connection for further requests. - - const expectsPayload = ( - method === 'PUT' || - method === 'POST' || - method === 'PATCH' - ) - - if (body && typeof body.read === 'function') { - // Try to read EOF in order to get length. - body.read(0) - } - - let contentLength = util.bodyLength(body) - - if (contentLength == null) { - contentLength = request.contentLength - } - - if (contentLength === 0 || !expectsPayload) { - // https://tools.ietf.org/html/rfc7230#section-3.3.2 - // A user agent SHOULD NOT send a Content-Length header field when - // the request message does not contain a payload body and the method - // semantics do not anticipate such a body. - - contentLength = null - } - - // https://github.com/nodejs/undici/issues/2046 - // A user agent may send a Content-Length header with 0 value, this should be allowed. - if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { - if (client[kStrictContentLength]) { - errorRequest(client, request, new RequestContentLengthMismatchError()) - return false - } - - process.emitWarning(new RequestContentLengthMismatchError()) - } - - if (contentLength != null) { - assert(body, 'no body must not have content length') - headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}` - } - - session.ref() - - const shouldEndStream = method === 'GET' || method === 'HEAD' - if (expectContinue) { - headers[HTTP2_HEADER_EXPECT] = '100-continue' - stream = session.request(headers, { endStream: shouldEndStream, signal }) - - stream.once('continue', writeBodyH2) - } else { - stream = session.request(headers, { - endStream: shouldEndStream, - signal - }) - writeBodyH2() - } - - // Increment counter as we have new several streams open - ++h2State.openStreams - - stream.once('response', headers => { - const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers - - if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), '') === false) { - stream.pause() - } - }) - - stream.once('end', () => { - request.onComplete([]) - }) - - stream.on('data', (chunk) => { - if (request.onData(chunk) === false) { - stream.pause() - } - }) - - stream.once('close', () => { - h2State.openStreams -= 1 - // TODO(HTTP/2): unref only if current streams count is 0 - if (h2State.openStreams === 0) { - session.unref() - } - }) - - stream.once('error', function (err) { - if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { - h2State.streams -= 1 - util.destroy(stream, err) - } - }) - - stream.once('frameError', (type, code) => { - const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`) - errorRequest(client, request, err) - - if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { - h2State.streams -= 1 - util.destroy(stream, err) - } - }) - - // stream.on('aborted', () => { - // // TODO(HTTP/2): Support aborted - // }) - - // stream.on('timeout', () => { - // // TODO(HTTP/2): Support timeout - // }) - - // stream.on('push', headers => { - // // TODO(HTTP/2): Suppor push - // }) - - // stream.on('trailers', headers => { - // // TODO(HTTP/2): Support trailers - // }) - - return true - - function writeBodyH2 () { - /* istanbul ignore else: assertion */ - if (!body) { - request.onRequestSent() - } else if (util.isBuffer(body)) { - assert(contentLength === body.byteLength, 'buffer body must have content length') - stream.cork() - stream.write(body) - stream.uncork() - stream.end() - request.onBodySent(body) - request.onRequestSent() - } else if (util.isBlobLike(body)) { - if (typeof body.stream === 'function') { - writeIterable({ - client, - request, - contentLength, - h2stream: stream, - expectsPayload, - body: body.stream(), - socket: client[kSocket], - header: '' - }) - } else { - writeBlob({ - body, - client, - request, - contentLength, - expectsPayload, - h2stream: stream, - header: '', - socket: client[kSocket] - }) - } - } else if (util.isStream(body)) { - writeStream({ - body, - client, - request, - contentLength, - expectsPayload, - socket: client[kSocket], - h2stream: stream, - header: '' - }) - } else if (util.isIterable(body)) { - writeIterable({ - body, - client, - request, - contentLength, - expectsPayload, - header: '', - h2stream: stream, - socket: client[kSocket] - }) - } else { - assert(false) - } - } -} - -function writeStream ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { - assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined') - - if (client[kHTTPConnVersion] === 'h2') { - // For HTTP/2, is enough to pipe the stream - const pipe = pipeline( - body, - h2stream, - (err) => { - if (err) { - util.destroy(body, err) - util.destroy(h2stream, err) - } else { - request.onRequestSent() - } - } - ) - - pipe.on('data', onPipeData) - pipe.once('end', () => { - pipe.removeListener('data', onPipeData) - util.destroy(pipe) - }) - - function onPipeData (chunk) { - request.onBodySent(chunk) - } - - return - } - - let finished = false - - const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }) - - const onData = function (chunk) { - if (finished) { - return - } - - try { - if (!writer.write(chunk) && this.pause) { - this.pause() - } - } catch (err) { - util.destroy(this, err) - } - } - const onDrain = function () { - if (finished) { - return - } - - if (body.resume) { - body.resume() - } - } - const onAbort = function () { - if (finished) { - return - } - const err = new RequestAbortedError() - queueMicrotask(() => onFinished(err)) - } - const onFinished = function (err) { - if (finished) { - return - } - - finished = true - - assert(socket.destroyed || (socket[kWriting] && client[kRunning] <= 1)) - - socket - .off('drain', onDrain) - .off('error', onFinished) - - body - .removeListener('data', onData) - .removeListener('end', onFinished) - .removeListener('error', onFinished) - .removeListener('close', onAbort) - - if (!err) { - try { - writer.end() - } catch (er) { - err = er - } - } - - writer.destroy(err) - - if (err && (err.code !== 'UND_ERR_INFO' || err.message !== 'reset')) { - util.destroy(body, err) - } else { - util.destroy(body) - } - } - - body - .on('data', onData) - .on('end', onFinished) - .on('error', onFinished) - .on('close', onAbort) - - if (body.resume) { - body.resume() - } - - socket - .on('drain', onDrain) - .on('error', onFinished) -} - -async function writeBlob ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { - assert(contentLength === body.size, 'blob body must have content length') - - const isH2 = client[kHTTPConnVersion] === 'h2' - try { - if (contentLength != null && contentLength !== body.size) { - throw new RequestContentLengthMismatchError() - } - - const buffer = Buffer.from(await body.arrayBuffer()) - - if (isH2) { - h2stream.cork() - h2stream.write(buffer) - h2stream.uncork() - } else { - socket.cork() - socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1') - socket.write(buffer) - socket.uncork() - } - - request.onBodySent(buffer) - request.onRequestSent() - - if (!expectsPayload) { - socket[kReset] = true - } - - resume(client) - } catch (err) { - util.destroy(isH2 ? h2stream : socket, err) - } -} - -async function writeIterable ({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { - assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined') - - let callback = null - function onDrain () { - if (callback) { - const cb = callback - callback = null - cb() - } - } - - const waitForDrain = () => new Promise((resolve, reject) => { - assert(callback === null) - - if (socket[kError]) { - reject(socket[kError]) - } else { - callback = resolve - } - }) - - if (client[kHTTPConnVersion] === 'h2') { - h2stream - .on('close', onDrain) - .on('drain', onDrain) - - try { - // It's up to the user to somehow abort the async iterable. - for await (const chunk of body) { - if (socket[kError]) { - throw socket[kError] - } - - const res = h2stream.write(chunk) - request.onBodySent(chunk) - if (!res) { - await waitForDrain() - } - } - } catch (err) { - h2stream.destroy(err) - } finally { - request.onRequestSent() - h2stream.end() - h2stream - .off('close', onDrain) - .off('drain', onDrain) - } - - return - } - - socket - .on('close', onDrain) - .on('drain', onDrain) - - const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }) - try { - // It's up to the user to somehow abort the async iterable. - for await (const chunk of body) { - if (socket[kError]) { - throw socket[kError] - } - - if (!writer.write(chunk)) { - await waitForDrain() - } - } - - writer.end() - } catch (err) { - writer.destroy(err) - } finally { - socket - .off('close', onDrain) - .off('drain', onDrain) - } -} - -class AsyncWriter { - constructor ({ socket, request, contentLength, client, expectsPayload, header }) { - this.socket = socket - this.request = request - this.contentLength = contentLength - this.client = client - this.bytesWritten = 0 - this.expectsPayload = expectsPayload - this.header = header - - socket[kWriting] = true - } - - write (chunk) { - const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this - - if (socket[kError]) { - throw socket[kError] - } - - if (socket.destroyed) { - return false - } - - const len = Buffer.byteLength(chunk) - if (!len) { - return true - } - - // We should defer writing chunks. - if (contentLength !== null && bytesWritten + len > contentLength) { - if (client[kStrictContentLength]) { - throw new RequestContentLengthMismatchError() - } - - process.emitWarning(new RequestContentLengthMismatchError()) - } - - socket.cork() - - if (bytesWritten === 0) { - if (!expectsPayload) { - socket[kReset] = true - } - - if (contentLength === null) { - socket.write(`${header}transfer-encoding: chunked\r\n`, 'latin1') - } else { - socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1') - } - } - - if (contentLength === null) { - socket.write(`\r\n${len.toString(16)}\r\n`, 'latin1') - } - - this.bytesWritten += len - - const ret = socket.write(chunk) - - socket.uncork() - - request.onBodySent(chunk) - - if (!ret) { - if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { - // istanbul ignore else: only for jest - if (socket[kParser].timeout.refresh) { - socket[kParser].timeout.refresh() - } - } - } - - return ret - } - - end () { - const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this - request.onRequestSent() - - socket[kWriting] = false - - if (socket[kError]) { - throw socket[kError] - } - - if (socket.destroyed) { - return - } - - if (bytesWritten === 0) { - if (expectsPayload) { - // https://tools.ietf.org/html/rfc7230#section-3.3.2 - // A user agent SHOULD send a Content-Length in a request message when - // no Transfer-Encoding is sent and the request method defines a meaning - // for an enclosed payload body. - - socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1') - } else { - socket.write(`${header}\r\n`, 'latin1') - } - } else if (contentLength === null) { - socket.write('\r\n0\r\n\r\n', 'latin1') - } - - if (contentLength !== null && bytesWritten !== contentLength) { - if (client[kStrictContentLength]) { - throw new RequestContentLengthMismatchError() - } else { - process.emitWarning(new RequestContentLengthMismatchError()) - } - } - - if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { - // istanbul ignore else: only for jest - if (socket[kParser].timeout.refresh) { - socket[kParser].timeout.refresh() - } - } - - resume(client) - } - - destroy (err) { - const { socket, client } = this - - socket[kWriting] = false - - if (err) { - assert(client[kRunning] <= 1, 'pipeline should only contain this request') - util.destroy(socket, err) - } - } -} - -function errorRequest (client, request, err) { - try { - request.onError(err) - assert(request.aborted) - } catch (err) { - client.emit('error', err) - } -} - -module.exports = Client - - -/***/ }), - -/***/ 3194: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -/* istanbul ignore file: only for Node 12 */ - -const { kConnected, kSize } = __nccwpck_require__(6443) - -class CompatWeakRef { - constructor (value) { - this.value = value - } - - deref () { - return this.value[kConnected] === 0 && this.value[kSize] === 0 - ? undefined - : this.value - } -} - -class CompatFinalizer { - constructor (finalizer) { - this.finalizer = finalizer - } - - register (dispatcher, key) { - if (dispatcher.on) { - dispatcher.on('disconnect', () => { - if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) { - this.finalizer(key) - } - }) - } - } -} - -module.exports = function () { - // FIXME: remove workaround when the Node bug is fixed - // https://github.com/nodejs/node/issues/49344#issuecomment-1741776308 - if (process.env.NODE_V8_COVERAGE) { - return { - WeakRef: CompatWeakRef, - FinalizationRegistry: CompatFinalizer - } - } - return { - WeakRef: global.WeakRef || CompatWeakRef, - FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer - } -} - - -/***/ }), - -/***/ 9237: -/***/ ((module) => { - -"use strict"; - - -// https://wicg.github.io/cookie-store/#cookie-maximum-attribute-value-size -const maxAttributeValueSize = 1024 - -// https://wicg.github.io/cookie-store/#cookie-maximum-name-value-pair-size -const maxNameValuePairSize = 4096 - -module.exports = { - maxAttributeValueSize, - maxNameValuePairSize -} - - -/***/ }), - -/***/ 3168: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { parseSetCookie } = __nccwpck_require__(8915) -const { stringify } = __nccwpck_require__(3834) -const { webidl } = __nccwpck_require__(4222) -const { Headers } = __nccwpck_require__(6349) - -/** - * @typedef {Object} Cookie - * @property {string} name - * @property {string} value - * @property {Date|number|undefined} expires - * @property {number|undefined} maxAge - * @property {string|undefined} domain - * @property {string|undefined} path - * @property {boolean|undefined} secure - * @property {boolean|undefined} httpOnly - * @property {'Strict'|'Lax'|'None'} sameSite - * @property {string[]} unparsed - */ - -/** - * @param {Headers} headers - * @returns {Record} - */ -function getCookies (headers) { - webidl.argumentLengthCheck(arguments, 1, { header: 'getCookies' }) - - webidl.brandCheck(headers, Headers, { strict: false }) - - const cookie = headers.get('cookie') - const out = {} - - if (!cookie) { - return out - } - - for (const piece of cookie.split(';')) { - const [name, ...value] = piece.split('=') - - out[name.trim()] = value.join('=') - } - - return out -} - -/** - * @param {Headers} headers - * @param {string} name - * @param {{ path?: string, domain?: string }|undefined} attributes - * @returns {void} - */ -function deleteCookie (headers, name, attributes) { - webidl.argumentLengthCheck(arguments, 2, { header: 'deleteCookie' }) - - webidl.brandCheck(headers, Headers, { strict: false }) - - name = webidl.converters.DOMString(name) - attributes = webidl.converters.DeleteCookieAttributes(attributes) - - // Matches behavior of - // https://github.com/denoland/deno_std/blob/63827b16330b82489a04614027c33b7904e08be5/http/cookie.ts#L278 - setCookie(headers, { - name, - value: '', - expires: new Date(0), - ...attributes - }) -} - -/** - * @param {Headers} headers - * @returns {Cookie[]} - */ -function getSetCookies (headers) { - webidl.argumentLengthCheck(arguments, 1, { header: 'getSetCookies' }) - - webidl.brandCheck(headers, Headers, { strict: false }) - - const cookies = headers.getSetCookie() - - if (!cookies) { - return [] - } - - return cookies.map((pair) => parseSetCookie(pair)) -} - -/** - * @param {Headers} headers - * @param {Cookie} cookie - * @returns {void} - */ -function setCookie (headers, cookie) { - webidl.argumentLengthCheck(arguments, 2, { header: 'setCookie' }) - - webidl.brandCheck(headers, Headers, { strict: false }) - - cookie = webidl.converters.Cookie(cookie) - - const str = stringify(cookie) - - if (str) { - headers.append('Set-Cookie', stringify(cookie)) - } -} - -webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([ - { - converter: webidl.nullableConverter(webidl.converters.DOMString), - key: 'path', - defaultValue: null - }, - { - converter: webidl.nullableConverter(webidl.converters.DOMString), - key: 'domain', - defaultValue: null - } -]) - -webidl.converters.Cookie = webidl.dictionaryConverter([ - { - converter: webidl.converters.DOMString, - key: 'name' - }, - { - converter: webidl.converters.DOMString, - key: 'value' - }, - { - converter: webidl.nullableConverter((value) => { - if (typeof value === 'number') { - return webidl.converters['unsigned long long'](value) - } - - return new Date(value) - }), - key: 'expires', - defaultValue: null - }, - { - converter: webidl.nullableConverter(webidl.converters['long long']), - key: 'maxAge', - defaultValue: null - }, - { - converter: webidl.nullableConverter(webidl.converters.DOMString), - key: 'domain', - defaultValue: null - }, - { - converter: webidl.nullableConverter(webidl.converters.DOMString), - key: 'path', - defaultValue: null - }, - { - converter: webidl.nullableConverter(webidl.converters.boolean), - key: 'secure', - defaultValue: null - }, - { - converter: webidl.nullableConverter(webidl.converters.boolean), - key: 'httpOnly', - defaultValue: null - }, - { - converter: webidl.converters.USVString, - key: 'sameSite', - allowedValues: ['Strict', 'Lax', 'None'] - }, - { - converter: webidl.sequenceConverter(webidl.converters.DOMString), - key: 'unparsed', - defaultValue: [] - } -]) - -module.exports = { - getCookies, - deleteCookie, - getSetCookies, - setCookie -} - - -/***/ }), - -/***/ 8915: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { maxNameValuePairSize, maxAttributeValueSize } = __nccwpck_require__(9237) -const { isCTLExcludingHtab } = __nccwpck_require__(3834) -const { collectASequenceOfCodePointsFast } = __nccwpck_require__(4322) -const assert = __nccwpck_require__(2613) - -/** - * @description Parses the field-value attributes of a set-cookie header string. - * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4 - * @param {string} header - * @returns if the header is invalid, null will be returned - */ -function parseSetCookie (header) { - // 1. If the set-cookie-string contains a %x00-08 / %x0A-1F / %x7F - // character (CTL characters excluding HTAB): Abort these steps and - // ignore the set-cookie-string entirely. - if (isCTLExcludingHtab(header)) { - return null - } - - let nameValuePair = '' - let unparsedAttributes = '' - let name = '' - let value = '' - - // 2. If the set-cookie-string contains a %x3B (";") character: - if (header.includes(';')) { - // 1. The name-value-pair string consists of the characters up to, - // but not including, the first %x3B (";"), and the unparsed- - // attributes consist of the remainder of the set-cookie-string - // (including the %x3B (";") in question). - const position = { position: 0 } - - nameValuePair = collectASequenceOfCodePointsFast(';', header, position) - unparsedAttributes = header.slice(position.position) - } else { - // Otherwise: - - // 1. The name-value-pair string consists of all the characters - // contained in the set-cookie-string, and the unparsed- - // attributes is the empty string. - nameValuePair = header - } - - // 3. If the name-value-pair string lacks a %x3D ("=") character, then - // the name string is empty, and the value string is the value of - // name-value-pair. - if (!nameValuePair.includes('=')) { - value = nameValuePair - } else { - // Otherwise, the name string consists of the characters up to, but - // not including, the first %x3D ("=") character, and the (possibly - // empty) value string consists of the characters after the first - // %x3D ("=") character. - const position = { position: 0 } - name = collectASequenceOfCodePointsFast( - '=', - nameValuePair, - position - ) - value = nameValuePair.slice(position.position + 1) - } - - // 4. Remove any leading or trailing WSP characters from the name - // string and the value string. - name = name.trim() - value = value.trim() - - // 5. If the sum of the lengths of the name string and the value string - // is more than 4096 octets, abort these steps and ignore the set- - // cookie-string entirely. - if (name.length + value.length > maxNameValuePairSize) { - return null - } - - // 6. The cookie-name is the name string, and the cookie-value is the - // value string. - return { - name, value, ...parseUnparsedAttributes(unparsedAttributes) - } -} - -/** - * Parses the remaining attributes of a set-cookie header - * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4 - * @param {string} unparsedAttributes - * @param {[Object.]={}} cookieAttributeList - */ -function parseUnparsedAttributes (unparsedAttributes, cookieAttributeList = {}) { - // 1. If the unparsed-attributes string is empty, skip the rest of - // these steps. - if (unparsedAttributes.length === 0) { - return cookieAttributeList - } - - // 2. Discard the first character of the unparsed-attributes (which - // will be a %x3B (";") character). - assert(unparsedAttributes[0] === ';') - unparsedAttributes = unparsedAttributes.slice(1) - - let cookieAv = '' - - // 3. If the remaining unparsed-attributes contains a %x3B (";") - // character: - if (unparsedAttributes.includes(';')) { - // 1. Consume the characters of the unparsed-attributes up to, but - // not including, the first %x3B (";") character. - cookieAv = collectASequenceOfCodePointsFast( - ';', - unparsedAttributes, - { position: 0 } - ) - unparsedAttributes = unparsedAttributes.slice(cookieAv.length) - } else { - // Otherwise: - - // 1. Consume the remainder of the unparsed-attributes. - cookieAv = unparsedAttributes - unparsedAttributes = '' - } - - // Let the cookie-av string be the characters consumed in this step. - - let attributeName = '' - let attributeValue = '' - - // 4. If the cookie-av string contains a %x3D ("=") character: - if (cookieAv.includes('=')) { - // 1. The (possibly empty) attribute-name string consists of the - // characters up to, but not including, the first %x3D ("=") - // character, and the (possibly empty) attribute-value string - // consists of the characters after the first %x3D ("=") - // character. - const position = { position: 0 } - - attributeName = collectASequenceOfCodePointsFast( - '=', - cookieAv, - position - ) - attributeValue = cookieAv.slice(position.position + 1) - } else { - // Otherwise: - - // 1. The attribute-name string consists of the entire cookie-av - // string, and the attribute-value string is empty. - attributeName = cookieAv - } - - // 5. Remove any leading or trailing WSP characters from the attribute- - // name string and the attribute-value string. - attributeName = attributeName.trim() - attributeValue = attributeValue.trim() - - // 6. If the attribute-value is longer than 1024 octets, ignore the - // cookie-av string and return to Step 1 of this algorithm. - if (attributeValue.length > maxAttributeValueSize) { - return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList) - } - - // 7. Process the attribute-name and attribute-value according to the - // requirements in the following subsections. (Notice that - // attributes with unrecognized attribute-names are ignored.) - const attributeNameLowercase = attributeName.toLowerCase() - - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.1 - // If the attribute-name case-insensitively matches the string - // "Expires", the user agent MUST process the cookie-av as follows. - if (attributeNameLowercase === 'expires') { - // 1. Let the expiry-time be the result of parsing the attribute-value - // as cookie-date (see Section 5.1.1). - const expiryTime = new Date(attributeValue) - - // 2. If the attribute-value failed to parse as a cookie date, ignore - // the cookie-av. - - cookieAttributeList.expires = expiryTime - } else if (attributeNameLowercase === 'max-age') { - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.2 - // If the attribute-name case-insensitively matches the string "Max- - // Age", the user agent MUST process the cookie-av as follows. - - // 1. If the first character of the attribute-value is not a DIGIT or a - // "-" character, ignore the cookie-av. - const charCode = attributeValue.charCodeAt(0) - - if ((charCode < 48 || charCode > 57) && attributeValue[0] !== '-') { - return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList) - } - - // 2. If the remainder of attribute-value contains a non-DIGIT - // character, ignore the cookie-av. - if (!/^\d+$/.test(attributeValue)) { - return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList) - } - - // 3. Let delta-seconds be the attribute-value converted to an integer. - const deltaSeconds = Number(attributeValue) - - // 4. Let cookie-age-limit be the maximum age of the cookie (which - // SHOULD be 400 days or less, see Section 4.1.2.2). - - // 5. Set delta-seconds to the smaller of its present value and cookie- - // age-limit. - // deltaSeconds = Math.min(deltaSeconds * 1000, maxExpiresMs) - - // 6. If delta-seconds is less than or equal to zero (0), let expiry- - // time be the earliest representable date and time. Otherwise, let - // the expiry-time be the current date and time plus delta-seconds - // seconds. - // const expiryTime = deltaSeconds <= 0 ? Date.now() : Date.now() + deltaSeconds - - // 7. Append an attribute to the cookie-attribute-list with an - // attribute-name of Max-Age and an attribute-value of expiry-time. - cookieAttributeList.maxAge = deltaSeconds - } else if (attributeNameLowercase === 'domain') { - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.3 - // If the attribute-name case-insensitively matches the string "Domain", - // the user agent MUST process the cookie-av as follows. - - // 1. Let cookie-domain be the attribute-value. - let cookieDomain = attributeValue - - // 2. If cookie-domain starts with %x2E ("."), let cookie-domain be - // cookie-domain without its leading %x2E ("."). - if (cookieDomain[0] === '.') { - cookieDomain = cookieDomain.slice(1) - } - - // 3. Convert the cookie-domain to lower case. - cookieDomain = cookieDomain.toLowerCase() - - // 4. Append an attribute to the cookie-attribute-list with an - // attribute-name of Domain and an attribute-value of cookie-domain. - cookieAttributeList.domain = cookieDomain - } else if (attributeNameLowercase === 'path') { - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.4 - // If the attribute-name case-insensitively matches the string "Path", - // the user agent MUST process the cookie-av as follows. - - // 1. If the attribute-value is empty or if the first character of the - // attribute-value is not %x2F ("/"): - let cookiePath = '' - if (attributeValue.length === 0 || attributeValue[0] !== '/') { - // 1. Let cookie-path be the default-path. - cookiePath = '/' - } else { - // Otherwise: - - // 1. Let cookie-path be the attribute-value. - cookiePath = attributeValue - } - - // 2. Append an attribute to the cookie-attribute-list with an - // attribute-name of Path and an attribute-value of cookie-path. - cookieAttributeList.path = cookiePath - } else if (attributeNameLowercase === 'secure') { - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.5 - // If the attribute-name case-insensitively matches the string "Secure", - // the user agent MUST append an attribute to the cookie-attribute-list - // with an attribute-name of Secure and an empty attribute-value. - - cookieAttributeList.secure = true - } else if (attributeNameLowercase === 'httponly') { - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.6 - // If the attribute-name case-insensitively matches the string - // "HttpOnly", the user agent MUST append an attribute to the cookie- - // attribute-list with an attribute-name of HttpOnly and an empty - // attribute-value. - - cookieAttributeList.httpOnly = true - } else if (attributeNameLowercase === 'samesite') { - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.7 - // If the attribute-name case-insensitively matches the string - // "SameSite", the user agent MUST process the cookie-av as follows: - - // 1. Let enforcement be "Default". - let enforcement = 'Default' - - const attributeValueLowercase = attributeValue.toLowerCase() - // 2. If cookie-av's attribute-value is a case-insensitive match for - // "None", set enforcement to "None". - if (attributeValueLowercase.includes('none')) { - enforcement = 'None' - } - - // 3. If cookie-av's attribute-value is a case-insensitive match for - // "Strict", set enforcement to "Strict". - if (attributeValueLowercase.includes('strict')) { - enforcement = 'Strict' - } - - // 4. If cookie-av's attribute-value is a case-insensitive match for - // "Lax", set enforcement to "Lax". - if (attributeValueLowercase.includes('lax')) { - enforcement = 'Lax' - } - - // 5. Append an attribute to the cookie-attribute-list with an - // attribute-name of "SameSite" and an attribute-value of - // enforcement. - cookieAttributeList.sameSite = enforcement - } else { - cookieAttributeList.unparsed ??= [] - - cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`) - } - - // 8. Return to Step 1 of this algorithm. - return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList) -} - -module.exports = { - parseSetCookie, - parseUnparsedAttributes -} - - -/***/ }), - -/***/ 3834: -/***/ ((module) => { - -"use strict"; - - -/** - * @param {string} value - * @returns {boolean} - */ -function isCTLExcludingHtab (value) { - if (value.length === 0) { - return false - } - - for (const char of value) { - const code = char.charCodeAt(0) - - if ( - (code >= 0x00 || code <= 0x08) || - (code >= 0x0A || code <= 0x1F) || - code === 0x7F - ) { - return false - } - } -} - -/** - CHAR = - token = 1* - separators = "(" | ")" | "<" | ">" | "@" - | "," | ";" | ":" | "\" | <"> - | "/" | "[" | "]" | "?" | "=" - | "{" | "}" | SP | HT - * @param {string} name - */ -function validateCookieName (name) { - for (const char of name) { - const code = char.charCodeAt(0) - - if ( - (code <= 0x20 || code > 0x7F) || - char === '(' || - char === ')' || - char === '>' || - char === '<' || - char === '@' || - char === ',' || - char === ';' || - char === ':' || - char === '\\' || - char === '"' || - char === '/' || - char === '[' || - char === ']' || - char === '?' || - char === '=' || - char === '{' || - char === '}' - ) { - throw new Error('Invalid cookie name') - } - } -} - -/** - cookie-value = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE ) - cookie-octet = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E - ; US-ASCII characters excluding CTLs, - ; whitespace DQUOTE, comma, semicolon, - ; and backslash - * @param {string} value - */ -function validateCookieValue (value) { - for (const char of value) { - const code = char.charCodeAt(0) - - if ( - code < 0x21 || // exclude CTLs (0-31) - code === 0x22 || - code === 0x2C || - code === 0x3B || - code === 0x5C || - code > 0x7E // non-ascii - ) { - throw new Error('Invalid header value') - } - } -} - -/** - * path-value = - * @param {string} path - */ -function validateCookiePath (path) { - for (const char of path) { - const code = char.charCodeAt(0) - - if (code < 0x21 || char === ';') { - throw new Error('Invalid cookie path') - } - } -} - -/** - * I have no idea why these values aren't allowed to be honest, - * but Deno tests these. - Khafra - * @param {string} domain - */ -function validateCookieDomain (domain) { - if ( - domain.startsWith('-') || - domain.endsWith('.') || - domain.endsWith('-') - ) { - throw new Error('Invalid cookie domain') - } -} - -/** - * @see https://www.rfc-editor.org/rfc/rfc7231#section-7.1.1.1 - * @param {number|Date} date - IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT - ; fixed length/zone/capitalization subset of the format - ; see Section 3.3 of [RFC5322] - - day-name = %x4D.6F.6E ; "Mon", case-sensitive - / %x54.75.65 ; "Tue", case-sensitive - / %x57.65.64 ; "Wed", case-sensitive - / %x54.68.75 ; "Thu", case-sensitive - / %x46.72.69 ; "Fri", case-sensitive - / %x53.61.74 ; "Sat", case-sensitive - / %x53.75.6E ; "Sun", case-sensitive - date1 = day SP month SP year - ; e.g., 02 Jun 1982 - - day = 2DIGIT - month = %x4A.61.6E ; "Jan", case-sensitive - / %x46.65.62 ; "Feb", case-sensitive - / %x4D.61.72 ; "Mar", case-sensitive - / %x41.70.72 ; "Apr", case-sensitive - / %x4D.61.79 ; "May", case-sensitive - / %x4A.75.6E ; "Jun", case-sensitive - / %x4A.75.6C ; "Jul", case-sensitive - / %x41.75.67 ; "Aug", case-sensitive - / %x53.65.70 ; "Sep", case-sensitive - / %x4F.63.74 ; "Oct", case-sensitive - / %x4E.6F.76 ; "Nov", case-sensitive - / %x44.65.63 ; "Dec", case-sensitive - year = 4DIGIT - - GMT = %x47.4D.54 ; "GMT", case-sensitive - - time-of-day = hour ":" minute ":" second - ; 00:00:00 - 23:59:60 (leap second) - - hour = 2DIGIT - minute = 2DIGIT - second = 2DIGIT - */ -function toIMFDate (date) { - if (typeof date === 'number') { - date = new Date(date) - } - - const days = [ - 'Sun', 'Mon', 'Tue', 'Wed', - 'Thu', 'Fri', 'Sat' - ] - - const months = [ - 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', - 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' - ] - - const dayName = days[date.getUTCDay()] - const day = date.getUTCDate().toString().padStart(2, '0') - const month = months[date.getUTCMonth()] - const year = date.getUTCFullYear() - const hour = date.getUTCHours().toString().padStart(2, '0') - const minute = date.getUTCMinutes().toString().padStart(2, '0') - const second = date.getUTCSeconds().toString().padStart(2, '0') - - return `${dayName}, ${day} ${month} ${year} ${hour}:${minute}:${second} GMT` -} - -/** - max-age-av = "Max-Age=" non-zero-digit *DIGIT - ; In practice, both expires-av and max-age-av - ; are limited to dates representable by the - ; user agent. - * @param {number} maxAge - */ -function validateCookieMaxAge (maxAge) { - if (maxAge < 0) { - throw new Error('Invalid cookie max-age') - } -} - -/** - * @see https://www.rfc-editor.org/rfc/rfc6265#section-4.1.1 - * @param {import('./index').Cookie} cookie - */ -function stringify (cookie) { - if (cookie.name.length === 0) { - return null - } - - validateCookieName(cookie.name) - validateCookieValue(cookie.value) - - const out = [`${cookie.name}=${cookie.value}`] - - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.1 - // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.2 - if (cookie.name.startsWith('__Secure-')) { - cookie.secure = true - } - - if (cookie.name.startsWith('__Host-')) { - cookie.secure = true - cookie.domain = null - cookie.path = '/' - } - - if (cookie.secure) { - out.push('Secure') - } - - if (cookie.httpOnly) { - out.push('HttpOnly') - } - - if (typeof cookie.maxAge === 'number') { - validateCookieMaxAge(cookie.maxAge) - out.push(`Max-Age=${cookie.maxAge}`) - } - - if (cookie.domain) { - validateCookieDomain(cookie.domain) - out.push(`Domain=${cookie.domain}`) - } - - if (cookie.path) { - validateCookiePath(cookie.path) - out.push(`Path=${cookie.path}`) - } - - if (cookie.expires && cookie.expires.toString() !== 'Invalid Date') { - out.push(`Expires=${toIMFDate(cookie.expires)}`) - } - - if (cookie.sameSite) { - out.push(`SameSite=${cookie.sameSite}`) - } - - for (const part of cookie.unparsed) { - if (!part.includes('=')) { - throw new Error('Invalid unparsed') - } - - const [key, ...value] = part.split('=') - - out.push(`${key.trim()}=${value.join('=')}`) - } - - return out.join('; ') -} - -module.exports = { - isCTLExcludingHtab, - validateCookieName, - validateCookiePath, - validateCookieValue, - toIMFDate, - stringify -} - - -/***/ }), - -/***/ 9136: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const net = __nccwpck_require__(9278) -const assert = __nccwpck_require__(2613) -const util = __nccwpck_require__(3440) -const { InvalidArgumentError, ConnectTimeoutError } = __nccwpck_require__(8707) - -let tls // include tls conditionally since it is not always available - -// TODO: session re-use does not wait for the first -// connection to resolve the session and might therefore -// resolve the same servername multiple times even when -// re-use is enabled. - -let SessionCache -// FIXME: remove workaround when the Node bug is fixed -// https://github.com/nodejs/node/issues/49344#issuecomment-1741776308 -if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) { - SessionCache = class WeakSessionCache { - constructor (maxCachedSessions) { - this._maxCachedSessions = maxCachedSessions - this._sessionCache = new Map() - this._sessionRegistry = new global.FinalizationRegistry((key) => { - if (this._sessionCache.size < this._maxCachedSessions) { - return - } - - const ref = this._sessionCache.get(key) - if (ref !== undefined && ref.deref() === undefined) { - this._sessionCache.delete(key) - } - }) - } - - get (sessionKey) { - const ref = this._sessionCache.get(sessionKey) - return ref ? ref.deref() : null - } - - set (sessionKey, session) { - if (this._maxCachedSessions === 0) { - return - } - - this._sessionCache.set(sessionKey, new WeakRef(session)) - this._sessionRegistry.register(session, sessionKey) - } - } -} else { - SessionCache = class SimpleSessionCache { - constructor (maxCachedSessions) { - this._maxCachedSessions = maxCachedSessions - this._sessionCache = new Map() - } - - get (sessionKey) { - return this._sessionCache.get(sessionKey) - } - - set (sessionKey, session) { - if (this._maxCachedSessions === 0) { - return - } - - if (this._sessionCache.size >= this._maxCachedSessions) { - // remove the oldest session - const { value: oldestKey } = this._sessionCache.keys().next() - this._sessionCache.delete(oldestKey) - } - - this._sessionCache.set(sessionKey, session) - } - } -} - -function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) { - if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { - throw new InvalidArgumentError('maxCachedSessions must be a positive integer or zero') - } - - const options = { path: socketPath, ...opts } - const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions) - timeout = timeout == null ? 10e3 : timeout - allowH2 = allowH2 != null ? allowH2 : false - return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { - let socket - if (protocol === 'https:') { - if (!tls) { - tls = __nccwpck_require__(4756) - } - servername = servername || options.servername || util.getServerName(host) || null - - const sessionKey = servername || hostname - const session = sessionCache.get(sessionKey) || null - - assert(sessionKey) - - socket = tls.connect({ - highWaterMark: 16384, // TLS in node can't have bigger HWM anyway... - ...options, - servername, - session, - localAddress, - // TODO(HTTP/2): Add support for h2c - ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'], - socket: httpSocket, // upgrade socket connection - port: port || 443, - host: hostname - }) - - socket - .on('session', function (session) { - // TODO (fix): Can a session become invalid once established? Don't think so? - sessionCache.set(sessionKey, session) - }) - } else { - assert(!httpSocket, 'httpSocket can only be sent on TLS update') - socket = net.connect({ - highWaterMark: 64 * 1024, // Same as nodejs fs streams. - ...options, - localAddress, - port: port || 80, - host: hostname - }) - } - - // Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket - if (options.keepAlive == null || options.keepAlive) { - const keepAliveInitialDelay = options.keepAliveInitialDelay === undefined ? 60e3 : options.keepAliveInitialDelay - socket.setKeepAlive(true, keepAliveInitialDelay) - } - - const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout) - - socket - .setNoDelay(true) - .once(protocol === 'https:' ? 'secureConnect' : 'connect', function () { - cancelTimeout() - - if (callback) { - const cb = callback - callback = null - cb(null, this) - } - }) - .on('error', function (err) { - cancelTimeout() - - if (callback) { - const cb = callback - callback = null - cb(err) - } - }) - - return socket - } -} - -function setupTimeout (onConnectTimeout, timeout) { - if (!timeout) { - return () => {} - } - - let s1 = null - let s2 = null - const timeoutId = setTimeout(() => { - // setImmediate is added to make sure that we priotorise socket error events over timeouts - s1 = setImmediate(() => { - if (process.platform === 'win32') { - // Windows needs an extra setImmediate probably due to implementation differences in the socket logic - s2 = setImmediate(() => onConnectTimeout()) - } else { - onConnectTimeout() - } - }) - }, timeout) - return () => { - clearTimeout(timeoutId) - clearImmediate(s1) - clearImmediate(s2) - } -} - -function onConnectTimeout (socket) { - util.destroy(socket, new ConnectTimeoutError()) -} - -module.exports = buildConnector - - -/***/ }), - -/***/ 735: -/***/ ((module) => { - -"use strict"; - - -/** @type {Record} */ -const headerNameLowerCasedRecord = {} - -// https://developer.mozilla.org/docs/Web/HTTP/Headers -const wellknownHeaderNames = [ - 'Accept', - 'Accept-Encoding', - 'Accept-Language', - 'Accept-Ranges', - 'Access-Control-Allow-Credentials', - 'Access-Control-Allow-Headers', - 'Access-Control-Allow-Methods', - 'Access-Control-Allow-Origin', - 'Access-Control-Expose-Headers', - 'Access-Control-Max-Age', - 'Access-Control-Request-Headers', - 'Access-Control-Request-Method', - 'Age', - 'Allow', - 'Alt-Svc', - 'Alt-Used', - 'Authorization', - 'Cache-Control', - 'Clear-Site-Data', - 'Connection', - 'Content-Disposition', - 'Content-Encoding', - 'Content-Language', - 'Content-Length', - 'Content-Location', - 'Content-Range', - 'Content-Security-Policy', - 'Content-Security-Policy-Report-Only', - 'Content-Type', - 'Cookie', - 'Cross-Origin-Embedder-Policy', - 'Cross-Origin-Opener-Policy', - 'Cross-Origin-Resource-Policy', - 'Date', - 'Device-Memory', - 'Downlink', - 'ECT', - 'ETag', - 'Expect', - 'Expect-CT', - 'Expires', - 'Forwarded', - 'From', - 'Host', - 'If-Match', - 'If-Modified-Since', - 'If-None-Match', - 'If-Range', - 'If-Unmodified-Since', - 'Keep-Alive', - 'Last-Modified', - 'Link', - 'Location', - 'Max-Forwards', - 'Origin', - 'Permissions-Policy', - 'Pragma', - 'Proxy-Authenticate', - 'Proxy-Authorization', - 'RTT', - 'Range', - 'Referer', - 'Referrer-Policy', - 'Refresh', - 'Retry-After', - 'Sec-WebSocket-Accept', - 'Sec-WebSocket-Extensions', - 'Sec-WebSocket-Key', - 'Sec-WebSocket-Protocol', - 'Sec-WebSocket-Version', - 'Server', - 'Server-Timing', - 'Service-Worker-Allowed', - 'Service-Worker-Navigation-Preload', - 'Set-Cookie', - 'SourceMap', - 'Strict-Transport-Security', - 'Supports-Loading-Mode', - 'TE', - 'Timing-Allow-Origin', - 'Trailer', - 'Transfer-Encoding', - 'Upgrade', - 'Upgrade-Insecure-Requests', - 'User-Agent', - 'Vary', - 'Via', - 'WWW-Authenticate', - 'X-Content-Type-Options', - 'X-DNS-Prefetch-Control', - 'X-Frame-Options', - 'X-Permitted-Cross-Domain-Policies', - 'X-Powered-By', - 'X-Requested-With', - 'X-XSS-Protection' -] - -for (let i = 0; i < wellknownHeaderNames.length; ++i) { - const key = wellknownHeaderNames[i] - const lowerCasedKey = key.toLowerCase() - headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = - lowerCasedKey -} - -// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`. -Object.setPrototypeOf(headerNameLowerCasedRecord, null) - -module.exports = { - wellknownHeaderNames, - headerNameLowerCasedRecord -} - - -/***/ }), - -/***/ 8707: -/***/ ((module) => { - -"use strict"; - - -class UndiciError extends Error { - constructor (message) { - super(message) - this.name = 'UndiciError' - this.code = 'UND_ERR' - } -} - -class ConnectTimeoutError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, ConnectTimeoutError) - this.name = 'ConnectTimeoutError' - this.message = message || 'Connect Timeout Error' - this.code = 'UND_ERR_CONNECT_TIMEOUT' - } -} - -class HeadersTimeoutError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, HeadersTimeoutError) - this.name = 'HeadersTimeoutError' - this.message = message || 'Headers Timeout Error' - this.code = 'UND_ERR_HEADERS_TIMEOUT' - } -} - -class HeadersOverflowError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, HeadersOverflowError) - this.name = 'HeadersOverflowError' - this.message = message || 'Headers Overflow Error' - this.code = 'UND_ERR_HEADERS_OVERFLOW' - } -} - -class BodyTimeoutError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, BodyTimeoutError) - this.name = 'BodyTimeoutError' - this.message = message || 'Body Timeout Error' - this.code = 'UND_ERR_BODY_TIMEOUT' - } -} - -class ResponseStatusCodeError extends UndiciError { - constructor (message, statusCode, headers, body) { - super(message) - Error.captureStackTrace(this, ResponseStatusCodeError) - this.name = 'ResponseStatusCodeError' - this.message = message || 'Response Status Code Error' - this.code = 'UND_ERR_RESPONSE_STATUS_CODE' - this.body = body - this.status = statusCode - this.statusCode = statusCode - this.headers = headers - } -} - -class InvalidArgumentError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, InvalidArgumentError) - this.name = 'InvalidArgumentError' - this.message = message || 'Invalid Argument Error' - this.code = 'UND_ERR_INVALID_ARG' - } -} - -class InvalidReturnValueError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, InvalidReturnValueError) - this.name = 'InvalidReturnValueError' - this.message = message || 'Invalid Return Value Error' - this.code = 'UND_ERR_INVALID_RETURN_VALUE' - } -} - -class RequestAbortedError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, RequestAbortedError) - this.name = 'AbortError' - this.message = message || 'Request aborted' - this.code = 'UND_ERR_ABORTED' - } -} - -class InformationalError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, InformationalError) - this.name = 'InformationalError' - this.message = message || 'Request information' - this.code = 'UND_ERR_INFO' - } -} - -class RequestContentLengthMismatchError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, RequestContentLengthMismatchError) - this.name = 'RequestContentLengthMismatchError' - this.message = message || 'Request body length does not match content-length header' - this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH' - } -} - -class ResponseContentLengthMismatchError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, ResponseContentLengthMismatchError) - this.name = 'ResponseContentLengthMismatchError' - this.message = message || 'Response body length does not match content-length header' - this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH' - } -} - -class ClientDestroyedError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, ClientDestroyedError) - this.name = 'ClientDestroyedError' - this.message = message || 'The client is destroyed' - this.code = 'UND_ERR_DESTROYED' - } -} - -class ClientClosedError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, ClientClosedError) - this.name = 'ClientClosedError' - this.message = message || 'The client is closed' - this.code = 'UND_ERR_CLOSED' - } -} - -class SocketError extends UndiciError { - constructor (message, socket) { - super(message) - Error.captureStackTrace(this, SocketError) - this.name = 'SocketError' - this.message = message || 'Socket error' - this.code = 'UND_ERR_SOCKET' - this.socket = socket - } -} - -class NotSupportedError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, NotSupportedError) - this.name = 'NotSupportedError' - this.message = message || 'Not supported error' - this.code = 'UND_ERR_NOT_SUPPORTED' - } -} - -class BalancedPoolMissingUpstreamError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, NotSupportedError) - this.name = 'MissingUpstreamError' - this.message = message || 'No upstream has been added to the BalancedPool' - this.code = 'UND_ERR_BPL_MISSING_UPSTREAM' - } -} - -class HTTPParserError extends Error { - constructor (message, code, data) { - super(message) - Error.captureStackTrace(this, HTTPParserError) - this.name = 'HTTPParserError' - this.code = code ? `HPE_${code}` : undefined - this.data = data ? data.toString() : undefined - } -} - -class ResponseExceededMaxSizeError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, ResponseExceededMaxSizeError) - this.name = 'ResponseExceededMaxSizeError' - this.message = message || 'Response content exceeded max size' - this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE' - } -} - -class RequestRetryError extends UndiciError { - constructor (message, code, { headers, data }) { - super(message) - Error.captureStackTrace(this, RequestRetryError) - this.name = 'RequestRetryError' - this.message = message || 'Request retry error' - this.code = 'UND_ERR_REQ_RETRY' - this.statusCode = code - this.data = data - this.headers = headers - } -} - -module.exports = { - HTTPParserError, - UndiciError, - HeadersTimeoutError, - HeadersOverflowError, - BodyTimeoutError, - RequestContentLengthMismatchError, - ConnectTimeoutError, - ResponseStatusCodeError, - InvalidArgumentError, - InvalidReturnValueError, - RequestAbortedError, - ClientDestroyedError, - ClientClosedError, - InformationalError, - SocketError, - NotSupportedError, - ResponseContentLengthMismatchError, - BalancedPoolMissingUpstreamError, - ResponseExceededMaxSizeError, - RequestRetryError -} - - -/***/ }), - -/***/ 4655: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { - InvalidArgumentError, - NotSupportedError -} = __nccwpck_require__(8707) -const assert = __nccwpck_require__(2613) -const { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = __nccwpck_require__(6443) -const util = __nccwpck_require__(3440) - -// tokenRegExp and headerCharRegex have been lifted from -// https://github.com/nodejs/node/blob/main/lib/_http_common.js - -/** - * Verifies that the given val is a valid HTTP token - * per the rules defined in RFC 7230 - * See https://tools.ietf.org/html/rfc7230#section-3.2.6 - */ -const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/ - -/** - * Matches if val contains an invalid field-vchar - * field-value = *( field-content / obs-fold ) - * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ] - * field-vchar = VCHAR / obs-text - */ -const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/ - -// Verifies that a given path is valid does not contain control chars \x00 to \x20 -const invalidPathRegex = /[^\u0021-\u00ff]/ - -const kHandler = Symbol('handler') - -const channels = {} - -let extractBody - -try { - const diagnosticsChannel = __nccwpck_require__(1637) - channels.create = diagnosticsChannel.channel('undici:request:create') - channels.bodySent = diagnosticsChannel.channel('undici:request:bodySent') - channels.headers = diagnosticsChannel.channel('undici:request:headers') - channels.trailers = diagnosticsChannel.channel('undici:request:trailers') - channels.error = diagnosticsChannel.channel('undici:request:error') -} catch { - channels.create = { hasSubscribers: false } - channels.bodySent = { hasSubscribers: false } - channels.headers = { hasSubscribers: false } - channels.trailers = { hasSubscribers: false } - channels.error = { hasSubscribers: false } -} - -class Request { - constructor (origin, { - path, - method, - body, - headers, - query, - idempotent, - blocking, - upgrade, - headersTimeout, - bodyTimeout, - reset, - throwOnError, - expectContinue - }, handler) { - if (typeof path !== 'string') { - throw new InvalidArgumentError('path must be a string') - } else if ( - path[0] !== '/' && - !(path.startsWith('http://') || path.startsWith('https://')) && - method !== 'CONNECT' - ) { - throw new InvalidArgumentError('path must be an absolute URL or start with a slash') - } else if (invalidPathRegex.exec(path) !== null) { - throw new InvalidArgumentError('invalid request path') - } - - if (typeof method !== 'string') { - throw new InvalidArgumentError('method must be a string') - } else if (tokenRegExp.exec(method) === null) { - throw new InvalidArgumentError('invalid request method') - } - - if (upgrade && typeof upgrade !== 'string') { - throw new InvalidArgumentError('upgrade must be a string') - } - - if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { - throw new InvalidArgumentError('invalid headersTimeout') - } - - if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) { - throw new InvalidArgumentError('invalid bodyTimeout') - } - - if (reset != null && typeof reset !== 'boolean') { - throw new InvalidArgumentError('invalid reset') - } - - if (expectContinue != null && typeof expectContinue !== 'boolean') { - throw new InvalidArgumentError('invalid expectContinue') - } - - this.headersTimeout = headersTimeout - - this.bodyTimeout = bodyTimeout - - this.throwOnError = throwOnError === true - - this.method = method - - this.abort = null - - if (body == null) { - this.body = null - } else if (util.isStream(body)) { - this.body = body - - const rState = this.body._readableState - if (!rState || !rState.autoDestroy) { - this.endHandler = function autoDestroy () { - util.destroy(this) - } - this.body.on('end', this.endHandler) - } - - this.errorHandler = err => { - if (this.abort) { - this.abort(err) - } else { - this.error = err - } - } - this.body.on('error', this.errorHandler) - } else if (util.isBuffer(body)) { - this.body = body.byteLength ? body : null - } else if (ArrayBuffer.isView(body)) { - this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null - } else if (body instanceof ArrayBuffer) { - this.body = body.byteLength ? Buffer.from(body) : null - } else if (typeof body === 'string') { - this.body = body.length ? Buffer.from(body) : null - } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) { - this.body = body - } else { - throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable') - } - - this.completed = false - - this.aborted = false - - this.upgrade = upgrade || null - - this.path = query ? util.buildURL(path, query) : path - - this.origin = origin - - this.idempotent = idempotent == null - ? method === 'HEAD' || method === 'GET' - : idempotent - - this.blocking = blocking == null ? false : blocking - - this.reset = reset == null ? null : reset - - this.host = null - - this.contentLength = null - - this.contentType = null - - this.headers = '' - - // Only for H2 - this.expectContinue = expectContinue != null ? expectContinue : false - - if (Array.isArray(headers)) { - if (headers.length % 2 !== 0) { - throw new InvalidArgumentError('headers array must be even') - } - for (let i = 0; i < headers.length; i += 2) { - processHeader(this, headers[i], headers[i + 1]) - } - } else if (headers && typeof headers === 'object') { - const keys = Object.keys(headers) - for (let i = 0; i < keys.length; i++) { - const key = keys[i] - processHeader(this, key, headers[key]) - } - } else if (headers != null) { - throw new InvalidArgumentError('headers must be an object or an array') - } - - if (util.isFormDataLike(this.body)) { - if (util.nodeMajor < 16 || (util.nodeMajor === 16 && util.nodeMinor < 8)) { - throw new InvalidArgumentError('Form-Data bodies are only supported in node v16.8 and newer.') - } - - if (!extractBody) { - extractBody = (__nccwpck_require__(8923).extractBody) - } - - const [bodyStream, contentType] = extractBody(body) - if (this.contentType == null) { - this.contentType = contentType - this.headers += `content-type: ${contentType}\r\n` - } - this.body = bodyStream.stream - this.contentLength = bodyStream.length - } else if (util.isBlobLike(body) && this.contentType == null && body.type) { - this.contentType = body.type - this.headers += `content-type: ${body.type}\r\n` - } - - util.validateHandler(handler, method, upgrade) - - this.servername = util.getServerName(this.host) - - this[kHandler] = handler - - if (channels.create.hasSubscribers) { - channels.create.publish({ request: this }) - } - } - - onBodySent (chunk) { - if (this[kHandler].onBodySent) { - try { - return this[kHandler].onBodySent(chunk) - } catch (err) { - this.abort(err) - } - } - } - - onRequestSent () { - if (channels.bodySent.hasSubscribers) { - channels.bodySent.publish({ request: this }) - } - - if (this[kHandler].onRequestSent) { - try { - return this[kHandler].onRequestSent() - } catch (err) { - this.abort(err) - } - } - } - - onConnect (abort) { - assert(!this.aborted) - assert(!this.completed) - - if (this.error) { - abort(this.error) - } else { - this.abort = abort - return this[kHandler].onConnect(abort) - } - } - - onHeaders (statusCode, headers, resume, statusText) { - assert(!this.aborted) - assert(!this.completed) - - if (channels.headers.hasSubscribers) { - channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }) - } - - try { - return this[kHandler].onHeaders(statusCode, headers, resume, statusText) - } catch (err) { - this.abort(err) - } - } - - onData (chunk) { - assert(!this.aborted) - assert(!this.completed) - - try { - return this[kHandler].onData(chunk) - } catch (err) { - this.abort(err) - return false - } - } - - onUpgrade (statusCode, headers, socket) { - assert(!this.aborted) - assert(!this.completed) - - return this[kHandler].onUpgrade(statusCode, headers, socket) - } - - onComplete (trailers) { - this.onFinally() - - assert(!this.aborted) - - this.completed = true - if (channels.trailers.hasSubscribers) { - channels.trailers.publish({ request: this, trailers }) - } - - try { - return this[kHandler].onComplete(trailers) - } catch (err) { - // TODO (fix): This might be a bad idea? - this.onError(err) - } - } - - onError (error) { - this.onFinally() - - if (channels.error.hasSubscribers) { - channels.error.publish({ request: this, error }) - } - - if (this.aborted) { - return - } - this.aborted = true - - return this[kHandler].onError(error) - } - - onFinally () { - if (this.errorHandler) { - this.body.off('error', this.errorHandler) - this.errorHandler = null - } - - if (this.endHandler) { - this.body.off('end', this.endHandler) - this.endHandler = null - } - } - - // TODO: adjust to support H2 - addHeader (key, value) { - processHeader(this, key, value) - return this - } - - static [kHTTP1BuildRequest] (origin, opts, handler) { - // TODO: Migrate header parsing here, to make Requests - // HTTP agnostic - return new Request(origin, opts, handler) - } - - static [kHTTP2BuildRequest] (origin, opts, handler) { - const headers = opts.headers - opts = { ...opts, headers: null } - - const request = new Request(origin, opts, handler) - - request.headers = {} - - if (Array.isArray(headers)) { - if (headers.length % 2 !== 0) { - throw new InvalidArgumentError('headers array must be even') - } - for (let i = 0; i < headers.length; i += 2) { - processHeader(request, headers[i], headers[i + 1], true) - } - } else if (headers && typeof headers === 'object') { - const keys = Object.keys(headers) - for (let i = 0; i < keys.length; i++) { - const key = keys[i] - processHeader(request, key, headers[key], true) - } - } else if (headers != null) { - throw new InvalidArgumentError('headers must be an object or an array') - } - - return request - } - - static [kHTTP2CopyHeaders] (raw) { - const rawHeaders = raw.split('\r\n') - const headers = {} - - for (const header of rawHeaders) { - const [key, value] = header.split(': ') - - if (value == null || value.length === 0) continue - - if (headers[key]) headers[key] += `,${value}` - else headers[key] = value - } - - return headers - } -} - -function processHeaderValue (key, val, skipAppend) { - if (val && typeof val === 'object') { - throw new InvalidArgumentError(`invalid ${key} header`) - } - - val = val != null ? `${val}` : '' - - if (headerCharRegex.exec(val) !== null) { - throw new InvalidArgumentError(`invalid ${key} header`) - } - - return skipAppend ? val : `${key}: ${val}\r\n` -} - -function processHeader (request, key, val, skipAppend = false) { - if (val && (typeof val === 'object' && !Array.isArray(val))) { - throw new InvalidArgumentError(`invalid ${key} header`) - } else if (val === undefined) { - return - } - - if ( - request.host === null && - key.length === 4 && - key.toLowerCase() === 'host' - ) { - if (headerCharRegex.exec(val) !== null) { - throw new InvalidArgumentError(`invalid ${key} header`) - } - // Consumed by Client - request.host = val - } else if ( - request.contentLength === null && - key.length === 14 && - key.toLowerCase() === 'content-length' - ) { - request.contentLength = parseInt(val, 10) - if (!Number.isFinite(request.contentLength)) { - throw new InvalidArgumentError('invalid content-length header') - } - } else if ( - request.contentType === null && - key.length === 12 && - key.toLowerCase() === 'content-type' - ) { - request.contentType = val - if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend) - else request.headers += processHeaderValue(key, val) - } else if ( - key.length === 17 && - key.toLowerCase() === 'transfer-encoding' - ) { - throw new InvalidArgumentError('invalid transfer-encoding header') - } else if ( - key.length === 10 && - key.toLowerCase() === 'connection' - ) { - const value = typeof val === 'string' ? val.toLowerCase() : null - if (value !== 'close' && value !== 'keep-alive') { - throw new InvalidArgumentError('invalid connection header') - } else if (value === 'close') { - request.reset = true - } - } else if ( - key.length === 10 && - key.toLowerCase() === 'keep-alive' - ) { - throw new InvalidArgumentError('invalid keep-alive header') - } else if ( - key.length === 7 && - key.toLowerCase() === 'upgrade' - ) { - throw new InvalidArgumentError('invalid upgrade header') - } else if ( - key.length === 6 && - key.toLowerCase() === 'expect' - ) { - throw new NotSupportedError('expect header not supported') - } else if (tokenRegExp.exec(key) === null) { - throw new InvalidArgumentError('invalid header key') - } else { - if (Array.isArray(val)) { - for (let i = 0; i < val.length; i++) { - if (skipAppend) { - if (request.headers[key]) request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}` - else request.headers[key] = processHeaderValue(key, val[i], skipAppend) - } else { - request.headers += processHeaderValue(key, val[i]) - } - } - } else { - if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend) - else request.headers += processHeaderValue(key, val) - } - } -} - -module.exports = Request - - -/***/ }), - -/***/ 6443: -/***/ ((module) => { - -module.exports = { - kClose: Symbol('close'), - kDestroy: Symbol('destroy'), - kDispatch: Symbol('dispatch'), - kUrl: Symbol('url'), - kWriting: Symbol('writing'), - kResuming: Symbol('resuming'), - kQueue: Symbol('queue'), - kConnect: Symbol('connect'), - kConnecting: Symbol('connecting'), - kHeadersList: Symbol('headers list'), - kKeepAliveDefaultTimeout: Symbol('default keep alive timeout'), - kKeepAliveMaxTimeout: Symbol('max keep alive timeout'), - kKeepAliveTimeoutThreshold: Symbol('keep alive timeout threshold'), - kKeepAliveTimeoutValue: Symbol('keep alive timeout'), - kKeepAlive: Symbol('keep alive'), - kHeadersTimeout: Symbol('headers timeout'), - kBodyTimeout: Symbol('body timeout'), - kServerName: Symbol('server name'), - kLocalAddress: Symbol('local address'), - kHost: Symbol('host'), - kNoRef: Symbol('no ref'), - kBodyUsed: Symbol('used'), - kRunning: Symbol('running'), - kBlocking: Symbol('blocking'), - kPending: Symbol('pending'), - kSize: Symbol('size'), - kBusy: Symbol('busy'), - kQueued: Symbol('queued'), - kFree: Symbol('free'), - kConnected: Symbol('connected'), - kClosed: Symbol('closed'), - kNeedDrain: Symbol('need drain'), - kReset: Symbol('reset'), - kDestroyed: Symbol.for('nodejs.stream.destroyed'), - kMaxHeadersSize: Symbol('max headers size'), - kRunningIdx: Symbol('running index'), - kPendingIdx: Symbol('pending index'), - kError: Symbol('error'), - kClients: Symbol('clients'), - kClient: Symbol('client'), - kParser: Symbol('parser'), - kOnDestroyed: Symbol('destroy callbacks'), - kPipelining: Symbol('pipelining'), - kSocket: Symbol('socket'), - kHostHeader: Symbol('host header'), - kConnector: Symbol('connector'), - kStrictContentLength: Symbol('strict content length'), - kMaxRedirections: Symbol('maxRedirections'), - kMaxRequests: Symbol('maxRequestsPerClient'), - kProxy: Symbol('proxy agent options'), - kCounter: Symbol('socket request counter'), - kInterceptors: Symbol('dispatch interceptors'), - kMaxResponseSize: Symbol('max response size'), - kHTTP2Session: Symbol('http2Session'), - kHTTP2SessionState: Symbol('http2Session state'), - kHTTP2BuildRequest: Symbol('http2 build request'), - kHTTP1BuildRequest: Symbol('http1 build request'), - kHTTP2CopyHeaders: Symbol('http2 copy headers'), - kHTTPConnVersion: Symbol('http connection version'), - kRetryHandlerDefaultRetry: Symbol('retry agent default retry'), - kConstruct: Symbol('constructable') -} - - -/***/ }), - -/***/ 3440: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const assert = __nccwpck_require__(2613) -const { kDestroyed, kBodyUsed } = __nccwpck_require__(6443) -const { IncomingMessage } = __nccwpck_require__(8611) -const stream = __nccwpck_require__(2203) -const net = __nccwpck_require__(9278) -const { InvalidArgumentError } = __nccwpck_require__(8707) -const { Blob } = __nccwpck_require__(181) -const nodeUtil = __nccwpck_require__(9023) -const { stringify } = __nccwpck_require__(3480) -const { headerNameLowerCasedRecord } = __nccwpck_require__(735) - -const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v)) - -function nop () {} - -function isStream (obj) { - return obj && typeof obj === 'object' && typeof obj.pipe === 'function' && typeof obj.on === 'function' -} - -// based on https://github.com/node-fetch/fetch-blob/blob/8ab587d34080de94140b54f07168451e7d0b655e/index.js#L229-L241 (MIT License) -function isBlobLike (object) { - return (Blob && object instanceof Blob) || ( - object && - typeof object === 'object' && - (typeof object.stream === 'function' || - typeof object.arrayBuffer === 'function') && - /^(Blob|File)$/.test(object[Symbol.toStringTag]) - ) -} - -function buildURL (url, queryParams) { - if (url.includes('?') || url.includes('#')) { - throw new Error('Query params cannot be passed when url already contains "?" or "#".') - } - - const stringified = stringify(queryParams) - - if (stringified) { - url += '?' + stringified - } - - return url -} - -function parseURL (url) { - if (typeof url === 'string') { - url = new URL(url) - - if (!/^https?:/.test(url.origin || url.protocol)) { - throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.') - } - - return url - } - - if (!url || typeof url !== 'object') { - throw new InvalidArgumentError('Invalid URL: The URL argument must be a non-null object.') - } - - if (!/^https?:/.test(url.origin || url.protocol)) { - throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.') - } - - if (!(url instanceof URL)) { - if (url.port != null && url.port !== '' && !Number.isFinite(parseInt(url.port))) { - throw new InvalidArgumentError('Invalid URL: port must be a valid integer or a string representation of an integer.') - } - - if (url.path != null && typeof url.path !== 'string') { - throw new InvalidArgumentError('Invalid URL path: the path must be a string or null/undefined.') - } - - if (url.pathname != null && typeof url.pathname !== 'string') { - throw new InvalidArgumentError('Invalid URL pathname: the pathname must be a string or null/undefined.') - } - - if (url.hostname != null && typeof url.hostname !== 'string') { - throw new InvalidArgumentError('Invalid URL hostname: the hostname must be a string or null/undefined.') - } - - if (url.origin != null && typeof url.origin !== 'string') { - throw new InvalidArgumentError('Invalid URL origin: the origin must be a string or null/undefined.') - } - - const port = url.port != null - ? url.port - : (url.protocol === 'https:' ? 443 : 80) - let origin = url.origin != null - ? url.origin - : `${url.protocol}//${url.hostname}:${port}` - let path = url.path != null - ? url.path - : `${url.pathname || ''}${url.search || ''}` - - if (origin.endsWith('/')) { - origin = origin.substring(0, origin.length - 1) - } - - if (path && !path.startsWith('/')) { - path = `/${path}` - } - // new URL(path, origin) is unsafe when `path` contains an absolute URL - // From https://developer.mozilla.org/en-US/docs/Web/API/URL/URL: - // If first parameter is a relative URL, second param is required, and will be used as the base URL. - // If first parameter is an absolute URL, a given second param will be ignored. - url = new URL(origin + path) - } - - return url -} - -function parseOrigin (url) { - url = parseURL(url) - - if (url.pathname !== '/' || url.search || url.hash) { - throw new InvalidArgumentError('invalid url') - } - - return url -} - -function getHostname (host) { - if (host[0] === '[') { - const idx = host.indexOf(']') - - assert(idx !== -1) - return host.substring(1, idx) - } - - const idx = host.indexOf(':') - if (idx === -1) return host - - return host.substring(0, idx) -} - -// IP addresses are not valid server names per RFC6066 -// > Currently, the only server names supported are DNS hostnames -function getServerName (host) { - if (!host) { - return null - } - - assert.strictEqual(typeof host, 'string') - - const servername = getHostname(host) - if (net.isIP(servername)) { - return '' - } - - return servername -} - -function deepClone (obj) { - return JSON.parse(JSON.stringify(obj)) -} - -function isAsyncIterable (obj) { - return !!(obj != null && typeof obj[Symbol.asyncIterator] === 'function') -} - -function isIterable (obj) { - return !!(obj != null && (typeof obj[Symbol.iterator] === 'function' || typeof obj[Symbol.asyncIterator] === 'function')) -} - -function bodyLength (body) { - if (body == null) { - return 0 - } else if (isStream(body)) { - const state = body._readableState - return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) - ? state.length - : null - } else if (isBlobLike(body)) { - return body.size != null ? body.size : null - } else if (isBuffer(body)) { - return body.byteLength - } - - return null -} - -function isDestroyed (stream) { - return !stream || !!(stream.destroyed || stream[kDestroyed]) -} - -function isReadableAborted (stream) { - const state = stream && stream._readableState - return isDestroyed(stream) && state && !state.endEmitted -} - -function destroy (stream, err) { - if (stream == null || !isStream(stream) || isDestroyed(stream)) { - return - } - - if (typeof stream.destroy === 'function') { - if (Object.getPrototypeOf(stream).constructor === IncomingMessage) { - // See: https://github.com/nodejs/node/pull/38505/files - stream.socket = null - } - - stream.destroy(err) - } else if (err) { - process.nextTick((stream, err) => { - stream.emit('error', err) - }, stream, err) - } - - if (stream.destroyed !== true) { - stream[kDestroyed] = true - } -} - -const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/ -function parseKeepAliveTimeout (val) { - const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR) - return m ? parseInt(m[1], 10) * 1000 : null -} - -/** - * Retrieves a header name and returns its lowercase value. - * @param {string | Buffer} value Header name - * @returns {string} - */ -function headerNameToString (value) { - return headerNameLowerCasedRecord[value] || value.toLowerCase() -} - -function parseHeaders (headers, obj = {}) { - // For H2 support - if (!Array.isArray(headers)) return headers - - for (let i = 0; i < headers.length; i += 2) { - const key = headers[i].toString().toLowerCase() - let val = obj[key] - - if (!val) { - if (Array.isArray(headers[i + 1])) { - obj[key] = headers[i + 1].map(x => x.toString('utf8')) - } else { - obj[key] = headers[i + 1].toString('utf8') - } - } else { - if (!Array.isArray(val)) { - val = [val] - obj[key] = val - } - val.push(headers[i + 1].toString('utf8')) - } - } - - // See https://github.com/nodejs/node/pull/46528 - if ('content-length' in obj && 'content-disposition' in obj) { - obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1') - } - - return obj -} - -function parseRawHeaders (headers) { - const ret = [] - let hasContentLength = false - let contentDispositionIdx = -1 - - for (let n = 0; n < headers.length; n += 2) { - const key = headers[n + 0].toString() - const val = headers[n + 1].toString('utf8') - - if (key.length === 14 && (key === 'content-length' || key.toLowerCase() === 'content-length')) { - ret.push(key, val) - hasContentLength = true - } else if (key.length === 19 && (key === 'content-disposition' || key.toLowerCase() === 'content-disposition')) { - contentDispositionIdx = ret.push(key, val) - 1 - } else { - ret.push(key, val) - } - } - - // See https://github.com/nodejs/node/pull/46528 - if (hasContentLength && contentDispositionIdx !== -1) { - ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString('latin1') - } - - return ret -} - -function isBuffer (buffer) { - // See, https://github.com/mcollina/undici/pull/319 - return buffer instanceof Uint8Array || Buffer.isBuffer(buffer) -} - -function validateHandler (handler, method, upgrade) { - if (!handler || typeof handler !== 'object') { - throw new InvalidArgumentError('handler must be an object') - } - - if (typeof handler.onConnect !== 'function') { - throw new InvalidArgumentError('invalid onConnect method') - } - - if (typeof handler.onError !== 'function') { - throw new InvalidArgumentError('invalid onError method') - } - - if (typeof handler.onBodySent !== 'function' && handler.onBodySent !== undefined) { - throw new InvalidArgumentError('invalid onBodySent method') - } - - if (upgrade || method === 'CONNECT') { - if (typeof handler.onUpgrade !== 'function') { - throw new InvalidArgumentError('invalid onUpgrade method') - } - } else { - if (typeof handler.onHeaders !== 'function') { - throw new InvalidArgumentError('invalid onHeaders method') - } - - if (typeof handler.onData !== 'function') { - throw new InvalidArgumentError('invalid onData method') - } - - if (typeof handler.onComplete !== 'function') { - throw new InvalidArgumentError('invalid onComplete method') - } - } -} - -// A body is disturbed if it has been read from and it cannot -// be re-used without losing state or data. -function isDisturbed (body) { - return !!(body && ( - stream.isDisturbed - ? stream.isDisturbed(body) || body[kBodyUsed] // TODO (fix): Why is body[kBodyUsed] needed? - : body[kBodyUsed] || - body.readableDidRead || - (body._readableState && body._readableState.dataEmitted) || - isReadableAborted(body) - )) -} - -function isErrored (body) { - return !!(body && ( - stream.isErrored - ? stream.isErrored(body) - : /state: 'errored'/.test(nodeUtil.inspect(body) - ))) -} - -function isReadable (body) { - return !!(body && ( - stream.isReadable - ? stream.isReadable(body) - : /state: 'readable'/.test(nodeUtil.inspect(body) - ))) -} - -function getSocketInfo (socket) { - return { - localAddress: socket.localAddress, - localPort: socket.localPort, - remoteAddress: socket.remoteAddress, - remotePort: socket.remotePort, - remoteFamily: socket.remoteFamily, - timeout: socket.timeout, - bytesWritten: socket.bytesWritten, - bytesRead: socket.bytesRead - } -} - -async function * convertIterableToBuffer (iterable) { - for await (const chunk of iterable) { - yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk) - } -} - -let ReadableStream -function ReadableStreamFrom (iterable) { - if (!ReadableStream) { - ReadableStream = (__nccwpck_require__(3774).ReadableStream) - } - - if (ReadableStream.from) { - return ReadableStream.from(convertIterableToBuffer(iterable)) - } - - let iterator - return new ReadableStream( - { - async start () { - iterator = iterable[Symbol.asyncIterator]() - }, - async pull (controller) { - const { done, value } = await iterator.next() - if (done) { - queueMicrotask(() => { - controller.close() - }) - } else { - const buf = Buffer.isBuffer(value) ? value : Buffer.from(value) - controller.enqueue(new Uint8Array(buf)) - } - return controller.desiredSize > 0 - }, - async cancel (reason) { - await iterator.return() - } - }, - 0 - ) -} - -// The chunk should be a FormData instance and contains -// all the required methods. -function isFormDataLike (object) { - return ( - object && - typeof object === 'object' && - typeof object.append === 'function' && - typeof object.delete === 'function' && - typeof object.get === 'function' && - typeof object.getAll === 'function' && - typeof object.has === 'function' && - typeof object.set === 'function' && - object[Symbol.toStringTag] === 'FormData' - ) -} - -function throwIfAborted (signal) { - if (!signal) { return } - if (typeof signal.throwIfAborted === 'function') { - signal.throwIfAborted() - } else { - if (signal.aborted) { - // DOMException not available < v17.0.0 - const err = new Error('The operation was aborted') - err.name = 'AbortError' - throw err - } - } -} - -function addAbortListener (signal, listener) { - if ('addEventListener' in signal) { - signal.addEventListener('abort', listener, { once: true }) - return () => signal.removeEventListener('abort', listener) - } - signal.addListener('abort', listener) - return () => signal.removeListener('abort', listener) -} - -const hasToWellFormed = !!String.prototype.toWellFormed - -/** - * @param {string} val - */ -function toUSVString (val) { - if (hasToWellFormed) { - return `${val}`.toWellFormed() - } else if (nodeUtil.toUSVString) { - return nodeUtil.toUSVString(val) - } - - return `${val}` -} - -// Parsed accordingly to RFC 9110 -// https://www.rfc-editor.org/rfc/rfc9110#field.content-range -function parseRangeHeader (range) { - if (range == null || range === '') return { start: 0, end: null, size: null } - - const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null - return m - ? { - start: parseInt(m[1]), - end: m[2] ? parseInt(m[2]) : null, - size: m[3] ? parseInt(m[3]) : null - } - : null -} - -const kEnumerableProperty = Object.create(null) -kEnumerableProperty.enumerable = true - -module.exports = { - kEnumerableProperty, - nop, - isDisturbed, - isErrored, - isReadable, - toUSVString, - isReadableAborted, - isBlobLike, - parseOrigin, - parseURL, - getServerName, - isStream, - isIterable, - isAsyncIterable, - isDestroyed, - headerNameToString, - parseRawHeaders, - parseHeaders, - parseKeepAliveTimeout, - destroy, - bodyLength, - deepClone, - ReadableStreamFrom, - isBuffer, - validateHandler, - getSocketInfo, - isFormDataLike, - buildURL, - throwIfAborted, - addAbortListener, - parseRangeHeader, - nodeMajor, - nodeMinor, - nodeHasAutoSelectFamily: nodeMajor > 18 || (nodeMajor === 18 && nodeMinor >= 13), - safeHTTPMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'] -} - - -/***/ }), - -/***/ 1: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const Dispatcher = __nccwpck_require__(992) -const { - ClientDestroyedError, - ClientClosedError, - InvalidArgumentError -} = __nccwpck_require__(8707) -const { kDestroy, kClose, kDispatch, kInterceptors } = __nccwpck_require__(6443) - -const kDestroyed = Symbol('destroyed') -const kClosed = Symbol('closed') -const kOnDestroyed = Symbol('onDestroyed') -const kOnClosed = Symbol('onClosed') -const kInterceptedDispatch = Symbol('Intercepted Dispatch') - -class DispatcherBase extends Dispatcher { - constructor () { - super() - - this[kDestroyed] = false - this[kOnDestroyed] = null - this[kClosed] = false - this[kOnClosed] = [] - } - - get destroyed () { - return this[kDestroyed] - } - - get closed () { - return this[kClosed] - } - - get interceptors () { - return this[kInterceptors] - } - - set interceptors (newInterceptors) { - if (newInterceptors) { - for (let i = newInterceptors.length - 1; i >= 0; i--) { - const interceptor = this[kInterceptors][i] - if (typeof interceptor !== 'function') { - throw new InvalidArgumentError('interceptor must be an function') - } - } - } - - this[kInterceptors] = newInterceptors - } - - close (callback) { - if (callback === undefined) { - return new Promise((resolve, reject) => { - this.close((err, data) => { - return err ? reject(err) : resolve(data) - }) - }) - } - - if (typeof callback !== 'function') { - throw new InvalidArgumentError('invalid callback') - } - - if (this[kDestroyed]) { - queueMicrotask(() => callback(new ClientDestroyedError(), null)) - return - } - - if (this[kClosed]) { - if (this[kOnClosed]) { - this[kOnClosed].push(callback) - } else { - queueMicrotask(() => callback(null, null)) - } - return - } - - this[kClosed] = true - this[kOnClosed].push(callback) - - const onClosed = () => { - const callbacks = this[kOnClosed] - this[kOnClosed] = null - for (let i = 0; i < callbacks.length; i++) { - callbacks[i](null, null) - } - } - - // Should not error. - this[kClose]() - .then(() => this.destroy()) - .then(() => { - queueMicrotask(onClosed) - }) - } - - destroy (err, callback) { - if (typeof err === 'function') { - callback = err - err = null - } - - if (callback === undefined) { - return new Promise((resolve, reject) => { - this.destroy(err, (err, data) => { - return err ? /* istanbul ignore next: should never error */ reject(err) : resolve(data) - }) - }) - } - - if (typeof callback !== 'function') { - throw new InvalidArgumentError('invalid callback') - } - - if (this[kDestroyed]) { - if (this[kOnDestroyed]) { - this[kOnDestroyed].push(callback) - } else { - queueMicrotask(() => callback(null, null)) - } - return - } - - if (!err) { - err = new ClientDestroyedError() - } - - this[kDestroyed] = true - this[kOnDestroyed] = this[kOnDestroyed] || [] - this[kOnDestroyed].push(callback) - - const onDestroyed = () => { - const callbacks = this[kOnDestroyed] - this[kOnDestroyed] = null - for (let i = 0; i < callbacks.length; i++) { - callbacks[i](null, null) - } - } - - // Should not error. - this[kDestroy](err).then(() => { - queueMicrotask(onDestroyed) - }) - } - - [kInterceptedDispatch] (opts, handler) { - if (!this[kInterceptors] || this[kInterceptors].length === 0) { - this[kInterceptedDispatch] = this[kDispatch] - return this[kDispatch](opts, handler) - } - - let dispatch = this[kDispatch].bind(this) - for (let i = this[kInterceptors].length - 1; i >= 0; i--) { - dispatch = this[kInterceptors][i](dispatch) - } - this[kInterceptedDispatch] = dispatch - return dispatch(opts, handler) - } - - dispatch (opts, handler) { - if (!handler || typeof handler !== 'object') { - throw new InvalidArgumentError('handler must be an object') - } - - try { - if (!opts || typeof opts !== 'object') { - throw new InvalidArgumentError('opts must be an object.') - } - - if (this[kDestroyed] || this[kOnDestroyed]) { - throw new ClientDestroyedError() - } - - if (this[kClosed]) { - throw new ClientClosedError() - } - - return this[kInterceptedDispatch](opts, handler) - } catch (err) { - if (typeof handler.onError !== 'function') { - throw new InvalidArgumentError('invalid onError method') - } - - handler.onError(err) - - return false - } - } -} - -module.exports = DispatcherBase - - -/***/ }), - -/***/ 992: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const EventEmitter = __nccwpck_require__(4434) - -class Dispatcher extends EventEmitter { - dispatch () { - throw new Error('not implemented') - } - - close () { - throw new Error('not implemented') - } - - destroy () { - throw new Error('not implemented') - } -} - -module.exports = Dispatcher - - -/***/ }), - -/***/ 8923: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const Busboy = __nccwpck_require__(9581) -const util = __nccwpck_require__(3440) -const { - ReadableStreamFrom, - isBlobLike, - isReadableStreamLike, - readableStreamClose, - createDeferredPromise, - fullyReadBody -} = __nccwpck_require__(5523) -const { FormData } = __nccwpck_require__(3073) -const { kState } = __nccwpck_require__(9710) -const { webidl } = __nccwpck_require__(4222) -const { DOMException, structuredClone } = __nccwpck_require__(7326) -const { Blob, File: NativeFile } = __nccwpck_require__(181) -const { kBodyUsed } = __nccwpck_require__(6443) -const assert = __nccwpck_require__(2613) -const { isErrored } = __nccwpck_require__(3440) -const { isUint8Array, isArrayBuffer } = __nccwpck_require__(8253) -const { File: UndiciFile } = __nccwpck_require__(3041) -const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(4322) - -let random -try { - const crypto = __nccwpck_require__(7598) - random = (max) => crypto.randomInt(0, max) -} catch { - random = (max) => Math.floor(Math.random(max)) -} - -let ReadableStream = globalThis.ReadableStream - -/** @type {globalThis['File']} */ -const File = NativeFile ?? UndiciFile -const textEncoder = new TextEncoder() -const textDecoder = new TextDecoder() - -// https://fetch.spec.whatwg.org/#concept-bodyinit-extract -function extractBody (object, keepalive = false) { - if (!ReadableStream) { - ReadableStream = (__nccwpck_require__(3774).ReadableStream) - } - - // 1. Let stream be null. - let stream = null - - // 2. If object is a ReadableStream object, then set stream to object. - if (object instanceof ReadableStream) { - stream = object - } else if (isBlobLike(object)) { - // 3. Otherwise, if object is a Blob object, set stream to the - // result of running object’s get stream. - stream = object.stream() - } else { - // 4. Otherwise, set stream to a new ReadableStream object, and set - // up stream. - stream = new ReadableStream({ - async pull (controller) { - controller.enqueue( - typeof source === 'string' ? textEncoder.encode(source) : source - ) - queueMicrotask(() => readableStreamClose(controller)) - }, - start () {}, - type: undefined - }) - } - - // 5. Assert: stream is a ReadableStream object. - assert(isReadableStreamLike(stream)) - - // 6. Let action be null. - let action = null - - // 7. Let source be null. - let source = null - - // 8. Let length be null. - let length = null - - // 9. Let type be null. - let type = null - - // 10. Switch on object: - if (typeof object === 'string') { - // Set source to the UTF-8 encoding of object. - // Note: setting source to a Uint8Array here breaks some mocking assumptions. - source = object - - // Set type to `text/plain;charset=UTF-8`. - type = 'text/plain;charset=UTF-8' - } else if (object instanceof URLSearchParams) { - // URLSearchParams - - // spec says to run application/x-www-form-urlencoded on body.list - // this is implemented in Node.js as apart of an URLSearchParams instance toString method - // See: https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L490 - // and https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L1100 - - // Set source to the result of running the application/x-www-form-urlencoded serializer with object’s list. - source = object.toString() - - // Set type to `application/x-www-form-urlencoded;charset=UTF-8`. - type = 'application/x-www-form-urlencoded;charset=UTF-8' - } else if (isArrayBuffer(object)) { - // BufferSource/ArrayBuffer - - // Set source to a copy of the bytes held by object. - source = new Uint8Array(object.slice()) - } else if (ArrayBuffer.isView(object)) { - // BufferSource/ArrayBufferView - - // Set source to a copy of the bytes held by object. - source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)) - } else if (util.isFormDataLike(object)) { - const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}` - const prefix = `--${boundary}\r\nContent-Disposition: form-data` - - /*! formdata-polyfill. MIT License. Jimmy Wärting */ - const escape = (str) => - str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22') - const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, '\r\n') - - // Set action to this step: run the multipart/form-data - // encoding algorithm, with object’s entry list and UTF-8. - // - This ensures that the body is immutable and can't be changed afterwords - // - That the content-length is calculated in advance. - // - And that all parts are pre-encoded and ready to be sent. - - const blobParts = [] - const rn = new Uint8Array([13, 10]) // '\r\n' - length = 0 - let hasUnknownSizeValue = false - - for (const [name, value] of object) { - if (typeof value === 'string') { - const chunk = textEncoder.encode(prefix + - `; name="${escape(normalizeLinefeeds(name))}"` + - `\r\n\r\n${normalizeLinefeeds(value)}\r\n`) - blobParts.push(chunk) - length += chunk.byteLength - } else { - const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + - (value.name ? `; filename="${escape(value.name)}"` : '') + '\r\n' + - `Content-Type: ${ - value.type || 'application/octet-stream' - }\r\n\r\n`) - blobParts.push(chunk, value, rn) - if (typeof value.size === 'number') { - length += chunk.byteLength + value.size + rn.byteLength - } else { - hasUnknownSizeValue = true - } - } - } - - const chunk = textEncoder.encode(`--${boundary}--`) - blobParts.push(chunk) - length += chunk.byteLength - if (hasUnknownSizeValue) { - length = null - } - - // Set source to object. - source = object - - action = async function * () { - for (const part of blobParts) { - if (part.stream) { - yield * part.stream() - } else { - yield part - } - } - } - - // Set type to `multipart/form-data; boundary=`, - // followed by the multipart/form-data boundary string generated - // by the multipart/form-data encoding algorithm. - type = 'multipart/form-data; boundary=' + boundary - } else if (isBlobLike(object)) { - // Blob - - // Set source to object. - source = object - - // Set length to object’s size. - length = object.size - - // If object’s type attribute is not the empty byte sequence, set - // type to its value. - if (object.type) { - type = object.type - } - } else if (typeof object[Symbol.asyncIterator] === 'function') { - // If keepalive is true, then throw a TypeError. - if (keepalive) { - throw new TypeError('keepalive') - } - - // If object is disturbed or locked, then throw a TypeError. - if (util.isDisturbed(object) || object.locked) { - throw new TypeError( - 'Response body object should not be disturbed or locked' - ) - } - - stream = - object instanceof ReadableStream ? object : ReadableStreamFrom(object) - } - - // 11. If source is a byte sequence, then set action to a - // step that returns source and length to source’s length. - if (typeof source === 'string' || util.isBuffer(source)) { - length = Buffer.byteLength(source) - } - - // 12. If action is non-null, then run these steps in in parallel: - if (action != null) { - // Run action. - let iterator - stream = new ReadableStream({ - async start () { - iterator = action(object)[Symbol.asyncIterator]() - }, - async pull (controller) { - const { value, done } = await iterator.next() - if (done) { - // When running action is done, close stream. - queueMicrotask(() => { - controller.close() - }) - } else { - // Whenever one or more bytes are available and stream is not errored, - // enqueue a Uint8Array wrapping an ArrayBuffer containing the available - // bytes into stream. - if (!isErrored(stream)) { - controller.enqueue(new Uint8Array(value)) - } - } - return controller.desiredSize > 0 - }, - async cancel (reason) { - await iterator.return() - }, - type: undefined - }) - } - - // 13. Let body be a body whose stream is stream, source is source, - // and length is length. - const body = { stream, source, length } - - // 14. Return (body, type). - return [body, type] -} - -// https://fetch.spec.whatwg.org/#bodyinit-safely-extract -function safelyExtractBody (object, keepalive = false) { - if (!ReadableStream) { - // istanbul ignore next - ReadableStream = (__nccwpck_require__(3774).ReadableStream) - } - - // To safely extract a body and a `Content-Type` value from - // a byte sequence or BodyInit object object, run these steps: - - // 1. If object is a ReadableStream object, then: - if (object instanceof ReadableStream) { - // Assert: object is neither disturbed nor locked. - // istanbul ignore next - assert(!util.isDisturbed(object), 'The body has already been consumed.') - // istanbul ignore next - assert(!object.locked, 'The stream is locked.') - } - - // 2. Return the results of extracting object. - return extractBody(object, keepalive) -} - -function cloneBody (body) { - // To clone a body body, run these steps: - - // https://fetch.spec.whatwg.org/#concept-body-clone - - // 1. Let « out1, out2 » be the result of teeing body’s stream. - const [out1, out2] = body.stream.tee() - const out2Clone = structuredClone(out2, { transfer: [out2] }) - // This, for whatever reasons, unrefs out2Clone which allows - // the process to exit by itself. - const [, finalClone] = out2Clone.tee() - - // 2. Set body’s stream to out1. - body.stream = out1 - - // 3. Return a body whose stream is out2 and other members are copied from body. - return { - stream: finalClone, - length: body.length, - source: body.source - } -} - -async function * consumeBody (body) { - if (body) { - if (isUint8Array(body)) { - yield body - } else { - const stream = body.stream - - if (util.isDisturbed(stream)) { - throw new TypeError('The body has already been consumed.') - } - - if (stream.locked) { - throw new TypeError('The stream is locked.') - } - - // Compat. - stream[kBodyUsed] = true - - yield * stream - } - } -} - -function throwIfAborted (state) { - if (state.aborted) { - throw new DOMException('The operation was aborted.', 'AbortError') - } -} - -function bodyMixinMethods (instance) { - const methods = { - blob () { - // The blob() method steps are to return the result of - // running consume body with this and the following step - // given a byte sequence bytes: return a Blob whose - // contents are bytes and whose type attribute is this’s - // MIME type. - return specConsumeBody(this, (bytes) => { - let mimeType = bodyMimeType(this) - - if (mimeType === 'failure') { - mimeType = '' - } else if (mimeType) { - mimeType = serializeAMimeType(mimeType) - } - - // Return a Blob whose contents are bytes and type attribute - // is mimeType. - return new Blob([bytes], { type: mimeType }) - }, instance) - }, - - arrayBuffer () { - // The arrayBuffer() method steps are to return the result - // of running consume body with this and the following step - // given a byte sequence bytes: return a new ArrayBuffer - // whose contents are bytes. - return specConsumeBody(this, (bytes) => { - return new Uint8Array(bytes).buffer - }, instance) - }, - - text () { - // The text() method steps are to return the result of running - // consume body with this and UTF-8 decode. - return specConsumeBody(this, utf8DecodeBytes, instance) - }, - - json () { - // The json() method steps are to return the result of running - // consume body with this and parse JSON from bytes. - return specConsumeBody(this, parseJSONFromBytes, instance) - }, - - async formData () { - webidl.brandCheck(this, instance) - - throwIfAborted(this[kState]) - - const contentType = this.headers.get('Content-Type') - - // If mimeType’s essence is "multipart/form-data", then: - if (/multipart\/form-data/.test(contentType)) { - const headers = {} - for (const [key, value] of this.headers) headers[key.toLowerCase()] = value - - const responseFormData = new FormData() - - let busboy - - try { - busboy = new Busboy({ - headers, - preservePath: true - }) - } catch (err) { - throw new DOMException(`${err}`, 'AbortError') - } - - busboy.on('field', (name, value) => { - responseFormData.append(name, value) - }) - busboy.on('file', (name, value, filename, encoding, mimeType) => { - const chunks = [] - - if (encoding === 'base64' || encoding.toLowerCase() === 'base64') { - let base64chunk = '' - - value.on('data', (chunk) => { - base64chunk += chunk.toString().replace(/[\r\n]/gm, '') - - const end = base64chunk.length - base64chunk.length % 4 - chunks.push(Buffer.from(base64chunk.slice(0, end), 'base64')) - - base64chunk = base64chunk.slice(end) - }) - value.on('end', () => { - chunks.push(Buffer.from(base64chunk, 'base64')) - responseFormData.append(name, new File(chunks, filename, { type: mimeType })) - }) - } else { - value.on('data', (chunk) => { - chunks.push(chunk) - }) - value.on('end', () => { - responseFormData.append(name, new File(chunks, filename, { type: mimeType })) - }) - } - }) - - const busboyResolve = new Promise((resolve, reject) => { - busboy.on('finish', resolve) - busboy.on('error', (err) => reject(new TypeError(err))) - }) - - if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk) - busboy.end() - await busboyResolve - - return responseFormData - } else if (/application\/x-www-form-urlencoded/.test(contentType)) { - // Otherwise, if mimeType’s essence is "application/x-www-form-urlencoded", then: - - // 1. Let entries be the result of parsing bytes. - let entries - try { - let text = '' - // application/x-www-form-urlencoded parser will keep the BOM. - // https://url.spec.whatwg.org/#concept-urlencoded-parser - // Note that streaming decoder is stateful and cannot be reused - const streamingDecoder = new TextDecoder('utf-8', { ignoreBOM: true }) - - for await (const chunk of consumeBody(this[kState].body)) { - if (!isUint8Array(chunk)) { - throw new TypeError('Expected Uint8Array chunk') - } - text += streamingDecoder.decode(chunk, { stream: true }) - } - text += streamingDecoder.decode() - entries = new URLSearchParams(text) - } catch (err) { - // istanbul ignore next: Unclear when new URLSearchParams can fail on a string. - // 2. If entries is failure, then throw a TypeError. - throw Object.assign(new TypeError(), { cause: err }) - } - - // 3. Return a new FormData object whose entries are entries. - const formData = new FormData() - for (const [name, value] of entries) { - formData.append(name, value) - } - return formData - } else { - // Wait a tick before checking if the request has been aborted. - // Otherwise, a TypeError can be thrown when an AbortError should. - await Promise.resolve() - - throwIfAborted(this[kState]) - - // Otherwise, throw a TypeError. - throw webidl.errors.exception({ - header: `${instance.name}.formData`, - message: 'Could not parse content as FormData.' - }) - } - } - } - - return methods -} - -function mixinBody (prototype) { - Object.assign(prototype.prototype, bodyMixinMethods(prototype)) -} - -/** - * @see https://fetch.spec.whatwg.org/#concept-body-consume-body - * @param {Response|Request} object - * @param {(value: unknown) => unknown} convertBytesToJSValue - * @param {Response|Request} instance - */ -async function specConsumeBody (object, convertBytesToJSValue, instance) { - webidl.brandCheck(object, instance) - - throwIfAborted(object[kState]) - - // 1. If object is unusable, then return a promise rejected - // with a TypeError. - if (bodyUnusable(object[kState].body)) { - throw new TypeError('Body is unusable') - } - - // 2. Let promise be a new promise. - const promise = createDeferredPromise() - - // 3. Let errorSteps given error be to reject promise with error. - const errorSteps = (error) => promise.reject(error) - - // 4. Let successSteps given a byte sequence data be to resolve - // promise with the result of running convertBytesToJSValue - // with data. If that threw an exception, then run errorSteps - // with that exception. - const successSteps = (data) => { - try { - promise.resolve(convertBytesToJSValue(data)) - } catch (e) { - errorSteps(e) - } - } - - // 5. If object’s body is null, then run successSteps with an - // empty byte sequence. - if (object[kState].body == null) { - successSteps(new Uint8Array()) - return promise.promise - } - - // 6. Otherwise, fully read object’s body given successSteps, - // errorSteps, and object’s relevant global object. - await fullyReadBody(object[kState].body, successSteps, errorSteps) - - // 7. Return promise. - return promise.promise -} - -// https://fetch.spec.whatwg.org/#body-unusable -function bodyUnusable (body) { - // An object including the Body interface mixin is - // said to be unusable if its body is non-null and - // its body’s stream is disturbed or locked. - return body != null && (body.stream.locked || util.isDisturbed(body.stream)) -} - -/** - * @see https://encoding.spec.whatwg.org/#utf-8-decode - * @param {Buffer} buffer - */ -function utf8DecodeBytes (buffer) { - if (buffer.length === 0) { - return '' - } - - // 1. Let buffer be the result of peeking three bytes from - // ioQueue, converted to a byte sequence. - - // 2. If buffer is 0xEF 0xBB 0xBF, then read three - // bytes from ioQueue. (Do nothing with those bytes.) - if (buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { - buffer = buffer.subarray(3) - } - - // 3. Process a queue with an instance of UTF-8’s - // decoder, ioQueue, output, and "replacement". - const output = textDecoder.decode(buffer) - - // 4. Return output. - return output -} - -/** - * @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value - * @param {Uint8Array} bytes - */ -function parseJSONFromBytes (bytes) { - return JSON.parse(utf8DecodeBytes(bytes)) -} - -/** - * @see https://fetch.spec.whatwg.org/#concept-body-mime-type - * @param {import('./response').Response|import('./request').Request} object - */ -function bodyMimeType (object) { - const { headersList } = object[kState] - const contentType = headersList.get('content-type') - - if (contentType === null) { - return 'failure' - } - - return parseMIMEType(contentType) -} - -module.exports = { - extractBody, - safelyExtractBody, - cloneBody, - mixinBody -} - - -/***/ }), - -/***/ 7326: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { MessageChannel, receiveMessageOnPort } = __nccwpck_require__(8167) - -const corsSafeListedMethods = ['GET', 'HEAD', 'POST'] -const corsSafeListedMethodsSet = new Set(corsSafeListedMethods) - -const nullBodyStatus = [101, 204, 205, 304] - -const redirectStatus = [301, 302, 303, 307, 308] -const redirectStatusSet = new Set(redirectStatus) - -// https://fetch.spec.whatwg.org/#block-bad-port -const badPorts = [ - '1', '7', '9', '11', '13', '15', '17', '19', '20', '21', '22', '23', '25', '37', '42', '43', '53', '69', '77', '79', - '87', '95', '101', '102', '103', '104', '109', '110', '111', '113', '115', '117', '119', '123', '135', '137', - '139', '143', '161', '179', '389', '427', '465', '512', '513', '514', '515', '526', '530', '531', '532', - '540', '548', '554', '556', '563', '587', '601', '636', '989', '990', '993', '995', '1719', '1720', '1723', - '2049', '3659', '4045', '5060', '5061', '6000', '6566', '6665', '6666', '6667', '6668', '6669', '6697', - '10080' -] - -const badPortsSet = new Set(badPorts) - -// https://w3c.github.io/webappsec-referrer-policy/#referrer-policies -const referrerPolicy = [ - '', - 'no-referrer', - 'no-referrer-when-downgrade', - 'same-origin', - 'origin', - 'strict-origin', - 'origin-when-cross-origin', - 'strict-origin-when-cross-origin', - 'unsafe-url' -] -const referrerPolicySet = new Set(referrerPolicy) - -const requestRedirect = ['follow', 'manual', 'error'] - -const safeMethods = ['GET', 'HEAD', 'OPTIONS', 'TRACE'] -const safeMethodsSet = new Set(safeMethods) - -const requestMode = ['navigate', 'same-origin', 'no-cors', 'cors'] - -const requestCredentials = ['omit', 'same-origin', 'include'] - -const requestCache = [ - 'default', - 'no-store', - 'reload', - 'no-cache', - 'force-cache', - 'only-if-cached' -] - -// https://fetch.spec.whatwg.org/#request-body-header-name -const requestBodyHeader = [ - 'content-encoding', - 'content-language', - 'content-location', - 'content-type', - // See https://github.com/nodejs/undici/issues/2021 - // 'Content-Length' is a forbidden header name, which is typically - // removed in the Headers implementation. However, undici doesn't - // filter out headers, so we add it here. - 'content-length' -] - -// https://fetch.spec.whatwg.org/#enumdef-requestduplex -const requestDuplex = [ - 'half' -] - -// http://fetch.spec.whatwg.org/#forbidden-method -const forbiddenMethods = ['CONNECT', 'TRACE', 'TRACK'] -const forbiddenMethodsSet = new Set(forbiddenMethods) - -const subresource = [ - 'audio', - 'audioworklet', - 'font', - 'image', - 'manifest', - 'paintworklet', - 'script', - 'style', - 'track', - 'video', - 'xslt', - '' -] -const subresourceSet = new Set(subresource) - -/** @type {globalThis['DOMException']} */ -const DOMException = globalThis.DOMException ?? (() => { - // DOMException was only made a global in Node v17.0.0, - // but fetch supports >= v16.8. - try { - atob('~') - } catch (err) { - return Object.getPrototypeOf(err).constructor - } -})() - -let channel - -/** @type {globalThis['structuredClone']} */ -const structuredClone = - globalThis.structuredClone ?? - // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js - // structuredClone was added in v17.0.0, but fetch supports v16.8 - function structuredClone (value, options = undefined) { - if (arguments.length === 0) { - throw new TypeError('missing argument') - } - - if (!channel) { - channel = new MessageChannel() - } - channel.port1.unref() - channel.port2.unref() - channel.port1.postMessage(value, options?.transfer) - return receiveMessageOnPort(channel.port2).message - } - -module.exports = { - DOMException, - structuredClone, - subresource, - forbiddenMethods, - requestBodyHeader, - referrerPolicy, - requestRedirect, - requestMode, - requestCredentials, - requestCache, - redirectStatus, - corsSafeListedMethods, - nullBodyStatus, - safeMethods, - badPorts, - requestDuplex, - subresourceSet, - badPortsSet, - redirectStatusSet, - corsSafeListedMethodsSet, - safeMethodsSet, - forbiddenMethodsSet, - referrerPolicySet -} - - -/***/ }), - -/***/ 4322: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -const assert = __nccwpck_require__(2613) -const { atob } = __nccwpck_require__(181) -const { isomorphicDecode } = __nccwpck_require__(5523) - -const encoder = new TextEncoder() - -/** - * @see https://mimesniff.spec.whatwg.org/#http-token-code-point - */ -const HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/ -const HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/ // eslint-disable-line -/** - * @see https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point - */ -const HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/ // eslint-disable-line - -// https://fetch.spec.whatwg.org/#data-url-processor -/** @param {URL} dataURL */ -function dataURLProcessor (dataURL) { - // 1. Assert: dataURL’s scheme is "data". - assert(dataURL.protocol === 'data:') - - // 2. Let input be the result of running the URL - // serializer on dataURL with exclude fragment - // set to true. - let input = URLSerializer(dataURL, true) - - // 3. Remove the leading "data:" string from input. - input = input.slice(5) - - // 4. Let position point at the start of input. - const position = { position: 0 } - - // 5. Let mimeType be the result of collecting a - // sequence of code points that are not equal - // to U+002C (,), given position. - let mimeType = collectASequenceOfCodePointsFast( - ',', - input, - position - ) - - // 6. Strip leading and trailing ASCII whitespace - // from mimeType. - // Undici implementation note: we need to store the - // length because if the mimetype has spaces removed, - // the wrong amount will be sliced from the input in - // step #9 - const mimeTypeLength = mimeType.length - mimeType = removeASCIIWhitespace(mimeType, true, true) - - // 7. If position is past the end of input, then - // return failure - if (position.position >= input.length) { - return 'failure' - } - - // 8. Advance position by 1. - position.position++ - - // 9. Let encodedBody be the remainder of input. - const encodedBody = input.slice(mimeTypeLength + 1) - - // 10. Let body be the percent-decoding of encodedBody. - let body = stringPercentDecode(encodedBody) - - // 11. If mimeType ends with U+003B (;), followed by - // zero or more U+0020 SPACE, followed by an ASCII - // case-insensitive match for "base64", then: - if (/;(\u0020){0,}base64$/i.test(mimeType)) { - // 1. Let stringBody be the isomorphic decode of body. - const stringBody = isomorphicDecode(body) - - // 2. Set body to the forgiving-base64 decode of - // stringBody. - body = forgivingBase64(stringBody) - - // 3. If body is failure, then return failure. - if (body === 'failure') { - return 'failure' - } - - // 4. Remove the last 6 code points from mimeType. - mimeType = mimeType.slice(0, -6) - - // 5. Remove trailing U+0020 SPACE code points from mimeType, - // if any. - mimeType = mimeType.replace(/(\u0020)+$/, '') - - // 6. Remove the last U+003B (;) code point from mimeType. - mimeType = mimeType.slice(0, -1) - } - - // 12. If mimeType starts with U+003B (;), then prepend - // "text/plain" to mimeType. - if (mimeType.startsWith(';')) { - mimeType = 'text/plain' + mimeType - } - - // 13. Let mimeTypeRecord be the result of parsing - // mimeType. - let mimeTypeRecord = parseMIMEType(mimeType) - - // 14. If mimeTypeRecord is failure, then set - // mimeTypeRecord to text/plain;charset=US-ASCII. - if (mimeTypeRecord === 'failure') { - mimeTypeRecord = parseMIMEType('text/plain;charset=US-ASCII') - } - - // 15. Return a new data: URL struct whose MIME - // type is mimeTypeRecord and body is body. - // https://fetch.spec.whatwg.org/#data-url-struct - return { mimeType: mimeTypeRecord, body } -} - -// https://url.spec.whatwg.org/#concept-url-serializer -/** - * @param {URL} url - * @param {boolean} excludeFragment - */ -function URLSerializer (url, excludeFragment = false) { - if (!excludeFragment) { - return url.href - } - - const href = url.href - const hashLength = url.hash.length - - return hashLength === 0 ? href : href.substring(0, href.length - hashLength) -} - -// https://infra.spec.whatwg.org/#collect-a-sequence-of-code-points -/** - * @param {(char: string) => boolean} condition - * @param {string} input - * @param {{ position: number }} position - */ -function collectASequenceOfCodePoints (condition, input, position) { - // 1. Let result be the empty string. - let result = '' - - // 2. While position doesn’t point past the end of input and the - // code point at position within input meets the condition condition: - while (position.position < input.length && condition(input[position.position])) { - // 1. Append that code point to the end of result. - result += input[position.position] - - // 2. Advance position by 1. - position.position++ - } - - // 3. Return result. - return result -} - -/** - * A faster collectASequenceOfCodePoints that only works when comparing a single character. - * @param {string} char - * @param {string} input - * @param {{ position: number }} position - */ -function collectASequenceOfCodePointsFast (char, input, position) { - const idx = input.indexOf(char, position.position) - const start = position.position - - if (idx === -1) { - position.position = input.length - return input.slice(start) - } - - position.position = idx - return input.slice(start, position.position) -} - -// https://url.spec.whatwg.org/#string-percent-decode -/** @param {string} input */ -function stringPercentDecode (input) { - // 1. Let bytes be the UTF-8 encoding of input. - const bytes = encoder.encode(input) - - // 2. Return the percent-decoding of bytes. - return percentDecode(bytes) -} - -// https://url.spec.whatwg.org/#percent-decode -/** @param {Uint8Array} input */ -function percentDecode (input) { - // 1. Let output be an empty byte sequence. - /** @type {number[]} */ - const output = [] - - // 2. For each byte byte in input: - for (let i = 0; i < input.length; i++) { - const byte = input[i] - - // 1. If byte is not 0x25 (%), then append byte to output. - if (byte !== 0x25) { - output.push(byte) - - // 2. Otherwise, if byte is 0x25 (%) and the next two bytes - // after byte in input are not in the ranges - // 0x30 (0) to 0x39 (9), 0x41 (A) to 0x46 (F), - // and 0x61 (a) to 0x66 (f), all inclusive, append byte - // to output. - } else if ( - byte === 0x25 && - !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2])) - ) { - output.push(0x25) - - // 3. Otherwise: - } else { - // 1. Let bytePoint be the two bytes after byte in input, - // decoded, and then interpreted as hexadecimal number. - const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]) - const bytePoint = Number.parseInt(nextTwoBytes, 16) - - // 2. Append a byte whose value is bytePoint to output. - output.push(bytePoint) - - // 3. Skip the next two bytes in input. - i += 2 - } - } - - // 3. Return output. - return Uint8Array.from(output) -} - -// https://mimesniff.spec.whatwg.org/#parse-a-mime-type -/** @param {string} input */ -function parseMIMEType (input) { - // 1. Remove any leading and trailing HTTP whitespace - // from input. - input = removeHTTPWhitespace(input, true, true) - - // 2. Let position be a position variable for input, - // initially pointing at the start of input. - const position = { position: 0 } - - // 3. Let type be the result of collecting a sequence - // of code points that are not U+002F (/) from - // input, given position. - const type = collectASequenceOfCodePointsFast( - '/', - input, - position - ) - - // 4. If type is the empty string or does not solely - // contain HTTP token code points, then return failure. - // https://mimesniff.spec.whatwg.org/#http-token-code-point - if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) { - return 'failure' - } - - // 5. If position is past the end of input, then return - // failure - if (position.position > input.length) { - return 'failure' - } - - // 6. Advance position by 1. (This skips past U+002F (/).) - position.position++ - - // 7. Let subtype be the result of collecting a sequence of - // code points that are not U+003B (;) from input, given - // position. - let subtype = collectASequenceOfCodePointsFast( - ';', - input, - position - ) - - // 8. Remove any trailing HTTP whitespace from subtype. - subtype = removeHTTPWhitespace(subtype, false, true) - - // 9. If subtype is the empty string or does not solely - // contain HTTP token code points, then return failure. - if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) { - return 'failure' - } - - const typeLowercase = type.toLowerCase() - const subtypeLowercase = subtype.toLowerCase() - - // 10. Let mimeType be a new MIME type record whose type - // is type, in ASCII lowercase, and subtype is subtype, - // in ASCII lowercase. - // https://mimesniff.spec.whatwg.org/#mime-type - const mimeType = { - type: typeLowercase, - subtype: subtypeLowercase, - /** @type {Map} */ - parameters: new Map(), - // https://mimesniff.spec.whatwg.org/#mime-type-essence - essence: `${typeLowercase}/${subtypeLowercase}` - } - - // 11. While position is not past the end of input: - while (position.position < input.length) { - // 1. Advance position by 1. (This skips past U+003B (;).) - position.position++ - - // 2. Collect a sequence of code points that are HTTP - // whitespace from input given position. - collectASequenceOfCodePoints( - // https://fetch.spec.whatwg.org/#http-whitespace - char => HTTP_WHITESPACE_REGEX.test(char), - input, - position - ) - - // 3. Let parameterName be the result of collecting a - // sequence of code points that are not U+003B (;) - // or U+003D (=) from input, given position. - let parameterName = collectASequenceOfCodePoints( - (char) => char !== ';' && char !== '=', - input, - position - ) - - // 4. Set parameterName to parameterName, in ASCII - // lowercase. - parameterName = parameterName.toLowerCase() - - // 5. If position is not past the end of input, then: - if (position.position < input.length) { - // 1. If the code point at position within input is - // U+003B (;), then continue. - if (input[position.position] === ';') { - continue - } - - // 2. Advance position by 1. (This skips past U+003D (=).) - position.position++ - } - - // 6. If position is past the end of input, then break. - if (position.position > input.length) { - break - } - - // 7. Let parameterValue be null. - let parameterValue = null - - // 8. If the code point at position within input is - // U+0022 ("), then: - if (input[position.position] === '"') { - // 1. Set parameterValue to the result of collecting - // an HTTP quoted string from input, given position - // and the extract-value flag. - parameterValue = collectAnHTTPQuotedString(input, position, true) - - // 2. Collect a sequence of code points that are not - // U+003B (;) from input, given position. - collectASequenceOfCodePointsFast( - ';', - input, - position - ) - - // 9. Otherwise: - } else { - // 1. Set parameterValue to the result of collecting - // a sequence of code points that are not U+003B (;) - // from input, given position. - parameterValue = collectASequenceOfCodePointsFast( - ';', - input, - position - ) - - // 2. Remove any trailing HTTP whitespace from parameterValue. - parameterValue = removeHTTPWhitespace(parameterValue, false, true) - - // 3. If parameterValue is the empty string, then continue. - if (parameterValue.length === 0) { - continue - } - } - - // 10. If all of the following are true - // - parameterName is not the empty string - // - parameterName solely contains HTTP token code points - // - parameterValue solely contains HTTP quoted-string token code points - // - mimeType’s parameters[parameterName] does not exist - // then set mimeType’s parameters[parameterName] to parameterValue. - if ( - parameterName.length !== 0 && - HTTP_TOKEN_CODEPOINTS.test(parameterName) && - (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && - !mimeType.parameters.has(parameterName) - ) { - mimeType.parameters.set(parameterName, parameterValue) - } - } - - // 12. Return mimeType. - return mimeType -} - -// https://infra.spec.whatwg.org/#forgiving-base64-decode -/** @param {string} data */ -function forgivingBase64 (data) { - // 1. Remove all ASCII whitespace from data. - data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, '') // eslint-disable-line - - // 2. If data’s code point length divides by 4 leaving - // no remainder, then: - if (data.length % 4 === 0) { - // 1. If data ends with one or two U+003D (=) code points, - // then remove them from data. - data = data.replace(/=?=$/, '') - } - - // 3. If data’s code point length divides by 4 leaving - // a remainder of 1, then return failure. - if (data.length % 4 === 1) { - return 'failure' - } - - // 4. If data contains a code point that is not one of - // U+002B (+) - // U+002F (/) - // ASCII alphanumeric - // then return failure. - if (/[^+/0-9A-Za-z]/.test(data)) { - return 'failure' - } - - const binary = atob(data) - const bytes = new Uint8Array(binary.length) - - for (let byte = 0; byte < binary.length; byte++) { - bytes[byte] = binary.charCodeAt(byte) - } - - return bytes -} - -// https://fetch.spec.whatwg.org/#collect-an-http-quoted-string -// tests: https://fetch.spec.whatwg.org/#example-http-quoted-string -/** - * @param {string} input - * @param {{ position: number }} position - * @param {boolean?} extractValue - */ -function collectAnHTTPQuotedString (input, position, extractValue) { - // 1. Let positionStart be position. - const positionStart = position.position - - // 2. Let value be the empty string. - let value = '' - - // 3. Assert: the code point at position within input - // is U+0022 ("). - assert(input[position.position] === '"') - - // 4. Advance position by 1. - position.position++ - - // 5. While true: - while (true) { - // 1. Append the result of collecting a sequence of code points - // that are not U+0022 (") or U+005C (\) from input, given - // position, to value. - value += collectASequenceOfCodePoints( - (char) => char !== '"' && char !== '\\', - input, - position - ) - - // 2. If position is past the end of input, then break. - if (position.position >= input.length) { - break - } - - // 3. Let quoteOrBackslash be the code point at position within - // input. - const quoteOrBackslash = input[position.position] - - // 4. Advance position by 1. - position.position++ - - // 5. If quoteOrBackslash is U+005C (\), then: - if (quoteOrBackslash === '\\') { - // 1. If position is past the end of input, then append - // U+005C (\) to value and break. - if (position.position >= input.length) { - value += '\\' - break - } - - // 2. Append the code point at position within input to value. - value += input[position.position] - - // 3. Advance position by 1. - position.position++ - - // 6. Otherwise: - } else { - // 1. Assert: quoteOrBackslash is U+0022 ("). - assert(quoteOrBackslash === '"') - - // 2. Break. - break - } - } - - // 6. If the extract-value flag is set, then return value. - if (extractValue) { - return value - } - - // 7. Return the code points from positionStart to position, - // inclusive, within input. - return input.slice(positionStart, position.position) -} - -/** - * @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type - */ -function serializeAMimeType (mimeType) { - assert(mimeType !== 'failure') - const { parameters, essence } = mimeType - - // 1. Let serialization be the concatenation of mimeType’s - // type, U+002F (/), and mimeType’s subtype. - let serialization = essence - - // 2. For each name → value of mimeType’s parameters: - for (let [name, value] of parameters.entries()) { - // 1. Append U+003B (;) to serialization. - serialization += ';' - - // 2. Append name to serialization. - serialization += name - - // 3. Append U+003D (=) to serialization. - serialization += '=' - - // 4. If value does not solely contain HTTP token code - // points or value is the empty string, then: - if (!HTTP_TOKEN_CODEPOINTS.test(value)) { - // 1. Precede each occurence of U+0022 (") or - // U+005C (\) in value with U+005C (\). - value = value.replace(/(\\|")/g, '\\$1') - - // 2. Prepend U+0022 (") to value. - value = '"' + value - - // 3. Append U+0022 (") to value. - value += '"' - } - - // 5. Append value to serialization. - serialization += value - } - - // 3. Return serialization. - return serialization -} - -/** - * @see https://fetch.spec.whatwg.org/#http-whitespace - * @param {string} char - */ -function isHTTPWhiteSpace (char) { - return char === '\r' || char === '\n' || char === '\t' || char === ' ' -} - -/** - * @see https://fetch.spec.whatwg.org/#http-whitespace - * @param {string} str - */ -function removeHTTPWhitespace (str, leading = true, trailing = true) { - let lead = 0 - let trail = str.length - 1 - - if (leading) { - for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++); - } - - if (trailing) { - for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--); - } - - return str.slice(lead, trail + 1) -} - -/** - * @see https://infra.spec.whatwg.org/#ascii-whitespace - * @param {string} char - */ -function isASCIIWhitespace (char) { - return char === '\r' || char === '\n' || char === '\t' || char === '\f' || char === ' ' -} - -/** - * @see https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace - */ -function removeASCIIWhitespace (str, leading = true, trailing = true) { - let lead = 0 - let trail = str.length - 1 - - if (leading) { - for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++); - } - - if (trailing) { - for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--); - } - - return str.slice(lead, trail + 1) -} - -module.exports = { - dataURLProcessor, - URLSerializer, - collectASequenceOfCodePoints, - collectASequenceOfCodePointsFast, - stringPercentDecode, - parseMIMEType, - collectAnHTTPQuotedString, - serializeAMimeType -} - - -/***/ }), - -/***/ 3041: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { Blob, File: NativeFile } = __nccwpck_require__(181) -const { types } = __nccwpck_require__(9023) -const { kState } = __nccwpck_require__(9710) -const { isBlobLike } = __nccwpck_require__(5523) -const { webidl } = __nccwpck_require__(4222) -const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(4322) -const { kEnumerableProperty } = __nccwpck_require__(3440) -const encoder = new TextEncoder() - -class File extends Blob { - constructor (fileBits, fileName, options = {}) { - // The File constructor is invoked with two or three parameters, depending - // on whether the optional dictionary parameter is used. When the File() - // constructor is invoked, user agents must run the following steps: - webidl.argumentLengthCheck(arguments, 2, { header: 'File constructor' }) - - fileBits = webidl.converters['sequence'](fileBits) - fileName = webidl.converters.USVString(fileName) - options = webidl.converters.FilePropertyBag(options) - - // 1. Let bytes be the result of processing blob parts given fileBits and - // options. - // Note: Blob handles this for us - - // 2. Let n be the fileName argument to the constructor. - const n = fileName - - // 3. Process FilePropertyBag dictionary argument by running the following - // substeps: - - // 1. If the type member is provided and is not the empty string, let t - // be set to the type dictionary member. If t contains any characters - // outside the range U+0020 to U+007E, then set t to the empty string - // and return from these substeps. - // 2. Convert every character in t to ASCII lowercase. - let t = options.type - let d - - // eslint-disable-next-line no-labels - substep: { - if (t) { - t = parseMIMEType(t) - - if (t === 'failure') { - t = '' - // eslint-disable-next-line no-labels - break substep - } - - t = serializeAMimeType(t).toLowerCase() - } - - // 3. If the lastModified member is provided, let d be set to the - // lastModified dictionary member. If it is not provided, set d to the - // current date and time represented as the number of milliseconds since - // the Unix Epoch (which is the equivalent of Date.now() [ECMA-262]). - d = options.lastModified - } - - // 4. Return a new File object F such that: - // F refers to the bytes byte sequence. - // F.size is set to the number of total bytes in bytes. - // F.name is set to n. - // F.type is set to t. - // F.lastModified is set to d. - - super(processBlobParts(fileBits, options), { type: t }) - this[kState] = { - name: n, - lastModified: d, - type: t - } - } - - get name () { - webidl.brandCheck(this, File) - - return this[kState].name - } - - get lastModified () { - webidl.brandCheck(this, File) - - return this[kState].lastModified - } - - get type () { - webidl.brandCheck(this, File) - - return this[kState].type - } -} - -class FileLike { - constructor (blobLike, fileName, options = {}) { - // TODO: argument idl type check - - // The File constructor is invoked with two or three parameters, depending - // on whether the optional dictionary parameter is used. When the File() - // constructor is invoked, user agents must run the following steps: - - // 1. Let bytes be the result of processing blob parts given fileBits and - // options. - - // 2. Let n be the fileName argument to the constructor. - const n = fileName - - // 3. Process FilePropertyBag dictionary argument by running the following - // substeps: - - // 1. If the type member is provided and is not the empty string, let t - // be set to the type dictionary member. If t contains any characters - // outside the range U+0020 to U+007E, then set t to the empty string - // and return from these substeps. - // TODO - const t = options.type - - // 2. Convert every character in t to ASCII lowercase. - // TODO - - // 3. If the lastModified member is provided, let d be set to the - // lastModified dictionary member. If it is not provided, set d to the - // current date and time represented as the number of milliseconds since - // the Unix Epoch (which is the equivalent of Date.now() [ECMA-262]). - const d = options.lastModified ?? Date.now() - - // 4. Return a new File object F such that: - // F refers to the bytes byte sequence. - // F.size is set to the number of total bytes in bytes. - // F.name is set to n. - // F.type is set to t. - // F.lastModified is set to d. - - this[kState] = { - blobLike, - name: n, - type: t, - lastModified: d - } - } - - stream (...args) { - webidl.brandCheck(this, FileLike) - - return this[kState].blobLike.stream(...args) - } - - arrayBuffer (...args) { - webidl.brandCheck(this, FileLike) - - return this[kState].blobLike.arrayBuffer(...args) - } - - slice (...args) { - webidl.brandCheck(this, FileLike) - - return this[kState].blobLike.slice(...args) - } - - text (...args) { - webidl.brandCheck(this, FileLike) - - return this[kState].blobLike.text(...args) - } - - get size () { - webidl.brandCheck(this, FileLike) - - return this[kState].blobLike.size - } - - get type () { - webidl.brandCheck(this, FileLike) - - return this[kState].blobLike.type - } - - get name () { - webidl.brandCheck(this, FileLike) - - return this[kState].name - } - - get lastModified () { - webidl.brandCheck(this, FileLike) - - return this[kState].lastModified - } - - get [Symbol.toStringTag] () { - return 'File' - } -} - -Object.defineProperties(File.prototype, { - [Symbol.toStringTag]: { - value: 'File', - configurable: true - }, - name: kEnumerableProperty, - lastModified: kEnumerableProperty -}) - -webidl.converters.Blob = webidl.interfaceConverter(Blob) - -webidl.converters.BlobPart = function (V, opts) { - if (webidl.util.Type(V) === 'Object') { - if (isBlobLike(V)) { - return webidl.converters.Blob(V, { strict: false }) - } - - if ( - ArrayBuffer.isView(V) || - types.isAnyArrayBuffer(V) - ) { - return webidl.converters.BufferSource(V, opts) - } - } - - return webidl.converters.USVString(V, opts) -} - -webidl.converters['sequence'] = webidl.sequenceConverter( - webidl.converters.BlobPart -) - -// https://www.w3.org/TR/FileAPI/#dfn-FilePropertyBag -webidl.converters.FilePropertyBag = webidl.dictionaryConverter([ - { - key: 'lastModified', - converter: webidl.converters['long long'], - get defaultValue () { - return Date.now() - } - }, - { - key: 'type', - converter: webidl.converters.DOMString, - defaultValue: '' - }, - { - key: 'endings', - converter: (value) => { - value = webidl.converters.DOMString(value) - value = value.toLowerCase() - - if (value !== 'native') { - value = 'transparent' - } - - return value - }, - defaultValue: 'transparent' - } -]) - -/** - * @see https://www.w3.org/TR/FileAPI/#process-blob-parts - * @param {(NodeJS.TypedArray|Blob|string)[]} parts - * @param {{ type: string, endings: string }} options - */ -function processBlobParts (parts, options) { - // 1. Let bytes be an empty sequence of bytes. - /** @type {NodeJS.TypedArray[]} */ - const bytes = [] - - // 2. For each element in parts: - for (const element of parts) { - // 1. If element is a USVString, run the following substeps: - if (typeof element === 'string') { - // 1. Let s be element. - let s = element - - // 2. If the endings member of options is "native", set s - // to the result of converting line endings to native - // of element. - if (options.endings === 'native') { - s = convertLineEndingsNative(s) - } - - // 3. Append the result of UTF-8 encoding s to bytes. - bytes.push(encoder.encode(s)) - } else if ( - types.isAnyArrayBuffer(element) || - types.isTypedArray(element) - ) { - // 2. If element is a BufferSource, get a copy of the - // bytes held by the buffer source, and append those - // bytes to bytes. - if (!element.buffer) { // ArrayBuffer - bytes.push(new Uint8Array(element)) - } else { - bytes.push( - new Uint8Array(element.buffer, element.byteOffset, element.byteLength) - ) - } - } else if (isBlobLike(element)) { - // 3. If element is a Blob, append the bytes it represents - // to bytes. - bytes.push(element) - } - } - - // 3. Return bytes. - return bytes -} - -/** - * @see https://www.w3.org/TR/FileAPI/#convert-line-endings-to-native - * @param {string} s - */ -function convertLineEndingsNative (s) { - // 1. Let native line ending be be the code point U+000A LF. - let nativeLineEnding = '\n' - - // 2. If the underlying platform’s conventions are to - // represent newlines as a carriage return and line feed - // sequence, set native line ending to the code point - // U+000D CR followed by the code point U+000A LF. - if (process.platform === 'win32') { - nativeLineEnding = '\r\n' - } - - return s.replace(/\r?\n/g, nativeLineEnding) -} - -// If this function is moved to ./util.js, some tools (such as -// rollup) will warn about circular dependencies. See: -// https://github.com/nodejs/undici/issues/1629 -function isFileLike (object) { - return ( - (NativeFile && object instanceof NativeFile) || - object instanceof File || ( - object && - (typeof object.stream === 'function' || - typeof object.arrayBuffer === 'function') && - object[Symbol.toStringTag] === 'File' - ) - ) -} - -module.exports = { File, FileLike, isFileLike } - - -/***/ }), - -/***/ 3073: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { isBlobLike, toUSVString, makeIterator } = __nccwpck_require__(5523) -const { kState } = __nccwpck_require__(9710) -const { File: UndiciFile, FileLike, isFileLike } = __nccwpck_require__(3041) -const { webidl } = __nccwpck_require__(4222) -const { Blob, File: NativeFile } = __nccwpck_require__(181) - -/** @type {globalThis['File']} */ -const File = NativeFile ?? UndiciFile - -// https://xhr.spec.whatwg.org/#formdata -class FormData { - constructor (form) { - if (form !== undefined) { - throw webidl.errors.conversionFailed({ - prefix: 'FormData constructor', - argument: 'Argument 1', - types: ['undefined'] - }) - } - - this[kState] = [] - } - - append (name, value, filename = undefined) { - webidl.brandCheck(this, FormData) - - webidl.argumentLengthCheck(arguments, 2, { header: 'FormData.append' }) - - if (arguments.length === 3 && !isBlobLike(value)) { - throw new TypeError( - "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" - ) - } - - // 1. Let value be value if given; otherwise blobValue. - - name = webidl.converters.USVString(name) - value = isBlobLike(value) - ? webidl.converters.Blob(value, { strict: false }) - : webidl.converters.USVString(value) - filename = arguments.length === 3 - ? webidl.converters.USVString(filename) - : undefined - - // 2. Let entry be the result of creating an entry with - // name, value, and filename if given. - const entry = makeEntry(name, value, filename) - - // 3. Append entry to this’s entry list. - this[kState].push(entry) - } - - delete (name) { - webidl.brandCheck(this, FormData) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FormData.delete' }) - - name = webidl.converters.USVString(name) - - // The delete(name) method steps are to remove all entries whose name - // is name from this’s entry list. - this[kState] = this[kState].filter(entry => entry.name !== name) - } - - get (name) { - webidl.brandCheck(this, FormData) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FormData.get' }) - - name = webidl.converters.USVString(name) - - // 1. If there is no entry whose name is name in this’s entry list, - // then return null. - const idx = this[kState].findIndex((entry) => entry.name === name) - if (idx === -1) { - return null - } - - // 2. Return the value of the first entry whose name is name from - // this’s entry list. - return this[kState][idx].value - } - - getAll (name) { - webidl.brandCheck(this, FormData) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FormData.getAll' }) - - name = webidl.converters.USVString(name) - - // 1. If there is no entry whose name is name in this’s entry list, - // then return the empty list. - // 2. Return the values of all entries whose name is name, in order, - // from this’s entry list. - return this[kState] - .filter((entry) => entry.name === name) - .map((entry) => entry.value) - } - - has (name) { - webidl.brandCheck(this, FormData) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FormData.has' }) - - name = webidl.converters.USVString(name) - - // The has(name) method steps are to return true if there is an entry - // whose name is name in this’s entry list; otherwise false. - return this[kState].findIndex((entry) => entry.name === name) !== -1 - } - - set (name, value, filename = undefined) { - webidl.brandCheck(this, FormData) - - webidl.argumentLengthCheck(arguments, 2, { header: 'FormData.set' }) - - if (arguments.length === 3 && !isBlobLike(value)) { - throw new TypeError( - "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" - ) - } - - // The set(name, value) and set(name, blobValue, filename) method steps - // are: - - // 1. Let value be value if given; otherwise blobValue. - - name = webidl.converters.USVString(name) - value = isBlobLike(value) - ? webidl.converters.Blob(value, { strict: false }) - : webidl.converters.USVString(value) - filename = arguments.length === 3 - ? toUSVString(filename) - : undefined - - // 2. Let entry be the result of creating an entry with name, value, and - // filename if given. - const entry = makeEntry(name, value, filename) - - // 3. If there are entries in this’s entry list whose name is name, then - // replace the first such entry with entry and remove the others. - const idx = this[kState].findIndex((entry) => entry.name === name) - if (idx !== -1) { - this[kState] = [ - ...this[kState].slice(0, idx), - entry, - ...this[kState].slice(idx + 1).filter((entry) => entry.name !== name) - ] - } else { - // 4. Otherwise, append entry to this’s entry list. - this[kState].push(entry) - } - } - - entries () { - webidl.brandCheck(this, FormData) - - return makeIterator( - () => this[kState].map(pair => [pair.name, pair.value]), - 'FormData', - 'key+value' - ) - } - - keys () { - webidl.brandCheck(this, FormData) - - return makeIterator( - () => this[kState].map(pair => [pair.name, pair.value]), - 'FormData', - 'key' - ) - } - - values () { - webidl.brandCheck(this, FormData) - - return makeIterator( - () => this[kState].map(pair => [pair.name, pair.value]), - 'FormData', - 'value' - ) - } - - /** - * @param {(value: string, key: string, self: FormData) => void} callbackFn - * @param {unknown} thisArg - */ - forEach (callbackFn, thisArg = globalThis) { - webidl.brandCheck(this, FormData) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FormData.forEach' }) - - if (typeof callbackFn !== 'function') { - throw new TypeError( - "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'." - ) - } - - for (const [key, value] of this) { - callbackFn.apply(thisArg, [value, key, this]) - } - } -} - -FormData.prototype[Symbol.iterator] = FormData.prototype.entries - -Object.defineProperties(FormData.prototype, { - [Symbol.toStringTag]: { - value: 'FormData', - configurable: true - } -}) - -/** - * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#create-an-entry - * @param {string} name - * @param {string|Blob} value - * @param {?string} filename - * @returns - */ -function makeEntry (name, value, filename) { - // 1. Set name to the result of converting name into a scalar value string. - // "To convert a string into a scalar value string, replace any surrogates - // with U+FFFD." - // see: https://nodejs.org/dist/latest-v18.x/docs/api/buffer.html#buftostringencoding-start-end - name = Buffer.from(name).toString('utf8') - - // 2. If value is a string, then set value to the result of converting - // value into a scalar value string. - if (typeof value === 'string') { - value = Buffer.from(value).toString('utf8') - } else { - // 3. Otherwise: - - // 1. If value is not a File object, then set value to a new File object, - // representing the same bytes, whose name attribute value is "blob" - if (!isFileLike(value)) { - value = value instanceof Blob - ? new File([value], 'blob', { type: value.type }) - : new FileLike(value, 'blob', { type: value.type }) - } - - // 2. If filename is given, then set value to a new File object, - // representing the same bytes, whose name attribute is filename. - if (filename !== undefined) { - /** @type {FilePropertyBag} */ - const options = { - type: value.type, - lastModified: value.lastModified - } - - value = (NativeFile && value instanceof NativeFile) || value instanceof UndiciFile - ? new File([value], filename, options) - : new FileLike(value, filename, options) - } - } - - // 4. Return an entry whose name is name and whose value is value. - return { name, value } -} - -module.exports = { FormData } - - -/***/ }), - -/***/ 5628: -/***/ ((module) => { - -"use strict"; - - -// In case of breaking changes, increase the version -// number to avoid conflicts. -const globalOrigin = Symbol.for('undici.globalOrigin.1') - -function getGlobalOrigin () { - return globalThis[globalOrigin] -} - -function setGlobalOrigin (newOrigin) { - if (newOrigin === undefined) { - Object.defineProperty(globalThis, globalOrigin, { - value: undefined, - writable: true, - enumerable: false, - configurable: false - }) - - return - } - - const parsedURL = new URL(newOrigin) - - if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') { - throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`) - } - - Object.defineProperty(globalThis, globalOrigin, { - value: parsedURL, - writable: true, - enumerable: false, - configurable: false - }) -} - -module.exports = { - getGlobalOrigin, - setGlobalOrigin -} - - -/***/ }), - -/***/ 6349: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; -// https://github.com/Ethan-Arrowood/undici-fetch - - - -const { kHeadersList, kConstruct } = __nccwpck_require__(6443) -const { kGuard } = __nccwpck_require__(9710) -const { kEnumerableProperty } = __nccwpck_require__(3440) -const { - makeIterator, - isValidHeaderName, - isValidHeaderValue -} = __nccwpck_require__(5523) -const util = __nccwpck_require__(9023) -const { webidl } = __nccwpck_require__(4222) -const assert = __nccwpck_require__(2613) - -const kHeadersMap = Symbol('headers map') -const kHeadersSortedMap = Symbol('headers map sorted') - -/** - * @param {number} code - */ -function isHTTPWhiteSpaceCharCode (code) { - return code === 0x00a || code === 0x00d || code === 0x009 || code === 0x020 -} - -/** - * @see https://fetch.spec.whatwg.org/#concept-header-value-normalize - * @param {string} potentialValue - */ -function headerValueNormalize (potentialValue) { - // To normalize a byte sequence potentialValue, remove - // any leading and trailing HTTP whitespace bytes from - // potentialValue. - let i = 0; let j = potentialValue.length - - while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j - while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i - - return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j) -} - -function fill (headers, object) { - // To fill a Headers object headers with a given object object, run these steps: - - // 1. If object is a sequence, then for each header in object: - // Note: webidl conversion to array has already been done. - if (Array.isArray(object)) { - for (let i = 0; i < object.length; ++i) { - const header = object[i] - // 1. If header does not contain exactly two items, then throw a TypeError. - if (header.length !== 2) { - throw webidl.errors.exception({ - header: 'Headers constructor', - message: `expected name/value pair to be length 2, found ${header.length}.` - }) - } - - // 2. Append (header’s first item, header’s second item) to headers. - appendHeader(headers, header[0], header[1]) - } - } else if (typeof object === 'object' && object !== null) { - // Note: null should throw - - // 2. Otherwise, object is a record, then for each key → value in object, - // append (key, value) to headers - const keys = Object.keys(object) - for (let i = 0; i < keys.length; ++i) { - appendHeader(headers, keys[i], object[keys[i]]) - } - } else { - throw webidl.errors.conversionFailed({ - prefix: 'Headers constructor', - argument: 'Argument 1', - types: ['sequence>', 'record'] - }) - } -} - -/** - * @see https://fetch.spec.whatwg.org/#concept-headers-append - */ -function appendHeader (headers, name, value) { - // 1. Normalize value. - value = headerValueNormalize(value) - - // 2. If name is not a header name or value is not a - // header value, then throw a TypeError. - if (!isValidHeaderName(name)) { - throw webidl.errors.invalidArgument({ - prefix: 'Headers.append', - value: name, - type: 'header name' - }) - } else if (!isValidHeaderValue(value)) { - throw webidl.errors.invalidArgument({ - prefix: 'Headers.append', - value, - type: 'header value' - }) - } - - // 3. If headers’s guard is "immutable", then throw a TypeError. - // 4. Otherwise, if headers’s guard is "request" and name is a - // forbidden header name, return. - // Note: undici does not implement forbidden header names - if (headers[kGuard] === 'immutable') { - throw new TypeError('immutable') - } else if (headers[kGuard] === 'request-no-cors') { - // 5. Otherwise, if headers’s guard is "request-no-cors": - // TODO - } - - // 6. Otherwise, if headers’s guard is "response" and name is a - // forbidden response-header name, return. - - // 7. Append (name, value) to headers’s header list. - return headers[kHeadersList].append(name, value) - - // 8. If headers’s guard is "request-no-cors", then remove - // privileged no-CORS request headers from headers -} - -class HeadersList { - /** @type {[string, string][]|null} */ - cookies = null - - constructor (init) { - if (init instanceof HeadersList) { - this[kHeadersMap] = new Map(init[kHeadersMap]) - this[kHeadersSortedMap] = init[kHeadersSortedMap] - this.cookies = init.cookies === null ? null : [...init.cookies] - } else { - this[kHeadersMap] = new Map(init) - this[kHeadersSortedMap] = null - } - } - - // https://fetch.spec.whatwg.org/#header-list-contains - contains (name) { - // A header list list contains a header name name if list - // contains a header whose name is a byte-case-insensitive - // match for name. - name = name.toLowerCase() - - return this[kHeadersMap].has(name) - } - - clear () { - this[kHeadersMap].clear() - this[kHeadersSortedMap] = null - this.cookies = null - } - - // https://fetch.spec.whatwg.org/#concept-header-list-append - append (name, value) { - this[kHeadersSortedMap] = null - - // 1. If list contains name, then set name to the first such - // header’s name. - const lowercaseName = name.toLowerCase() - const exists = this[kHeadersMap].get(lowercaseName) - - // 2. Append (name, value) to list. - if (exists) { - const delimiter = lowercaseName === 'cookie' ? '; ' : ', ' - this[kHeadersMap].set(lowercaseName, { - name: exists.name, - value: `${exists.value}${delimiter}${value}` - }) - } else { - this[kHeadersMap].set(lowercaseName, { name, value }) - } - - if (lowercaseName === 'set-cookie') { - this.cookies ??= [] - this.cookies.push(value) - } - } - - // https://fetch.spec.whatwg.org/#concept-header-list-set - set (name, value) { - this[kHeadersSortedMap] = null - const lowercaseName = name.toLowerCase() - - if (lowercaseName === 'set-cookie') { - this.cookies = [value] - } - - // 1. If list contains name, then set the value of - // the first such header to value and remove the - // others. - // 2. Otherwise, append header (name, value) to list. - this[kHeadersMap].set(lowercaseName, { name, value }) - } - - // https://fetch.spec.whatwg.org/#concept-header-list-delete - delete (name) { - this[kHeadersSortedMap] = null - - name = name.toLowerCase() - - if (name === 'set-cookie') { - this.cookies = null - } - - this[kHeadersMap].delete(name) - } - - // https://fetch.spec.whatwg.org/#concept-header-list-get - get (name) { - const value = this[kHeadersMap].get(name.toLowerCase()) - - // 1. If list does not contain name, then return null. - // 2. Return the values of all headers in list whose name - // is a byte-case-insensitive match for name, - // separated from each other by 0x2C 0x20, in order. - return value === undefined ? null : value.value - } - - * [Symbol.iterator] () { - // use the lowercased name - for (const [name, { value }] of this[kHeadersMap]) { - yield [name, value] - } - } - - get entries () { - const headers = {} - - if (this[kHeadersMap].size) { - for (const { name, value } of this[kHeadersMap].values()) { - headers[name] = value - } - } - - return headers - } -} - -// https://fetch.spec.whatwg.org/#headers-class -class Headers { - constructor (init = undefined) { - if (init === kConstruct) { - return - } - this[kHeadersList] = new HeadersList() - - // The new Headers(init) constructor steps are: - - // 1. Set this’s guard to "none". - this[kGuard] = 'none' - - // 2. If init is given, then fill this with init. - if (init !== undefined) { - init = webidl.converters.HeadersInit(init) - fill(this, init) - } - } - - // https://fetch.spec.whatwg.org/#dom-headers-append - append (name, value) { - webidl.brandCheck(this, Headers) - - webidl.argumentLengthCheck(arguments, 2, { header: 'Headers.append' }) - - name = webidl.converters.ByteString(name) - value = webidl.converters.ByteString(value) - - return appendHeader(this, name, value) - } - - // https://fetch.spec.whatwg.org/#dom-headers-delete - delete (name) { - webidl.brandCheck(this, Headers) - - webidl.argumentLengthCheck(arguments, 1, { header: 'Headers.delete' }) - - name = webidl.converters.ByteString(name) - - // 1. If name is not a header name, then throw a TypeError. - if (!isValidHeaderName(name)) { - throw webidl.errors.invalidArgument({ - prefix: 'Headers.delete', - value: name, - type: 'header name' - }) - } - - // 2. If this’s guard is "immutable", then throw a TypeError. - // 3. Otherwise, if this’s guard is "request" and name is a - // forbidden header name, return. - // 4. Otherwise, if this’s guard is "request-no-cors", name - // is not a no-CORS-safelisted request-header name, and - // name is not a privileged no-CORS request-header name, - // return. - // 5. Otherwise, if this’s guard is "response" and name is - // a forbidden response-header name, return. - // Note: undici does not implement forbidden header names - if (this[kGuard] === 'immutable') { - throw new TypeError('immutable') - } else if (this[kGuard] === 'request-no-cors') { - // TODO - } - - // 6. If this’s header list does not contain name, then - // return. - if (!this[kHeadersList].contains(name)) { - return - } - - // 7. Delete name from this’s header list. - // 8. If this’s guard is "request-no-cors", then remove - // privileged no-CORS request headers from this. - this[kHeadersList].delete(name) - } - - // https://fetch.spec.whatwg.org/#dom-headers-get - get (name) { - webidl.brandCheck(this, Headers) - - webidl.argumentLengthCheck(arguments, 1, { header: 'Headers.get' }) - - name = webidl.converters.ByteString(name) - - // 1. If name is not a header name, then throw a TypeError. - if (!isValidHeaderName(name)) { - throw webidl.errors.invalidArgument({ - prefix: 'Headers.get', - value: name, - type: 'header name' - }) - } - - // 2. Return the result of getting name from this’s header - // list. - return this[kHeadersList].get(name) - } - - // https://fetch.spec.whatwg.org/#dom-headers-has - has (name) { - webidl.brandCheck(this, Headers) - - webidl.argumentLengthCheck(arguments, 1, { header: 'Headers.has' }) - - name = webidl.converters.ByteString(name) - - // 1. If name is not a header name, then throw a TypeError. - if (!isValidHeaderName(name)) { - throw webidl.errors.invalidArgument({ - prefix: 'Headers.has', - value: name, - type: 'header name' - }) - } - - // 2. Return true if this’s header list contains name; - // otherwise false. - return this[kHeadersList].contains(name) - } - - // https://fetch.spec.whatwg.org/#dom-headers-set - set (name, value) { - webidl.brandCheck(this, Headers) - - webidl.argumentLengthCheck(arguments, 2, { header: 'Headers.set' }) - - name = webidl.converters.ByteString(name) - value = webidl.converters.ByteString(value) - - // 1. Normalize value. - value = headerValueNormalize(value) - - // 2. If name is not a header name or value is not a - // header value, then throw a TypeError. - if (!isValidHeaderName(name)) { - throw webidl.errors.invalidArgument({ - prefix: 'Headers.set', - value: name, - type: 'header name' - }) - } else if (!isValidHeaderValue(value)) { - throw webidl.errors.invalidArgument({ - prefix: 'Headers.set', - value, - type: 'header value' - }) - } - - // 3. If this’s guard is "immutable", then throw a TypeError. - // 4. Otherwise, if this’s guard is "request" and name is a - // forbidden header name, return. - // 5. Otherwise, if this’s guard is "request-no-cors" and - // name/value is not a no-CORS-safelisted request-header, - // return. - // 6. Otherwise, if this’s guard is "response" and name is a - // forbidden response-header name, return. - // Note: undici does not implement forbidden header names - if (this[kGuard] === 'immutable') { - throw new TypeError('immutable') - } else if (this[kGuard] === 'request-no-cors') { - // TODO - } - - // 7. Set (name, value) in this’s header list. - // 8. If this’s guard is "request-no-cors", then remove - // privileged no-CORS request headers from this - this[kHeadersList].set(name, value) - } - - // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie - getSetCookie () { - webidl.brandCheck(this, Headers) - - // 1. If this’s header list does not contain `Set-Cookie`, then return « ». - // 2. Return the values of all headers in this’s header list whose name is - // a byte-case-insensitive match for `Set-Cookie`, in order. - - const list = this[kHeadersList].cookies - - if (list) { - return [...list] - } - - return [] - } - - // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine - get [kHeadersSortedMap] () { - if (this[kHeadersList][kHeadersSortedMap]) { - return this[kHeadersList][kHeadersSortedMap] - } - - // 1. Let headers be an empty list of headers with the key being the name - // and value the value. - const headers = [] - - // 2. Let names be the result of convert header names to a sorted-lowercase - // set with all the names of the headers in list. - const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1) - const cookies = this[kHeadersList].cookies - - // 3. For each name of names: - for (let i = 0; i < names.length; ++i) { - const [name, value] = names[i] - // 1. If name is `set-cookie`, then: - if (name === 'set-cookie') { - // 1. Let values be a list of all values of headers in list whose name - // is a byte-case-insensitive match for name, in order. - - // 2. For each value of values: - // 1. Append (name, value) to headers. - for (let j = 0; j < cookies.length; ++j) { - headers.push([name, cookies[j]]) - } - } else { - // 2. Otherwise: - - // 1. Let value be the result of getting name from list. - - // 2. Assert: value is non-null. - assert(value !== null) - - // 3. Append (name, value) to headers. - headers.push([name, value]) - } - } - - this[kHeadersList][kHeadersSortedMap] = headers - - // 4. Return headers. - return headers - } - - keys () { - webidl.brandCheck(this, Headers) - - if (this[kGuard] === 'immutable') { - const value = this[kHeadersSortedMap] - return makeIterator(() => value, 'Headers', - 'key') - } - - return makeIterator( - () => [...this[kHeadersSortedMap].values()], - 'Headers', - 'key' - ) - } - - values () { - webidl.brandCheck(this, Headers) - - if (this[kGuard] === 'immutable') { - const value = this[kHeadersSortedMap] - return makeIterator(() => value, 'Headers', - 'value') - } - - return makeIterator( - () => [...this[kHeadersSortedMap].values()], - 'Headers', - 'value' - ) - } - - entries () { - webidl.brandCheck(this, Headers) - - if (this[kGuard] === 'immutable') { - const value = this[kHeadersSortedMap] - return makeIterator(() => value, 'Headers', - 'key+value') - } - - return makeIterator( - () => [...this[kHeadersSortedMap].values()], - 'Headers', - 'key+value' - ) - } - - /** - * @param {(value: string, key: string, self: Headers) => void} callbackFn - * @param {unknown} thisArg - */ - forEach (callbackFn, thisArg = globalThis) { - webidl.brandCheck(this, Headers) - - webidl.argumentLengthCheck(arguments, 1, { header: 'Headers.forEach' }) - - if (typeof callbackFn !== 'function') { - throw new TypeError( - "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'." - ) - } - - for (const [key, value] of this) { - callbackFn.apply(thisArg, [value, key, this]) - } - } - - [Symbol.for('nodejs.util.inspect.custom')] () { - webidl.brandCheck(this, Headers) - - return this[kHeadersList] - } -} - -Headers.prototype[Symbol.iterator] = Headers.prototype.entries - -Object.defineProperties(Headers.prototype, { - append: kEnumerableProperty, - delete: kEnumerableProperty, - get: kEnumerableProperty, - has: kEnumerableProperty, - set: kEnumerableProperty, - getSetCookie: kEnumerableProperty, - keys: kEnumerableProperty, - values: kEnumerableProperty, - entries: kEnumerableProperty, - forEach: kEnumerableProperty, - [Symbol.iterator]: { enumerable: false }, - [Symbol.toStringTag]: { - value: 'Headers', - configurable: true - }, - [util.inspect.custom]: { - enumerable: false - } -}) - -webidl.converters.HeadersInit = function (V) { - if (webidl.util.Type(V) === 'Object') { - if (V[Symbol.iterator]) { - return webidl.converters['sequence>'](V) - } - - return webidl.converters['record'](V) - } - - throw webidl.errors.conversionFailed({ - prefix: 'Headers constructor', - argument: 'Argument 1', - types: ['sequence>', 'record'] - }) -} - -module.exports = { - fill, - Headers, - HeadersList -} - - -/***/ }), - -/***/ 2315: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; -// https://github.com/Ethan-Arrowood/undici-fetch - - - -const { - Response, - makeNetworkError, - makeAppropriateNetworkError, - filterResponse, - makeResponse -} = __nccwpck_require__(8676) -const { Headers } = __nccwpck_require__(6349) -const { Request, makeRequest } = __nccwpck_require__(5194) -const zlib = __nccwpck_require__(3106) -const { - bytesMatch, - makePolicyContainer, - clonePolicyContainer, - requestBadPort, - TAOCheck, - appendRequestOriginHeader, - responseLocationURL, - requestCurrentURL, - setRequestReferrerPolicyOnRedirect, - tryUpgradeRequestToAPotentiallyTrustworthyURL, - createOpaqueTimingInfo, - appendFetchMetadata, - corsCheck, - crossOriginResourcePolicyCheck, - determineRequestsReferrer, - coarsenedSharedCurrentTime, - createDeferredPromise, - isBlobLike, - sameOrigin, - isCancelled, - isAborted, - isErrorLike, - fullyReadBody, - readableStreamClose, - isomorphicEncode, - urlIsLocal, - urlIsHttpHttpsScheme, - urlHasHttpsScheme -} = __nccwpck_require__(5523) -const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(9710) -const assert = __nccwpck_require__(2613) -const { safelyExtractBody } = __nccwpck_require__(8923) -const { - redirectStatusSet, - nullBodyStatus, - safeMethodsSet, - requestBodyHeader, - subresourceSet, - DOMException -} = __nccwpck_require__(7326) -const { kHeadersList } = __nccwpck_require__(6443) -const EE = __nccwpck_require__(4434) -const { Readable, pipeline } = __nccwpck_require__(2203) -const { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = __nccwpck_require__(3440) -const { dataURLProcessor, serializeAMimeType } = __nccwpck_require__(4322) -const { TransformStream } = __nccwpck_require__(3774) -const { getGlobalDispatcher } = __nccwpck_require__(2581) -const { webidl } = __nccwpck_require__(4222) -const { STATUS_CODES } = __nccwpck_require__(8611) -const GET_OR_HEAD = ['GET', 'HEAD'] - -/** @type {import('buffer').resolveObjectURL} */ -let resolveObjectURL -let ReadableStream = globalThis.ReadableStream - -class Fetch extends EE { - constructor (dispatcher) { - super() - - this.dispatcher = dispatcher - this.connection = null - this.dump = false - this.state = 'ongoing' - // 2 terminated listeners get added per request, - // but only 1 gets removed. If there are 20 redirects, - // 21 listeners will be added. - // See https://github.com/nodejs/undici/issues/1711 - // TODO (fix): Find and fix root cause for leaked listener. - this.setMaxListeners(21) - } - - terminate (reason) { - if (this.state !== 'ongoing') { - return - } - - this.state = 'terminated' - this.connection?.destroy(reason) - this.emit('terminated', reason) - } - - // https://fetch.spec.whatwg.org/#fetch-controller-abort - abort (error) { - if (this.state !== 'ongoing') { - return - } - - // 1. Set controller’s state to "aborted". - this.state = 'aborted' - - // 2. Let fallbackError be an "AbortError" DOMException. - // 3. Set error to fallbackError if it is not given. - if (!error) { - error = new DOMException('The operation was aborted.', 'AbortError') - } - - // 4. Let serializedError be StructuredSerialize(error). - // If that threw an exception, catch it, and let - // serializedError be StructuredSerialize(fallbackError). - - // 5. Set controller’s serialized abort reason to serializedError. - this.serializedAbortReason = error - - this.connection?.destroy(error) - this.emit('terminated', error) - } -} - -// https://fetch.spec.whatwg.org/#fetch-method -function fetch (input, init = {}) { - webidl.argumentLengthCheck(arguments, 1, { header: 'globalThis.fetch' }) - - // 1. Let p be a new promise. - const p = createDeferredPromise() - - // 2. Let requestObject be the result of invoking the initial value of - // Request as constructor with input and init as arguments. If this throws - // an exception, reject p with it and return p. - let requestObject - - try { - requestObject = new Request(input, init) - } catch (e) { - p.reject(e) - return p.promise - } - - // 3. Let request be requestObject’s request. - const request = requestObject[kState] - - // 4. If requestObject’s signal’s aborted flag is set, then: - if (requestObject.signal.aborted) { - // 1. Abort the fetch() call with p, request, null, and - // requestObject’s signal’s abort reason. - abortFetch(p, request, null, requestObject.signal.reason) - - // 2. Return p. - return p.promise - } - - // 5. Let globalObject be request’s client’s global object. - const globalObject = request.client.globalObject - - // 6. If globalObject is a ServiceWorkerGlobalScope object, then set - // request’s service-workers mode to "none". - if (globalObject?.constructor?.name === 'ServiceWorkerGlobalScope') { - request.serviceWorkers = 'none' - } - - // 7. Let responseObject be null. - let responseObject = null - - // 8. Let relevantRealm be this’s relevant Realm. - const relevantRealm = null - - // 9. Let locallyAborted be false. - let locallyAborted = false - - // 10. Let controller be null. - let controller = null - - // 11. Add the following abort steps to requestObject’s signal: - addAbortListener( - requestObject.signal, - () => { - // 1. Set locallyAborted to true. - locallyAborted = true - - // 2. Assert: controller is non-null. - assert(controller != null) - - // 3. Abort controller with requestObject’s signal’s abort reason. - controller.abort(requestObject.signal.reason) - - // 4. Abort the fetch() call with p, request, responseObject, - // and requestObject’s signal’s abort reason. - abortFetch(p, request, responseObject, requestObject.signal.reason) - } - ) - - // 12. Let handleFetchDone given response response be to finalize and - // report timing with response, globalObject, and "fetch". - const handleFetchDone = (response) => - finalizeAndReportTiming(response, 'fetch') - - // 13. Set controller to the result of calling fetch given request, - // with processResponseEndOfBody set to handleFetchDone, and processResponse - // given response being these substeps: - - const processResponse = (response) => { - // 1. If locallyAborted is true, terminate these substeps. - if (locallyAborted) { - return Promise.resolve() - } - - // 2. If response’s aborted flag is set, then: - if (response.aborted) { - // 1. Let deserializedError be the result of deserialize a serialized - // abort reason given controller’s serialized abort reason and - // relevantRealm. - - // 2. Abort the fetch() call with p, request, responseObject, and - // deserializedError. - - abortFetch(p, request, responseObject, controller.serializedAbortReason) - return Promise.resolve() - } - - // 3. If response is a network error, then reject p with a TypeError - // and terminate these substeps. - if (response.type === 'error') { - p.reject( - Object.assign(new TypeError('fetch failed'), { cause: response.error }) - ) - return Promise.resolve() - } - - // 4. Set responseObject to the result of creating a Response object, - // given response, "immutable", and relevantRealm. - responseObject = new Response() - responseObject[kState] = response - responseObject[kRealm] = relevantRealm - responseObject[kHeaders][kHeadersList] = response.headersList - responseObject[kHeaders][kGuard] = 'immutable' - responseObject[kHeaders][kRealm] = relevantRealm - - // 5. Resolve p with responseObject. - p.resolve(responseObject) - } - - controller = fetching({ - request, - processResponseEndOfBody: handleFetchDone, - processResponse, - dispatcher: init.dispatcher ?? getGlobalDispatcher() // undici - }) - - // 14. Return p. - return p.promise -} - -// https://fetch.spec.whatwg.org/#finalize-and-report-timing -function finalizeAndReportTiming (response, initiatorType = 'other') { - // 1. If response is an aborted network error, then return. - if (response.type === 'error' && response.aborted) { - return - } - - // 2. If response’s URL list is null or empty, then return. - if (!response.urlList?.length) { - return - } - - // 3. Let originalURL be response’s URL list[0]. - const originalURL = response.urlList[0] - - // 4. Let timingInfo be response’s timing info. - let timingInfo = response.timingInfo - - // 5. Let cacheState be response’s cache state. - let cacheState = response.cacheState - - // 6. If originalURL’s scheme is not an HTTP(S) scheme, then return. - if (!urlIsHttpHttpsScheme(originalURL)) { - return - } - - // 7. If timingInfo is null, then return. - if (timingInfo === null) { - return - } - - // 8. If response’s timing allow passed flag is not set, then: - if (!response.timingAllowPassed) { - // 1. Set timingInfo to a the result of creating an opaque timing info for timingInfo. - timingInfo = createOpaqueTimingInfo({ - startTime: timingInfo.startTime - }) - - // 2. Set cacheState to the empty string. - cacheState = '' - } - - // 9. Set timingInfo’s end time to the coarsened shared current time - // given global’s relevant settings object’s cross-origin isolated - // capability. - // TODO: given global’s relevant settings object’s cross-origin isolated - // capability? - timingInfo.endTime = coarsenedSharedCurrentTime() - - // 10. Set response’s timing info to timingInfo. - response.timingInfo = timingInfo - - // 11. Mark resource timing for timingInfo, originalURL, initiatorType, - // global, and cacheState. - markResourceTiming( - timingInfo, - originalURL, - initiatorType, - globalThis, - cacheState - ) -} - -// https://w3c.github.io/resource-timing/#dfn-mark-resource-timing -function markResourceTiming (timingInfo, originalURL, initiatorType, globalThis, cacheState) { - if (nodeMajor > 18 || (nodeMajor === 18 && nodeMinor >= 2)) { - performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis, cacheState) - } -} - -// https://fetch.spec.whatwg.org/#abort-fetch -function abortFetch (p, request, responseObject, error) { - // Note: AbortSignal.reason was added in node v17.2.0 - // which would give us an undefined error to reject with. - // Remove this once node v16 is no longer supported. - if (!error) { - error = new DOMException('The operation was aborted.', 'AbortError') - } - - // 1. Reject promise with error. - p.reject(error) - - // 2. If request’s body is not null and is readable, then cancel request’s - // body with error. - if (request.body != null && isReadable(request.body?.stream)) { - request.body.stream.cancel(error).catch((err) => { - if (err.code === 'ERR_INVALID_STATE') { - // Node bug? - return - } - throw err - }) - } - - // 3. If responseObject is null, then return. - if (responseObject == null) { - return - } - - // 4. Let response be responseObject’s response. - const response = responseObject[kState] - - // 5. If response’s body is not null and is readable, then error response’s - // body with error. - if (response.body != null && isReadable(response.body?.stream)) { - response.body.stream.cancel(error).catch((err) => { - if (err.code === 'ERR_INVALID_STATE') { - // Node bug? - return - } - throw err - }) - } -} - -// https://fetch.spec.whatwg.org/#fetching -function fetching ({ - request, - processRequestBodyChunkLength, - processRequestEndOfBody, - processResponse, - processResponseEndOfBody, - processResponseConsumeBody, - useParallelQueue = false, - dispatcher // undici -}) { - // 1. Let taskDestination be null. - let taskDestination = null - - // 2. Let crossOriginIsolatedCapability be false. - let crossOriginIsolatedCapability = false - - // 3. If request’s client is non-null, then: - if (request.client != null) { - // 1. Set taskDestination to request’s client’s global object. - taskDestination = request.client.globalObject - - // 2. Set crossOriginIsolatedCapability to request’s client’s cross-origin - // isolated capability. - crossOriginIsolatedCapability = - request.client.crossOriginIsolatedCapability - } - - // 4. If useParallelQueue is true, then set taskDestination to the result of - // starting a new parallel queue. - // TODO - - // 5. Let timingInfo be a new fetch timing info whose start time and - // post-redirect start time are the coarsened shared current time given - // crossOriginIsolatedCapability. - const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability) - const timingInfo = createOpaqueTimingInfo({ - startTime: currenTime - }) - - // 6. Let fetchParams be a new fetch params whose - // request is request, - // timing info is timingInfo, - // process request body chunk length is processRequestBodyChunkLength, - // process request end-of-body is processRequestEndOfBody, - // process response is processResponse, - // process response consume body is processResponseConsumeBody, - // process response end-of-body is processResponseEndOfBody, - // task destination is taskDestination, - // and cross-origin isolated capability is crossOriginIsolatedCapability. - const fetchParams = { - controller: new Fetch(dispatcher), - request, - timingInfo, - processRequestBodyChunkLength, - processRequestEndOfBody, - processResponse, - processResponseConsumeBody, - processResponseEndOfBody, - taskDestination, - crossOriginIsolatedCapability - } - - // 7. If request’s body is a byte sequence, then set request’s body to - // request’s body as a body. - // NOTE: Since fetching is only called from fetch, body should already be - // extracted. - assert(!request.body || request.body.stream) - - // 8. If request’s window is "client", then set request’s window to request’s - // client, if request’s client’s global object is a Window object; otherwise - // "no-window". - if (request.window === 'client') { - // TODO: What if request.client is null? - request.window = - request.client?.globalObject?.constructor?.name === 'Window' - ? request.client - : 'no-window' - } - - // 9. If request’s origin is "client", then set request’s origin to request’s - // client’s origin. - if (request.origin === 'client') { - // TODO: What if request.client is null? - request.origin = request.client?.origin - } - - // 10. If all of the following conditions are true: - // TODO - - // 11. If request’s policy container is "client", then: - if (request.policyContainer === 'client') { - // 1. If request’s client is non-null, then set request’s policy - // container to a clone of request’s client’s policy container. [HTML] - if (request.client != null) { - request.policyContainer = clonePolicyContainer( - request.client.policyContainer - ) - } else { - // 2. Otherwise, set request’s policy container to a new policy - // container. - request.policyContainer = makePolicyContainer() - } - } - - // 12. If request’s header list does not contain `Accept`, then: - if (!request.headersList.contains('accept')) { - // 1. Let value be `*/*`. - const value = '*/*' - - // 2. A user agent should set value to the first matching statement, if - // any, switching on request’s destination: - // "document" - // "frame" - // "iframe" - // `text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8` - // "image" - // `image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5` - // "style" - // `text/css,*/*;q=0.1` - // TODO - - // 3. Append `Accept`/value to request’s header list. - request.headersList.append('accept', value) - } - - // 13. If request’s header list does not contain `Accept-Language`, then - // user agents should append `Accept-Language`/an appropriate value to - // request’s header list. - if (!request.headersList.contains('accept-language')) { - request.headersList.append('accept-language', '*') - } - - // 14. If request’s priority is null, then use request’s initiator and - // destination appropriately in setting request’s priority to a - // user-agent-defined object. - if (request.priority === null) { - // TODO - } - - // 15. If request is a subresource request, then: - if (subresourceSet.has(request.destination)) { - // TODO - } - - // 16. Run main fetch given fetchParams. - mainFetch(fetchParams) - .catch(err => { - fetchParams.controller.terminate(err) - }) - - // 17. Return fetchParam's controller - return fetchParams.controller -} - -// https://fetch.spec.whatwg.org/#concept-main-fetch -async function mainFetch (fetchParams, recursive = false) { - // 1. Let request be fetchParams’s request. - const request = fetchParams.request - - // 2. Let response be null. - let response = null - - // 3. If request’s local-URLs-only flag is set and request’s current URL is - // not local, then set response to a network error. - if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) { - response = makeNetworkError('local URLs only') - } - - // 4. Run report Content Security Policy violations for request. - // TODO - - // 5. Upgrade request to a potentially trustworthy URL, if appropriate. - tryUpgradeRequestToAPotentiallyTrustworthyURL(request) - - // 6. If should request be blocked due to a bad port, should fetching request - // be blocked as mixed content, or should request be blocked by Content - // Security Policy returns blocked, then set response to a network error. - if (requestBadPort(request) === 'blocked') { - response = makeNetworkError('bad port') - } - // TODO: should fetching request be blocked as mixed content? - // TODO: should request be blocked by Content Security Policy? - - // 7. If request’s referrer policy is the empty string, then set request’s - // referrer policy to request’s policy container’s referrer policy. - if (request.referrerPolicy === '') { - request.referrerPolicy = request.policyContainer.referrerPolicy - } - - // 8. If request’s referrer is not "no-referrer", then set request’s - // referrer to the result of invoking determine request’s referrer. - if (request.referrer !== 'no-referrer') { - request.referrer = determineRequestsReferrer(request) - } - - // 9. Set request’s current URL’s scheme to "https" if all of the following - // conditions are true: - // - request’s current URL’s scheme is "http" - // - request’s current URL’s host is a domain - // - Matching request’s current URL’s host per Known HSTS Host Domain Name - // Matching results in either a superdomain match with an asserted - // includeSubDomains directive or a congruent match (with or without an - // asserted includeSubDomains directive). [HSTS] - // TODO - - // 10. If recursive is false, then run the remaining steps in parallel. - // TODO - - // 11. If response is null, then set response to the result of running - // the steps corresponding to the first matching statement: - if (response === null) { - response = await (async () => { - const currentURL = requestCurrentURL(request) - - if ( - // - request’s current URL’s origin is same origin with request’s origin, - // and request’s response tainting is "basic" - (sameOrigin(currentURL, request.url) && request.responseTainting === 'basic') || - // request’s current URL’s scheme is "data" - (currentURL.protocol === 'data:') || - // - request’s mode is "navigate" or "websocket" - (request.mode === 'navigate' || request.mode === 'websocket') - ) { - // 1. Set request’s response tainting to "basic". - request.responseTainting = 'basic' - - // 2. Return the result of running scheme fetch given fetchParams. - return await schemeFetch(fetchParams) - } - - // request’s mode is "same-origin" - if (request.mode === 'same-origin') { - // 1. Return a network error. - return makeNetworkError('request mode cannot be "same-origin"') - } - - // request’s mode is "no-cors" - if (request.mode === 'no-cors') { - // 1. If request’s redirect mode is not "follow", then return a network - // error. - if (request.redirect !== 'follow') { - return makeNetworkError( - 'redirect mode cannot be "follow" for "no-cors" request' - ) - } - - // 2. Set request’s response tainting to "opaque". - request.responseTainting = 'opaque' - - // 3. Return the result of running scheme fetch given fetchParams. - return await schemeFetch(fetchParams) - } - - // request’s current URL’s scheme is not an HTTP(S) scheme - if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) { - // Return a network error. - return makeNetworkError('URL scheme must be a HTTP(S) scheme') - } - - // - request’s use-CORS-preflight flag is set - // - request’s unsafe-request flag is set and either request’s method is - // not a CORS-safelisted method or CORS-unsafe request-header names with - // request’s header list is not empty - // 1. Set request’s response tainting to "cors". - // 2. Let corsWithPreflightResponse be the result of running HTTP fetch - // given fetchParams and true. - // 3. If corsWithPreflightResponse is a network error, then clear cache - // entries using request. - // 4. Return corsWithPreflightResponse. - // TODO - - // Otherwise - // 1. Set request’s response tainting to "cors". - request.responseTainting = 'cors' - - // 2. Return the result of running HTTP fetch given fetchParams. - return await httpFetch(fetchParams) - })() - } - - // 12. If recursive is true, then return response. - if (recursive) { - return response - } - - // 13. If response is not a network error and response is not a filtered - // response, then: - if (response.status !== 0 && !response.internalResponse) { - // If request’s response tainting is "cors", then: - if (request.responseTainting === 'cors') { - // 1. Let headerNames be the result of extracting header list values - // given `Access-Control-Expose-Headers` and response’s header list. - // TODO - // 2. If request’s credentials mode is not "include" and headerNames - // contains `*`, then set response’s CORS-exposed header-name list to - // all unique header names in response’s header list. - // TODO - // 3. Otherwise, if headerNames is not null or failure, then set - // response’s CORS-exposed header-name list to headerNames. - // TODO - } - - // Set response to the following filtered response with response as its - // internal response, depending on request’s response tainting: - if (request.responseTainting === 'basic') { - response = filterResponse(response, 'basic') - } else if (request.responseTainting === 'cors') { - response = filterResponse(response, 'cors') - } else if (request.responseTainting === 'opaque') { - response = filterResponse(response, 'opaque') - } else { - assert(false) - } - } - - // 14. Let internalResponse be response, if response is a network error, - // and response’s internal response otherwise. - let internalResponse = - response.status === 0 ? response : response.internalResponse - - // 15. If internalResponse’s URL list is empty, then set it to a clone of - // request’s URL list. - if (internalResponse.urlList.length === 0) { - internalResponse.urlList.push(...request.urlList) - } - - // 16. If request’s timing allow failed flag is unset, then set - // internalResponse’s timing allow passed flag. - if (!request.timingAllowFailed) { - response.timingAllowPassed = true - } - - // 17. If response is not a network error and any of the following returns - // blocked - // - should internalResponse to request be blocked as mixed content - // - should internalResponse to request be blocked by Content Security Policy - // - should internalResponse to request be blocked due to its MIME type - // - should internalResponse to request be blocked due to nosniff - // TODO - - // 18. If response’s type is "opaque", internalResponse’s status is 206, - // internalResponse’s range-requested flag is set, and request’s header - // list does not contain `Range`, then set response and internalResponse - // to a network error. - if ( - response.type === 'opaque' && - internalResponse.status === 206 && - internalResponse.rangeRequested && - !request.headers.contains('range') - ) { - response = internalResponse = makeNetworkError() - } - - // 19. If response is not a network error and either request’s method is - // `HEAD` or `CONNECT`, or internalResponse’s status is a null body status, - // set internalResponse’s body to null and disregard any enqueuing toward - // it (if any). - if ( - response.status !== 0 && - (request.method === 'HEAD' || - request.method === 'CONNECT' || - nullBodyStatus.includes(internalResponse.status)) - ) { - internalResponse.body = null - fetchParams.controller.dump = true - } - - // 20. If request’s integrity metadata is not the empty string, then: - if (request.integrity) { - // 1. Let processBodyError be this step: run fetch finale given fetchParams - // and a network error. - const processBodyError = (reason) => - fetchFinale(fetchParams, makeNetworkError(reason)) - - // 2. If request’s response tainting is "opaque", or response’s body is null, - // then run processBodyError and abort these steps. - if (request.responseTainting === 'opaque' || response.body == null) { - processBodyError(response.error) - return - } - - // 3. Let processBody given bytes be these steps: - const processBody = (bytes) => { - // 1. If bytes do not match request’s integrity metadata, - // then run processBodyError and abort these steps. [SRI] - if (!bytesMatch(bytes, request.integrity)) { - processBodyError('integrity mismatch') - return - } - - // 2. Set response’s body to bytes as a body. - response.body = safelyExtractBody(bytes)[0] - - // 3. Run fetch finale given fetchParams and response. - fetchFinale(fetchParams, response) - } - - // 4. Fully read response’s body given processBody and processBodyError. - await fullyReadBody(response.body, processBody, processBodyError) - } else { - // 21. Otherwise, run fetch finale given fetchParams and response. - fetchFinale(fetchParams, response) - } -} - -// https://fetch.spec.whatwg.org/#concept-scheme-fetch -// given a fetch params fetchParams -function schemeFetch (fetchParams) { - // Note: since the connection is destroyed on redirect, which sets fetchParams to a - // cancelled state, we do not want this condition to trigger *unless* there have been - // no redirects. See https://github.com/nodejs/undici/issues/1776 - // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams. - if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) { - return Promise.resolve(makeAppropriateNetworkError(fetchParams)) - } - - // 2. Let request be fetchParams’s request. - const { request } = fetchParams - - const { protocol: scheme } = requestCurrentURL(request) - - // 3. Switch on request’s current URL’s scheme and run the associated steps: - switch (scheme) { - case 'about:': { - // If request’s current URL’s path is the string "blank", then return a new response - // whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) », - // and body is the empty byte sequence as a body. - - // Otherwise, return a network error. - return Promise.resolve(makeNetworkError('about scheme is not supported')) - } - case 'blob:': { - if (!resolveObjectURL) { - resolveObjectURL = (__nccwpck_require__(181).resolveObjectURL) - } - - // 1. Let blobURLEntry be request’s current URL’s blob URL entry. - const blobURLEntry = requestCurrentURL(request) - - // https://github.com/web-platform-tests/wpt/blob/7b0ebaccc62b566a1965396e5be7bb2bc06f841f/FileAPI/url/resources/fetch-tests.js#L52-L56 - // Buffer.resolveObjectURL does not ignore URL queries. - if (blobURLEntry.search.length !== 0) { - return Promise.resolve(makeNetworkError('NetworkError when attempting to fetch resource.')) - } - - const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString()) - - // 2. If request’s method is not `GET`, blobURLEntry is null, or blobURLEntry’s - // object is not a Blob object, then return a network error. - if (request.method !== 'GET' || !isBlobLike(blobURLEntryObject)) { - return Promise.resolve(makeNetworkError('invalid method')) - } - - // 3. Let bodyWithType be the result of safely extracting blobURLEntry’s object. - const bodyWithType = safelyExtractBody(blobURLEntryObject) - - // 4. Let body be bodyWithType’s body. - const body = bodyWithType[0] - - // 5. Let length be body’s length, serialized and isomorphic encoded. - const length = isomorphicEncode(`${body.length}`) - - // 6. Let type be bodyWithType’s type if it is non-null; otherwise the empty byte sequence. - const type = bodyWithType[1] ?? '' - - // 7. Return a new response whose status message is `OK`, header list is - // « (`Content-Length`, length), (`Content-Type`, type) », and body is body. - const response = makeResponse({ - statusText: 'OK', - headersList: [ - ['content-length', { name: 'Content-Length', value: length }], - ['content-type', { name: 'Content-Type', value: type }] - ] - }) - - response.body = body - - return Promise.resolve(response) - } - case 'data:': { - // 1. Let dataURLStruct be the result of running the - // data: URL processor on request’s current URL. - const currentURL = requestCurrentURL(request) - const dataURLStruct = dataURLProcessor(currentURL) - - // 2. If dataURLStruct is failure, then return a - // network error. - if (dataURLStruct === 'failure') { - return Promise.resolve(makeNetworkError('failed to fetch the data URL')) - } - - // 3. Let mimeType be dataURLStruct’s MIME type, serialized. - const mimeType = serializeAMimeType(dataURLStruct.mimeType) - - // 4. Return a response whose status message is `OK`, - // header list is « (`Content-Type`, mimeType) », - // and body is dataURLStruct’s body as a body. - return Promise.resolve(makeResponse({ - statusText: 'OK', - headersList: [ - ['content-type', { name: 'Content-Type', value: mimeType }] - ], - body: safelyExtractBody(dataURLStruct.body)[0] - })) - } - case 'file:': { - // For now, unfortunate as it is, file URLs are left as an exercise for the reader. - // When in doubt, return a network error. - return Promise.resolve(makeNetworkError('not implemented... yet...')) - } - case 'http:': - case 'https:': { - // Return the result of running HTTP fetch given fetchParams. - - return httpFetch(fetchParams) - .catch((err) => makeNetworkError(err)) - } - default: { - return Promise.resolve(makeNetworkError('unknown scheme')) - } - } -} - -// https://fetch.spec.whatwg.org/#finalize-response -function finalizeResponse (fetchParams, response) { - // 1. Set fetchParams’s request’s done flag. - fetchParams.request.done = true - - // 2, If fetchParams’s process response done is not null, then queue a fetch - // task to run fetchParams’s process response done given response, with - // fetchParams’s task destination. - if (fetchParams.processResponseDone != null) { - queueMicrotask(() => fetchParams.processResponseDone(response)) - } -} - -// https://fetch.spec.whatwg.org/#fetch-finale -function fetchFinale (fetchParams, response) { - // 1. If response is a network error, then: - if (response.type === 'error') { - // 1. Set response’s URL list to « fetchParams’s request’s URL list[0] ». - response.urlList = [fetchParams.request.urlList[0]] - - // 2. Set response’s timing info to the result of creating an opaque timing - // info for fetchParams’s timing info. - response.timingInfo = createOpaqueTimingInfo({ - startTime: fetchParams.timingInfo.startTime - }) - } - - // 2. Let processResponseEndOfBody be the following steps: - const processResponseEndOfBody = () => { - // 1. Set fetchParams’s request’s done flag. - fetchParams.request.done = true - - // If fetchParams’s process response end-of-body is not null, - // then queue a fetch task to run fetchParams’s process response - // end-of-body given response with fetchParams’s task destination. - if (fetchParams.processResponseEndOfBody != null) { - queueMicrotask(() => fetchParams.processResponseEndOfBody(response)) - } - } - - // 3. If fetchParams’s process response is non-null, then queue a fetch task - // to run fetchParams’s process response given response, with fetchParams’s - // task destination. - if (fetchParams.processResponse != null) { - queueMicrotask(() => fetchParams.processResponse(response)) - } - - // 4. If response’s body is null, then run processResponseEndOfBody. - if (response.body == null) { - processResponseEndOfBody() - } else { - // 5. Otherwise: - - // 1. Let transformStream be a new a TransformStream. - - // 2. Let identityTransformAlgorithm be an algorithm which, given chunk, - // enqueues chunk in transformStream. - const identityTransformAlgorithm = (chunk, controller) => { - controller.enqueue(chunk) - } - - // 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm - // and flushAlgorithm set to processResponseEndOfBody. - const transformStream = new TransformStream({ - start () {}, - transform: identityTransformAlgorithm, - flush: processResponseEndOfBody - }, { - size () { - return 1 - } - }, { - size () { - return 1 - } - }) - - // 4. Set response’s body to the result of piping response’s body through transformStream. - response.body = { stream: response.body.stream.pipeThrough(transformStream) } - } - - // 6. If fetchParams’s process response consume body is non-null, then: - if (fetchParams.processResponseConsumeBody != null) { - // 1. Let processBody given nullOrBytes be this step: run fetchParams’s - // process response consume body given response and nullOrBytes. - const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes) - - // 2. Let processBodyError be this step: run fetchParams’s process - // response consume body given response and failure. - const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure) - - // 3. If response’s body is null, then queue a fetch task to run processBody - // given null, with fetchParams’s task destination. - if (response.body == null) { - queueMicrotask(() => processBody(null)) - } else { - // 4. Otherwise, fully read response’s body given processBody, processBodyError, - // and fetchParams’s task destination. - return fullyReadBody(response.body, processBody, processBodyError) - } - return Promise.resolve() - } -} - -// https://fetch.spec.whatwg.org/#http-fetch -async function httpFetch (fetchParams) { - // 1. Let request be fetchParams’s request. - const request = fetchParams.request - - // 2. Let response be null. - let response = null - - // 3. Let actualResponse be null. - let actualResponse = null - - // 4. Let timingInfo be fetchParams’s timing info. - const timingInfo = fetchParams.timingInfo - - // 5. If request’s service-workers mode is "all", then: - if (request.serviceWorkers === 'all') { - // TODO - } - - // 6. If response is null, then: - if (response === null) { - // 1. If makeCORSPreflight is true and one of these conditions is true: - // TODO - - // 2. If request’s redirect mode is "follow", then set request’s - // service-workers mode to "none". - if (request.redirect === 'follow') { - request.serviceWorkers = 'none' - } - - // 3. Set response and actualResponse to the result of running - // HTTP-network-or-cache fetch given fetchParams. - actualResponse = response = await httpNetworkOrCacheFetch(fetchParams) - - // 4. If request’s response tainting is "cors" and a CORS check - // for request and response returns failure, then return a network error. - if ( - request.responseTainting === 'cors' && - corsCheck(request, response) === 'failure' - ) { - return makeNetworkError('cors failure') - } - - // 5. If the TAO check for request and response returns failure, then set - // request’s timing allow failed flag. - if (TAOCheck(request, response) === 'failure') { - request.timingAllowFailed = true - } - } - - // 7. If either request’s response tainting or response’s type - // is "opaque", and the cross-origin resource policy check with - // request’s origin, request’s client, request’s destination, - // and actualResponse returns blocked, then return a network error. - if ( - (request.responseTainting === 'opaque' || response.type === 'opaque') && - crossOriginResourcePolicyCheck( - request.origin, - request.client, - request.destination, - actualResponse - ) === 'blocked' - ) { - return makeNetworkError('blocked') - } - - // 8. If actualResponse’s status is a redirect status, then: - if (redirectStatusSet.has(actualResponse.status)) { - // 1. If actualResponse’s status is not 303, request’s body is not null, - // and the connection uses HTTP/2, then user agents may, and are even - // encouraged to, transmit an RST_STREAM frame. - // See, https://github.com/whatwg/fetch/issues/1288 - if (request.redirect !== 'manual') { - fetchParams.controller.connection.destroy() - } - - // 2. Switch on request’s redirect mode: - if (request.redirect === 'error') { - // Set response to a network error. - response = makeNetworkError('unexpected redirect') - } else if (request.redirect === 'manual') { - // Set response to an opaque-redirect filtered response whose internal - // response is actualResponse. - // NOTE(spec): On the web this would return an `opaqueredirect` response, - // but that doesn't make sense server side. - // See https://github.com/nodejs/undici/issues/1193. - response = actualResponse - } else if (request.redirect === 'follow') { - // Set response to the result of running HTTP-redirect fetch given - // fetchParams and response. - response = await httpRedirectFetch(fetchParams, response) - } else { - assert(false) - } - } - - // 9. Set response’s timing info to timingInfo. - response.timingInfo = timingInfo - - // 10. Return response. - return response -} - -// https://fetch.spec.whatwg.org/#http-redirect-fetch -function httpRedirectFetch (fetchParams, response) { - // 1. Let request be fetchParams’s request. - const request = fetchParams.request - - // 2. Let actualResponse be response, if response is not a filtered response, - // and response’s internal response otherwise. - const actualResponse = response.internalResponse - ? response.internalResponse - : response - - // 3. Let locationURL be actualResponse’s location URL given request’s current - // URL’s fragment. - let locationURL - - try { - locationURL = responseLocationURL( - actualResponse, - requestCurrentURL(request).hash - ) - - // 4. If locationURL is null, then return response. - if (locationURL == null) { - return response - } - } catch (err) { - // 5. If locationURL is failure, then return a network error. - return Promise.resolve(makeNetworkError(err)) - } - - // 6. If locationURL’s scheme is not an HTTP(S) scheme, then return a network - // error. - if (!urlIsHttpHttpsScheme(locationURL)) { - return Promise.resolve(makeNetworkError('URL scheme must be a HTTP(S) scheme')) - } - - // 7. If request’s redirect count is 20, then return a network error. - if (request.redirectCount === 20) { - return Promise.resolve(makeNetworkError('redirect count exceeded')) - } - - // 8. Increase request’s redirect count by 1. - request.redirectCount += 1 - - // 9. If request’s mode is "cors", locationURL includes credentials, and - // request’s origin is not same origin with locationURL’s origin, then return - // a network error. - if ( - request.mode === 'cors' && - (locationURL.username || locationURL.password) && - !sameOrigin(request, locationURL) - ) { - return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"')) - } - - // 10. If request’s response tainting is "cors" and locationURL includes - // credentials, then return a network error. - if ( - request.responseTainting === 'cors' && - (locationURL.username || locationURL.password) - ) { - return Promise.resolve(makeNetworkError( - 'URL cannot contain credentials for request mode "cors"' - )) - } - - // 11. If actualResponse’s status is not 303, request’s body is non-null, - // and request’s body’s source is null, then return a network error. - if ( - actualResponse.status !== 303 && - request.body != null && - request.body.source == null - ) { - return Promise.resolve(makeNetworkError()) - } - - // 12. If one of the following is true - // - actualResponse’s status is 301 or 302 and request’s method is `POST` - // - actualResponse’s status is 303 and request’s method is not `GET` or `HEAD` - if ( - ([301, 302].includes(actualResponse.status) && request.method === 'POST') || - (actualResponse.status === 303 && - !GET_OR_HEAD.includes(request.method)) - ) { - // then: - // 1. Set request’s method to `GET` and request’s body to null. - request.method = 'GET' - request.body = null - - // 2. For each headerName of request-body-header name, delete headerName from - // request’s header list. - for (const headerName of requestBodyHeader) { - request.headersList.delete(headerName) - } - } - - // 13. If request’s current URL’s origin is not same origin with locationURL’s - // origin, then for each headerName of CORS non-wildcard request-header name, - // delete headerName from request’s header list. - if (!sameOrigin(requestCurrentURL(request), locationURL)) { - // https://fetch.spec.whatwg.org/#cors-non-wildcard-request-header-name - request.headersList.delete('authorization') - - // https://fetch.spec.whatwg.org/#authentication-entries - request.headersList.delete('proxy-authorization', true) - - // "Cookie" and "Host" are forbidden request-headers, which undici doesn't implement. - request.headersList.delete('cookie') - request.headersList.delete('host') - } - - // 14. If request’s body is non-null, then set request’s body to the first return - // value of safely extracting request’s body’s source. - if (request.body != null) { - assert(request.body.source != null) - request.body = safelyExtractBody(request.body.source)[0] - } - - // 15. Let timingInfo be fetchParams’s timing info. - const timingInfo = fetchParams.timingInfo - - // 16. Set timingInfo’s redirect end time and post-redirect start time to the - // coarsened shared current time given fetchParams’s cross-origin isolated - // capability. - timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = - coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability) - - // 17. If timingInfo’s redirect start time is 0, then set timingInfo’s - // redirect start time to timingInfo’s start time. - if (timingInfo.redirectStartTime === 0) { - timingInfo.redirectStartTime = timingInfo.startTime - } - - // 18. Append locationURL to request’s URL list. - request.urlList.push(locationURL) - - // 19. Invoke set request’s referrer policy on redirect on request and - // actualResponse. - setRequestReferrerPolicyOnRedirect(request, actualResponse) - - // 20. Return the result of running main fetch given fetchParams and true. - return mainFetch(fetchParams, true) -} - -// https://fetch.spec.whatwg.org/#http-network-or-cache-fetch -async function httpNetworkOrCacheFetch ( - fetchParams, - isAuthenticationFetch = false, - isNewConnectionFetch = false -) { - // 1. Let request be fetchParams’s request. - const request = fetchParams.request - - // 2. Let httpFetchParams be null. - let httpFetchParams = null - - // 3. Let httpRequest be null. - let httpRequest = null - - // 4. Let response be null. - let response = null - - // 5. Let storedResponse be null. - // TODO: cache - - // 6. Let httpCache be null. - const httpCache = null - - // 7. Let the revalidatingFlag be unset. - const revalidatingFlag = false - - // 8. Run these steps, but abort when the ongoing fetch is terminated: - - // 1. If request’s window is "no-window" and request’s redirect mode is - // "error", then set httpFetchParams to fetchParams and httpRequest to - // request. - if (request.window === 'no-window' && request.redirect === 'error') { - httpFetchParams = fetchParams - httpRequest = request - } else { - // Otherwise: - - // 1. Set httpRequest to a clone of request. - httpRequest = makeRequest(request) - - // 2. Set httpFetchParams to a copy of fetchParams. - httpFetchParams = { ...fetchParams } - - // 3. Set httpFetchParams’s request to httpRequest. - httpFetchParams.request = httpRequest - } - - // 3. Let includeCredentials be true if one of - const includeCredentials = - request.credentials === 'include' || - (request.credentials === 'same-origin' && - request.responseTainting === 'basic') - - // 4. Let contentLength be httpRequest’s body’s length, if httpRequest’s - // body is non-null; otherwise null. - const contentLength = httpRequest.body ? httpRequest.body.length : null - - // 5. Let contentLengthHeaderValue be null. - let contentLengthHeaderValue = null - - // 6. If httpRequest’s body is null and httpRequest’s method is `POST` or - // `PUT`, then set contentLengthHeaderValue to `0`. - if ( - httpRequest.body == null && - ['POST', 'PUT'].includes(httpRequest.method) - ) { - contentLengthHeaderValue = '0' - } - - // 7. If contentLength is non-null, then set contentLengthHeaderValue to - // contentLength, serialized and isomorphic encoded. - if (contentLength != null) { - contentLengthHeaderValue = isomorphicEncode(`${contentLength}`) - } - - // 8. If contentLengthHeaderValue is non-null, then append - // `Content-Length`/contentLengthHeaderValue to httpRequest’s header - // list. - if (contentLengthHeaderValue != null) { - httpRequest.headersList.append('content-length', contentLengthHeaderValue) - } - - // 9. If contentLengthHeaderValue is non-null, then append (`Content-Length`, - // contentLengthHeaderValue) to httpRequest’s header list. - - // 10. If contentLength is non-null and httpRequest’s keepalive is true, - // then: - if (contentLength != null && httpRequest.keepalive) { - // NOTE: keepalive is a noop outside of browser context. - } - - // 11. If httpRequest’s referrer is a URL, then append - // `Referer`/httpRequest’s referrer, serialized and isomorphic encoded, - // to httpRequest’s header list. - if (httpRequest.referrer instanceof URL) { - httpRequest.headersList.append('referer', isomorphicEncode(httpRequest.referrer.href)) - } - - // 12. Append a request `Origin` header for httpRequest. - appendRequestOriginHeader(httpRequest) - - // 13. Append the Fetch metadata headers for httpRequest. [FETCH-METADATA] - appendFetchMetadata(httpRequest) - - // 14. If httpRequest’s header list does not contain `User-Agent`, then - // user agents should append `User-Agent`/default `User-Agent` value to - // httpRequest’s header list. - if (!httpRequest.headersList.contains('user-agent')) { - httpRequest.headersList.append('user-agent', typeof esbuildDetection === 'undefined' ? 'undici' : 'node') - } - - // 15. If httpRequest’s cache mode is "default" and httpRequest’s header - // list contains `If-Modified-Since`, `If-None-Match`, - // `If-Unmodified-Since`, `If-Match`, or `If-Range`, then set - // httpRequest’s cache mode to "no-store". - if ( - httpRequest.cache === 'default' && - (httpRequest.headersList.contains('if-modified-since') || - httpRequest.headersList.contains('if-none-match') || - httpRequest.headersList.contains('if-unmodified-since') || - httpRequest.headersList.contains('if-match') || - httpRequest.headersList.contains('if-range')) - ) { - httpRequest.cache = 'no-store' - } - - // 16. If httpRequest’s cache mode is "no-cache", httpRequest’s prevent - // no-cache cache-control header modification flag is unset, and - // httpRequest’s header list does not contain `Cache-Control`, then append - // `Cache-Control`/`max-age=0` to httpRequest’s header list. - if ( - httpRequest.cache === 'no-cache' && - !httpRequest.preventNoCacheCacheControlHeaderModification && - !httpRequest.headersList.contains('cache-control') - ) { - httpRequest.headersList.append('cache-control', 'max-age=0') - } - - // 17. If httpRequest’s cache mode is "no-store" or "reload", then: - if (httpRequest.cache === 'no-store' || httpRequest.cache === 'reload') { - // 1. If httpRequest’s header list does not contain `Pragma`, then append - // `Pragma`/`no-cache` to httpRequest’s header list. - if (!httpRequest.headersList.contains('pragma')) { - httpRequest.headersList.append('pragma', 'no-cache') - } - - // 2. If httpRequest’s header list does not contain `Cache-Control`, - // then append `Cache-Control`/`no-cache` to httpRequest’s header list. - if (!httpRequest.headersList.contains('cache-control')) { - httpRequest.headersList.append('cache-control', 'no-cache') - } - } - - // 18. If httpRequest’s header list contains `Range`, then append - // `Accept-Encoding`/`identity` to httpRequest’s header list. - if (httpRequest.headersList.contains('range')) { - httpRequest.headersList.append('accept-encoding', 'identity') - } - - // 19. Modify httpRequest’s header list per HTTP. Do not append a given - // header if httpRequest’s header list contains that header’s name. - // TODO: https://github.com/whatwg/fetch/issues/1285#issuecomment-896560129 - if (!httpRequest.headersList.contains('accept-encoding')) { - if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) { - httpRequest.headersList.append('accept-encoding', 'br, gzip, deflate') - } else { - httpRequest.headersList.append('accept-encoding', 'gzip, deflate') - } - } - - httpRequest.headersList.delete('host') - - // 20. If includeCredentials is true, then: - if (includeCredentials) { - // 1. If the user agent is not configured to block cookies for httpRequest - // (see section 7 of [COOKIES]), then: - // TODO: credentials - // 2. If httpRequest’s header list does not contain `Authorization`, then: - // TODO: credentials - } - - // 21. If there’s a proxy-authentication entry, use it as appropriate. - // TODO: proxy-authentication - - // 22. Set httpCache to the result of determining the HTTP cache - // partition, given httpRequest. - // TODO: cache - - // 23. If httpCache is null, then set httpRequest’s cache mode to - // "no-store". - if (httpCache == null) { - httpRequest.cache = 'no-store' - } - - // 24. If httpRequest’s cache mode is neither "no-store" nor "reload", - // then: - if (httpRequest.mode !== 'no-store' && httpRequest.mode !== 'reload') { - // TODO: cache - } - - // 9. If aborted, then return the appropriate network error for fetchParams. - // TODO - - // 10. If response is null, then: - if (response == null) { - // 1. If httpRequest’s cache mode is "only-if-cached", then return a - // network error. - if (httpRequest.mode === 'only-if-cached') { - return makeNetworkError('only if cached') - } - - // 2. Let forwardResponse be the result of running HTTP-network fetch - // given httpFetchParams, includeCredentials, and isNewConnectionFetch. - const forwardResponse = await httpNetworkFetch( - httpFetchParams, - includeCredentials, - isNewConnectionFetch - ) - - // 3. If httpRequest’s method is unsafe and forwardResponse’s status is - // in the range 200 to 399, inclusive, invalidate appropriate stored - // responses in httpCache, as per the "Invalidation" chapter of HTTP - // Caching, and set storedResponse to null. [HTTP-CACHING] - if ( - !safeMethodsSet.has(httpRequest.method) && - forwardResponse.status >= 200 && - forwardResponse.status <= 399 - ) { - // TODO: cache - } - - // 4. If the revalidatingFlag is set and forwardResponse’s status is 304, - // then: - if (revalidatingFlag && forwardResponse.status === 304) { - // TODO: cache - } - - // 5. If response is null, then: - if (response == null) { - // 1. Set response to forwardResponse. - response = forwardResponse - - // 2. Store httpRequest and forwardResponse in httpCache, as per the - // "Storing Responses in Caches" chapter of HTTP Caching. [HTTP-CACHING] - // TODO: cache - } - } - - // 11. Set response’s URL list to a clone of httpRequest’s URL list. - response.urlList = [...httpRequest.urlList] - - // 12. If httpRequest’s header list contains `Range`, then set response’s - // range-requested flag. - if (httpRequest.headersList.contains('range')) { - response.rangeRequested = true - } - - // 13. Set response’s request-includes-credentials to includeCredentials. - response.requestIncludesCredentials = includeCredentials - - // 14. If response’s status is 401, httpRequest’s response tainting is not - // "cors", includeCredentials is true, and request’s window is an environment - // settings object, then: - // TODO - - // 15. If response’s status is 407, then: - if (response.status === 407) { - // 1. If request’s window is "no-window", then return a network error. - if (request.window === 'no-window') { - return makeNetworkError() - } - - // 2. ??? - - // 3. If fetchParams is canceled, then return the appropriate network error for fetchParams. - if (isCancelled(fetchParams)) { - return makeAppropriateNetworkError(fetchParams) - } - - // 4. Prompt the end user as appropriate in request’s window and store - // the result as a proxy-authentication entry. [HTTP-AUTH] - // TODO: Invoke some kind of callback? - - // 5. Set response to the result of running HTTP-network-or-cache fetch given - // fetchParams. - // TODO - return makeNetworkError('proxy authentication required') - } - - // 16. If all of the following are true - if ( - // response’s status is 421 - response.status === 421 && - // isNewConnectionFetch is false - !isNewConnectionFetch && - // request’s body is null, or request’s body is non-null and request’s body’s source is non-null - (request.body == null || request.body.source != null) - ) { - // then: - - // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams. - if (isCancelled(fetchParams)) { - return makeAppropriateNetworkError(fetchParams) - } - - // 2. Set response to the result of running HTTP-network-or-cache - // fetch given fetchParams, isAuthenticationFetch, and true. - - // TODO (spec): The spec doesn't specify this but we need to cancel - // the active response before we can start a new one. - // https://github.com/whatwg/fetch/issues/1293 - fetchParams.controller.connection.destroy() - - response = await httpNetworkOrCacheFetch( - fetchParams, - isAuthenticationFetch, - true - ) - } - - // 17. If isAuthenticationFetch is true, then create an authentication entry - if (isAuthenticationFetch) { - // TODO - } - - // 18. Return response. - return response -} - -// https://fetch.spec.whatwg.org/#http-network-fetch -async function httpNetworkFetch ( - fetchParams, - includeCredentials = false, - forceNewConnection = false -) { - assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed) - - fetchParams.controller.connection = { - abort: null, - destroyed: false, - destroy (err) { - if (!this.destroyed) { - this.destroyed = true - this.abort?.(err ?? new DOMException('The operation was aborted.', 'AbortError')) - } - } - } - - // 1. Let request be fetchParams’s request. - const request = fetchParams.request - - // 2. Let response be null. - let response = null - - // 3. Let timingInfo be fetchParams’s timing info. - const timingInfo = fetchParams.timingInfo - - // 4. Let httpCache be the result of determining the HTTP cache partition, - // given request. - // TODO: cache - const httpCache = null - - // 5. If httpCache is null, then set request’s cache mode to "no-store". - if (httpCache == null) { - request.cache = 'no-store' - } - - // 6. Let networkPartitionKey be the result of determining the network - // partition key given request. - // TODO - - // 7. Let newConnection be "yes" if forceNewConnection is true; otherwise - // "no". - const newConnection = forceNewConnection ? 'yes' : 'no' // eslint-disable-line no-unused-vars - - // 8. Switch on request’s mode: - if (request.mode === 'websocket') { - // Let connection be the result of obtaining a WebSocket connection, - // given request’s current URL. - // TODO - } else { - // Let connection be the result of obtaining a connection, given - // networkPartitionKey, request’s current URL’s origin, - // includeCredentials, and forceNewConnection. - // TODO - } - - // 9. Run these steps, but abort when the ongoing fetch is terminated: - - // 1. If connection is failure, then return a network error. - - // 2. Set timingInfo’s final connection timing info to the result of - // calling clamp and coarsen connection timing info with connection’s - // timing info, timingInfo’s post-redirect start time, and fetchParams’s - // cross-origin isolated capability. - - // 3. If connection is not an HTTP/2 connection, request’s body is non-null, - // and request’s body’s source is null, then append (`Transfer-Encoding`, - // `chunked`) to request’s header list. - - // 4. Set timingInfo’s final network-request start time to the coarsened - // shared current time given fetchParams’s cross-origin isolated - // capability. - - // 5. Set response to the result of making an HTTP request over connection - // using request with the following caveats: - - // - Follow the relevant requirements from HTTP. [HTTP] [HTTP-SEMANTICS] - // [HTTP-COND] [HTTP-CACHING] [HTTP-AUTH] - - // - If request’s body is non-null, and request’s body’s source is null, - // then the user agent may have a buffer of up to 64 kibibytes and store - // a part of request’s body in that buffer. If the user agent reads from - // request’s body beyond that buffer’s size and the user agent needs to - // resend request, then instead return a network error. - - // - Set timingInfo’s final network-response start time to the coarsened - // shared current time given fetchParams’s cross-origin isolated capability, - // immediately after the user agent’s HTTP parser receives the first byte - // of the response (e.g., frame header bytes for HTTP/2 or response status - // line for HTTP/1.x). - - // - Wait until all the headers are transmitted. - - // - Any responses whose status is in the range 100 to 199, inclusive, - // and is not 101, are to be ignored, except for the purposes of setting - // timingInfo’s final network-response start time above. - - // - If request’s header list contains `Transfer-Encoding`/`chunked` and - // response is transferred via HTTP/1.0 or older, then return a network - // error. - - // - If the HTTP request results in a TLS client certificate dialog, then: - - // 1. If request’s window is an environment settings object, make the - // dialog available in request’s window. - - // 2. Otherwise, return a network error. - - // To transmit request’s body body, run these steps: - let requestBody = null - // 1. If body is null and fetchParams’s process request end-of-body is - // non-null, then queue a fetch task given fetchParams’s process request - // end-of-body and fetchParams’s task destination. - if (request.body == null && fetchParams.processRequestEndOfBody) { - queueMicrotask(() => fetchParams.processRequestEndOfBody()) - } else if (request.body != null) { - // 2. Otherwise, if body is non-null: - - // 1. Let processBodyChunk given bytes be these steps: - const processBodyChunk = async function * (bytes) { - // 1. If the ongoing fetch is terminated, then abort these steps. - if (isCancelled(fetchParams)) { - return - } - - // 2. Run this step in parallel: transmit bytes. - yield bytes - - // 3. If fetchParams’s process request body is non-null, then run - // fetchParams’s process request body given bytes’s length. - fetchParams.processRequestBodyChunkLength?.(bytes.byteLength) - } - - // 2. Let processEndOfBody be these steps: - const processEndOfBody = () => { - // 1. If fetchParams is canceled, then abort these steps. - if (isCancelled(fetchParams)) { - return - } - - // 2. If fetchParams’s process request end-of-body is non-null, - // then run fetchParams’s process request end-of-body. - if (fetchParams.processRequestEndOfBody) { - fetchParams.processRequestEndOfBody() - } - } - - // 3. Let processBodyError given e be these steps: - const processBodyError = (e) => { - // 1. If fetchParams is canceled, then abort these steps. - if (isCancelled(fetchParams)) { - return - } - - // 2. If e is an "AbortError" DOMException, then abort fetchParams’s controller. - if (e.name === 'AbortError') { - fetchParams.controller.abort() - } else { - fetchParams.controller.terminate(e) - } - } - - // 4. Incrementally read request’s body given processBodyChunk, processEndOfBody, - // processBodyError, and fetchParams’s task destination. - requestBody = (async function * () { - try { - for await (const bytes of request.body.stream) { - yield * processBodyChunk(bytes) - } - processEndOfBody() - } catch (err) { - processBodyError(err) - } - })() - } - - try { - // socket is only provided for websockets - const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody }) - - if (socket) { - response = makeResponse({ status, statusText, headersList, socket }) - } else { - const iterator = body[Symbol.asyncIterator]() - fetchParams.controller.next = () => iterator.next() - - response = makeResponse({ status, statusText, headersList }) - } - } catch (err) { - // 10. If aborted, then: - if (err.name === 'AbortError') { - // 1. If connection uses HTTP/2, then transmit an RST_STREAM frame. - fetchParams.controller.connection.destroy() - - // 2. Return the appropriate network error for fetchParams. - return makeAppropriateNetworkError(fetchParams, err) - } - - return makeNetworkError(err) - } - - // 11. Let pullAlgorithm be an action that resumes the ongoing fetch - // if it is suspended. - const pullAlgorithm = () => { - fetchParams.controller.resume() - } - - // 12. Let cancelAlgorithm be an algorithm that aborts fetchParams’s - // controller with reason, given reason. - const cancelAlgorithm = (reason) => { - fetchParams.controller.abort(reason) - } - - // 13. Let highWaterMark be a non-negative, non-NaN number, chosen by - // the user agent. - // TODO - - // 14. Let sizeAlgorithm be an algorithm that accepts a chunk object - // and returns a non-negative, non-NaN, non-infinite number, chosen by the user agent. - // TODO - - // 15. Let stream be a new ReadableStream. - // 16. Set up stream with pullAlgorithm set to pullAlgorithm, - // cancelAlgorithm set to cancelAlgorithm, highWaterMark set to - // highWaterMark, and sizeAlgorithm set to sizeAlgorithm. - if (!ReadableStream) { - ReadableStream = (__nccwpck_require__(3774).ReadableStream) - } - - const stream = new ReadableStream( - { - async start (controller) { - fetchParams.controller.controller = controller - }, - async pull (controller) { - await pullAlgorithm(controller) - }, - async cancel (reason) { - await cancelAlgorithm(reason) - } - }, - { - highWaterMark: 0, - size () { - return 1 - } - } - ) - - // 17. Run these steps, but abort when the ongoing fetch is terminated: - - // 1. Set response’s body to a new body whose stream is stream. - response.body = { stream } - - // 2. If response is not a network error and request’s cache mode is - // not "no-store", then update response in httpCache for request. - // TODO - - // 3. If includeCredentials is true and the user agent is not configured - // to block cookies for request (see section 7 of [COOKIES]), then run the - // "set-cookie-string" parsing algorithm (see section 5.2 of [COOKIES]) on - // the value of each header whose name is a byte-case-insensitive match for - // `Set-Cookie` in response’s header list, if any, and request’s current URL. - // TODO - - // 18. If aborted, then: - // TODO - - // 19. Run these steps in parallel: - - // 1. Run these steps, but abort when fetchParams is canceled: - fetchParams.controller.on('terminated', onAborted) - fetchParams.controller.resume = async () => { - // 1. While true - while (true) { - // 1-3. See onData... - - // 4. Set bytes to the result of handling content codings given - // codings and bytes. - let bytes - let isFailure - try { - const { done, value } = await fetchParams.controller.next() - - if (isAborted(fetchParams)) { - break - } - - bytes = done ? undefined : value - } catch (err) { - if (fetchParams.controller.ended && !timingInfo.encodedBodySize) { - // zlib doesn't like empty streams. - bytes = undefined - } else { - bytes = err - - // err may be propagated from the result of calling readablestream.cancel, - // which might not be an error. https://github.com/nodejs/undici/issues/2009 - isFailure = true - } - } - - if (bytes === undefined) { - // 2. Otherwise, if the bytes transmission for response’s message - // body is done normally and stream is readable, then close - // stream, finalize response for fetchParams and response, and - // abort these in-parallel steps. - readableStreamClose(fetchParams.controller.controller) - - finalizeResponse(fetchParams, response) - - return - } - - // 5. Increase timingInfo’s decoded body size by bytes’s length. - timingInfo.decodedBodySize += bytes?.byteLength ?? 0 - - // 6. If bytes is failure, then terminate fetchParams’s controller. - if (isFailure) { - fetchParams.controller.terminate(bytes) - return - } - - // 7. Enqueue a Uint8Array wrapping an ArrayBuffer containing bytes - // into stream. - fetchParams.controller.controller.enqueue(new Uint8Array(bytes)) - - // 8. If stream is errored, then terminate the ongoing fetch. - if (isErrored(stream)) { - fetchParams.controller.terminate() - return - } - - // 9. If stream doesn’t need more data ask the user agent to suspend - // the ongoing fetch. - if (!fetchParams.controller.controller.desiredSize) { - return - } - } - } - - // 2. If aborted, then: - function onAborted (reason) { - // 2. If fetchParams is aborted, then: - if (isAborted(fetchParams)) { - // 1. Set response’s aborted flag. - response.aborted = true - - // 2. If stream is readable, then error stream with the result of - // deserialize a serialized abort reason given fetchParams’s - // controller’s serialized abort reason and an - // implementation-defined realm. - if (isReadable(stream)) { - fetchParams.controller.controller.error( - fetchParams.controller.serializedAbortReason - ) - } - } else { - // 3. Otherwise, if stream is readable, error stream with a TypeError. - if (isReadable(stream)) { - fetchParams.controller.controller.error(new TypeError('terminated', { - cause: isErrorLike(reason) ? reason : undefined - })) - } - } - - // 4. If connection uses HTTP/2, then transmit an RST_STREAM frame. - // 5. Otherwise, the user agent should close connection unless it would be bad for performance to do so. - fetchParams.controller.connection.destroy() - } - - // 20. Return response. - return response - - async function dispatch ({ body }) { - const url = requestCurrentURL(request) - /** @type {import('../..').Agent} */ - const agent = fetchParams.controller.dispatcher - - return new Promise((resolve, reject) => agent.dispatch( - { - path: url.pathname + url.search, - origin: url.origin, - method: request.method, - body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body, - headers: request.headersList.entries, - maxRedirections: 0, - upgrade: request.mode === 'websocket' ? 'websocket' : undefined - }, - { - body: null, - abort: null, - - onConnect (abort) { - // TODO (fix): Do we need connection here? - const { connection } = fetchParams.controller - - if (connection.destroyed) { - abort(new DOMException('The operation was aborted.', 'AbortError')) - } else { - fetchParams.controller.on('terminated', abort) - this.abort = connection.abort = abort - } - }, - - onHeaders (status, headersList, resume, statusText) { - if (status < 200) { - return - } - - let codings = [] - let location = '' - - const headers = new Headers() - - // For H2, the headers are a plain JS object - // We distinguish between them and iterate accordingly - if (Array.isArray(headersList)) { - for (let n = 0; n < headersList.length; n += 2) { - const key = headersList[n + 0].toString('latin1') - const val = headersList[n + 1].toString('latin1') - if (key.toLowerCase() === 'content-encoding') { - // https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1 - // "All content-coding values are case-insensitive..." - codings = val.toLowerCase().split(',').map((x) => x.trim()) - } else if (key.toLowerCase() === 'location') { - location = val - } - - headers[kHeadersList].append(key, val) - } - } else { - const keys = Object.keys(headersList) - for (const key of keys) { - const val = headersList[key] - if (key.toLowerCase() === 'content-encoding') { - // https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1 - // "All content-coding values are case-insensitive..." - codings = val.toLowerCase().split(',').map((x) => x.trim()).reverse() - } else if (key.toLowerCase() === 'location') { - location = val - } - - headers[kHeadersList].append(key, val) - } - } - - this.body = new Readable({ read: resume }) - - const decoders = [] - - const willFollow = request.redirect === 'follow' && - location && - redirectStatusSet.has(status) - - // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding - if (request.method !== 'HEAD' && request.method !== 'CONNECT' && !nullBodyStatus.includes(status) && !willFollow) { - for (const coding of codings) { - // https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2 - if (coding === 'x-gzip' || coding === 'gzip') { - decoders.push(zlib.createGunzip({ - // 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. - flush: zlib.constants.Z_SYNC_FLUSH, - finishFlush: zlib.constants.Z_SYNC_FLUSH - })) - } else if (coding === 'deflate') { - decoders.push(zlib.createInflate()) - } else if (coding === 'br') { - decoders.push(zlib.createBrotliDecompress()) - } else { - decoders.length = 0 - break - } - } - } - - resolve({ - status, - statusText, - headersList: headers[kHeadersList], - body: decoders.length - ? pipeline(this.body, ...decoders, () => { }) - : this.body.on('error', () => {}) - }) - - return true - }, - - onData (chunk) { - if (fetchParams.controller.dump) { - return - } - - // 1. If one or more bytes have been transmitted from response’s - // message body, then: - - // 1. Let bytes be the transmitted bytes. - const bytes = chunk - - // 2. Let codings be the result of extracting header list values - // given `Content-Encoding` and response’s header list. - // See pullAlgorithm. - - // 3. Increase timingInfo’s encoded body size by bytes’s length. - timingInfo.encodedBodySize += bytes.byteLength - - // 4. See pullAlgorithm... - - return this.body.push(bytes) - }, - - onComplete () { - if (this.abort) { - fetchParams.controller.off('terminated', this.abort) - } - - fetchParams.controller.ended = true - - this.body.push(null) - }, - - onError (error) { - if (this.abort) { - fetchParams.controller.off('terminated', this.abort) - } - - this.body?.destroy(error) - - fetchParams.controller.terminate(error) - - reject(error) - }, - - onUpgrade (status, headersList, socket) { - if (status !== 101) { - return - } - - const headers = new Headers() - - for (let n = 0; n < headersList.length; n += 2) { - const key = headersList[n + 0].toString('latin1') - const val = headersList[n + 1].toString('latin1') - - headers[kHeadersList].append(key, val) - } - - resolve({ - status, - statusText: STATUS_CODES[status], - headersList: headers[kHeadersList], - socket - }) - - return true - } - } - )) - } -} - -module.exports = { - fetch, - Fetch, - fetching, - finalizeAndReportTiming -} - - -/***/ }), - -/***/ 5194: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; -/* globals AbortController */ - - - -const { extractBody, mixinBody, cloneBody } = __nccwpck_require__(8923) -const { Headers, fill: fillHeaders, HeadersList } = __nccwpck_require__(6349) -const { FinalizationRegistry } = __nccwpck_require__(3194)() -const util = __nccwpck_require__(3440) -const { - isValidHTTPToken, - sameOrigin, - normalizeMethod, - makePolicyContainer, - normalizeMethodRecord -} = __nccwpck_require__(5523) -const { - forbiddenMethodsSet, - corsSafeListedMethodsSet, - referrerPolicy, - requestRedirect, - requestMode, - requestCredentials, - requestCache, - requestDuplex -} = __nccwpck_require__(7326) -const { kEnumerableProperty } = util -const { kHeaders, kSignal, kState, kGuard, kRealm } = __nccwpck_require__(9710) -const { webidl } = __nccwpck_require__(4222) -const { getGlobalOrigin } = __nccwpck_require__(5628) -const { URLSerializer } = __nccwpck_require__(4322) -const { kHeadersList, kConstruct } = __nccwpck_require__(6443) -const assert = __nccwpck_require__(2613) -const { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __nccwpck_require__(4434) - -let TransformStream = globalThis.TransformStream - -const kAbortController = Symbol('abortController') - -const requestFinalizer = new FinalizationRegistry(({ signal, abort }) => { - signal.removeEventListener('abort', abort) -}) - -// https://fetch.spec.whatwg.org/#request-class -class Request { - // https://fetch.spec.whatwg.org/#dom-request - constructor (input, init = {}) { - if (input === kConstruct) { - return - } - - webidl.argumentLengthCheck(arguments, 1, { header: 'Request constructor' }) - - input = webidl.converters.RequestInfo(input) - init = webidl.converters.RequestInit(init) - - // https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object - this[kRealm] = { - settingsObject: { - baseUrl: getGlobalOrigin(), - get origin () { - return this.baseUrl?.origin - }, - policyContainer: makePolicyContainer() - } - } - - // 1. Let request be null. - let request = null - - // 2. Let fallbackMode be null. - let fallbackMode = null - - // 3. Let baseURL be this’s relevant settings object’s API base URL. - const baseUrl = this[kRealm].settingsObject.baseUrl - - // 4. Let signal be null. - let signal = null - - // 5. If input is a string, then: - if (typeof input === 'string') { - // 1. Let parsedURL be the result of parsing input with baseURL. - // 2. If parsedURL is failure, then throw a TypeError. - let parsedURL - try { - parsedURL = new URL(input, baseUrl) - } catch (err) { - throw new TypeError('Failed to parse URL from ' + input, { cause: err }) - } - - // 3. If parsedURL includes credentials, then throw a TypeError. - if (parsedURL.username || parsedURL.password) { - throw new TypeError( - 'Request cannot be constructed from a URL that includes credentials: ' + - input - ) - } - - // 4. Set request to a new request whose URL is parsedURL. - request = makeRequest({ urlList: [parsedURL] }) - - // 5. Set fallbackMode to "cors". - fallbackMode = 'cors' - } else { - // 6. Otherwise: - - // 7. Assert: input is a Request object. - assert(input instanceof Request) - - // 8. Set request to input’s request. - request = input[kState] - - // 9. Set signal to input’s signal. - signal = input[kSignal] - } - - // 7. Let origin be this’s relevant settings object’s origin. - const origin = this[kRealm].settingsObject.origin - - // 8. Let window be "client". - let window = 'client' - - // 9. If request’s window is an environment settings object and its origin - // is same origin with origin, then set window to request’s window. - if ( - request.window?.constructor?.name === 'EnvironmentSettingsObject' && - sameOrigin(request.window, origin) - ) { - window = request.window - } - - // 10. If init["window"] exists and is non-null, then throw a TypeError. - if (init.window != null) { - throw new TypeError(`'window' option '${window}' must be null`) - } - - // 11. If init["window"] exists, then set window to "no-window". - if ('window' in init) { - window = 'no-window' - } - - // 12. Set request to a new request with the following properties: - request = makeRequest({ - // URL request’s URL. - // undici implementation note: this is set as the first item in request's urlList in makeRequest - // method request’s method. - method: request.method, - // header list A copy of request’s header list. - // undici implementation note: headersList is cloned in makeRequest - headersList: request.headersList, - // unsafe-request flag Set. - unsafeRequest: request.unsafeRequest, - // client This’s relevant settings object. - client: this[kRealm].settingsObject, - // window window. - window, - // priority request’s priority. - priority: request.priority, - // origin request’s origin. The propagation of the origin is only significant for navigation requests - // being handled by a service worker. In this scenario a request can have an origin that is different - // from the current client. - origin: request.origin, - // referrer request’s referrer. - referrer: request.referrer, - // referrer policy request’s referrer policy. - referrerPolicy: request.referrerPolicy, - // mode request’s mode. - mode: request.mode, - // credentials mode request’s credentials mode. - credentials: request.credentials, - // cache mode request’s cache mode. - cache: request.cache, - // redirect mode request’s redirect mode. - redirect: request.redirect, - // integrity metadata request’s integrity metadata. - integrity: request.integrity, - // keepalive request’s keepalive. - keepalive: request.keepalive, - // reload-navigation flag request’s reload-navigation flag. - reloadNavigation: request.reloadNavigation, - // history-navigation flag request’s history-navigation flag. - historyNavigation: request.historyNavigation, - // URL list A clone of request’s URL list. - urlList: [...request.urlList] - }) - - const initHasKey = Object.keys(init).length !== 0 - - // 13. If init is not empty, then: - if (initHasKey) { - // 1. If request’s mode is "navigate", then set it to "same-origin". - if (request.mode === 'navigate') { - request.mode = 'same-origin' - } - - // 2. Unset request’s reload-navigation flag. - request.reloadNavigation = false - - // 3. Unset request’s history-navigation flag. - request.historyNavigation = false - - // 4. Set request’s origin to "client". - request.origin = 'client' - - // 5. Set request’s referrer to "client" - request.referrer = 'client' - - // 6. Set request’s referrer policy to the empty string. - request.referrerPolicy = '' - - // 7. Set request’s URL to request’s current URL. - request.url = request.urlList[request.urlList.length - 1] - - // 8. Set request’s URL list to « request’s URL ». - request.urlList = [request.url] - } - - // 14. If init["referrer"] exists, then: - if (init.referrer !== undefined) { - // 1. Let referrer be init["referrer"]. - const referrer = init.referrer - - // 2. If referrer is the empty string, then set request’s referrer to "no-referrer". - if (referrer === '') { - request.referrer = 'no-referrer' - } else { - // 1. Let parsedReferrer be the result of parsing referrer with - // baseURL. - // 2. If parsedReferrer is failure, then throw a TypeError. - let parsedReferrer - try { - parsedReferrer = new URL(referrer, baseUrl) - } catch (err) { - throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err }) - } - - // 3. If one of the following is true - // - parsedReferrer’s scheme is "about" and path is the string "client" - // - parsedReferrer’s origin is not same origin with origin - // then set request’s referrer to "client". - if ( - (parsedReferrer.protocol === 'about:' && parsedReferrer.hostname === 'client') || - (origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) - ) { - request.referrer = 'client' - } else { - // 4. Otherwise, set request’s referrer to parsedReferrer. - request.referrer = parsedReferrer - } - } - } - - // 15. If init["referrerPolicy"] exists, then set request’s referrer policy - // to it. - if (init.referrerPolicy !== undefined) { - request.referrerPolicy = init.referrerPolicy - } - - // 16. Let mode be init["mode"] if it exists, and fallbackMode otherwise. - let mode - if (init.mode !== undefined) { - mode = init.mode - } else { - mode = fallbackMode - } - - // 17. If mode is "navigate", then throw a TypeError. - if (mode === 'navigate') { - throw webidl.errors.exception({ - header: 'Request constructor', - message: 'invalid request mode navigate.' - }) - } - - // 18. If mode is non-null, set request’s mode to mode. - if (mode != null) { - request.mode = mode - } - - // 19. If init["credentials"] exists, then set request’s credentials mode - // to it. - if (init.credentials !== undefined) { - request.credentials = init.credentials - } - - // 18. If init["cache"] exists, then set request’s cache mode to it. - if (init.cache !== undefined) { - request.cache = init.cache - } - - // 21. If request’s cache mode is "only-if-cached" and request’s mode is - // not "same-origin", then throw a TypeError. - if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') { - throw new TypeError( - "'only-if-cached' can be set only with 'same-origin' mode" - ) - } - - // 22. If init["redirect"] exists, then set request’s redirect mode to it. - if (init.redirect !== undefined) { - request.redirect = init.redirect - } - - // 23. If init["integrity"] exists, then set request’s integrity metadata to it. - if (init.integrity != null) { - request.integrity = String(init.integrity) - } - - // 24. If init["keepalive"] exists, then set request’s keepalive to it. - if (init.keepalive !== undefined) { - request.keepalive = Boolean(init.keepalive) - } - - // 25. If init["method"] exists, then: - if (init.method !== undefined) { - // 1. Let method be init["method"]. - let method = init.method - - // 2. If method is not a method or method is a forbidden method, then - // throw a TypeError. - if (!isValidHTTPToken(method)) { - throw new TypeError(`'${method}' is not a valid HTTP method.`) - } - - if (forbiddenMethodsSet.has(method.toUpperCase())) { - throw new TypeError(`'${method}' HTTP method is unsupported.`) - } - - // 3. Normalize method. - method = normalizeMethodRecord[method] ?? normalizeMethod(method) - - // 4. Set request’s method to method. - request.method = method - } - - // 26. If init["signal"] exists, then set signal to it. - if (init.signal !== undefined) { - signal = init.signal - } - - // 27. Set this’s request to request. - this[kState] = request - - // 28. Set this’s signal to a new AbortSignal object with this’s relevant - // Realm. - // TODO: could this be simplified with AbortSignal.any - // (https://dom.spec.whatwg.org/#dom-abortsignal-any) - const ac = new AbortController() - this[kSignal] = ac.signal - this[kSignal][kRealm] = this[kRealm] - - // 29. If signal is not null, then make this’s signal follow signal. - if (signal != null) { - if ( - !signal || - typeof signal.aborted !== 'boolean' || - typeof signal.addEventListener !== 'function' - ) { - throw new TypeError( - "Failed to construct 'Request': member signal is not of type AbortSignal." - ) - } - - if (signal.aborted) { - ac.abort(signal.reason) - } else { - // Keep a strong ref to ac while request object - // is alive. This is needed to prevent AbortController - // from being prematurely garbage collected. - // See, https://github.com/nodejs/undici/issues/1926. - this[kAbortController] = ac - - const acRef = new WeakRef(ac) - const abort = function () { - const ac = acRef.deref() - if (ac !== undefined) { - ac.abort(this.reason) - } - } - - // Third-party AbortControllers may not work with these. - // See, https://github.com/nodejs/undici/pull/1910#issuecomment-1464495619. - try { - // If the max amount of listeners is equal to the default, increase it - // This is only available in node >= v19.9.0 - if (typeof getMaxListeners === 'function' && getMaxListeners(signal) === defaultMaxListeners) { - setMaxListeners(100, signal) - } else if (getEventListeners(signal, 'abort').length >= defaultMaxListeners) { - setMaxListeners(100, signal) - } - } catch {} - - util.addAbortListener(signal, abort) - requestFinalizer.register(ac, { signal, abort }) - } - } - - // 30. Set this’s headers to a new Headers object with this’s relevant - // Realm, whose header list is request’s header list and guard is - // "request". - this[kHeaders] = new Headers(kConstruct) - this[kHeaders][kHeadersList] = request.headersList - this[kHeaders][kGuard] = 'request' - this[kHeaders][kRealm] = this[kRealm] - - // 31. If this’s request’s mode is "no-cors", then: - if (mode === 'no-cors') { - // 1. If this’s request’s method is not a CORS-safelisted method, - // then throw a TypeError. - if (!corsSafeListedMethodsSet.has(request.method)) { - throw new TypeError( - `'${request.method} is unsupported in no-cors mode.` - ) - } - - // 2. Set this’s headers’s guard to "request-no-cors". - this[kHeaders][kGuard] = 'request-no-cors' - } - - // 32. If init is not empty, then: - if (initHasKey) { - /** @type {HeadersList} */ - const headersList = this[kHeaders][kHeadersList] - // 1. Let headers be a copy of this’s headers and its associated header - // list. - // 2. If init["headers"] exists, then set headers to init["headers"]. - const headers = init.headers !== undefined ? init.headers : new HeadersList(headersList) - - // 3. Empty this’s headers’s header list. - headersList.clear() - - // 4. If headers is a Headers object, then for each header in its header - // list, append header’s name/header’s value to this’s headers. - if (headers instanceof HeadersList) { - for (const [key, val] of headers) { - headersList.append(key, val) - } - // Note: Copy the `set-cookie` meta-data. - headersList.cookies = headers.cookies - } else { - // 5. Otherwise, fill this’s headers with headers. - fillHeaders(this[kHeaders], headers) - } - } - - // 33. Let inputBody be input’s request’s body if input is a Request - // object; otherwise null. - const inputBody = input instanceof Request ? input[kState].body : null - - // 34. If either init["body"] exists and is non-null or inputBody is - // non-null, and request’s method is `GET` or `HEAD`, then throw a - // TypeError. - if ( - (init.body != null || inputBody != null) && - (request.method === 'GET' || request.method === 'HEAD') - ) { - throw new TypeError('Request with GET/HEAD method cannot have body.') - } - - // 35. Let initBody be null. - let initBody = null - - // 36. If init["body"] exists and is non-null, then: - if (init.body != null) { - // 1. Let Content-Type be null. - // 2. Set initBody and Content-Type to the result of extracting - // init["body"], with keepalive set to request’s keepalive. - const [extractedBody, contentType] = extractBody( - init.body, - request.keepalive - ) - initBody = extractedBody - - // 3, If Content-Type is non-null and this’s headers’s header list does - // not contain `Content-Type`, then append `Content-Type`/Content-Type to - // this’s headers. - if (contentType && !this[kHeaders][kHeadersList].contains('content-type')) { - this[kHeaders].append('content-type', contentType) - } - } - - // 37. Let inputOrInitBody be initBody if it is non-null; otherwise - // inputBody. - const inputOrInitBody = initBody ?? inputBody - - // 38. If inputOrInitBody is non-null and inputOrInitBody’s source is - // null, then: - if (inputOrInitBody != null && inputOrInitBody.source == null) { - // 1. If initBody is non-null and init["duplex"] does not exist, - // then throw a TypeError. - if (initBody != null && init.duplex == null) { - throw new TypeError('RequestInit: duplex option is required when sending a body.') - } - - // 2. If this’s request’s mode is neither "same-origin" nor "cors", - // then throw a TypeError. - if (request.mode !== 'same-origin' && request.mode !== 'cors') { - throw new TypeError( - 'If request is made from ReadableStream, mode should be "same-origin" or "cors"' - ) - } - - // 3. Set this’s request’s use-CORS-preflight flag. - request.useCORSPreflightFlag = true - } - - // 39. Let finalBody be inputOrInitBody. - let finalBody = inputOrInitBody - - // 40. If initBody is null and inputBody is non-null, then: - if (initBody == null && inputBody != null) { - // 1. If input is unusable, then throw a TypeError. - if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) { - throw new TypeError( - 'Cannot construct a Request with a Request object that has already been used.' - ) - } - - // 2. Set finalBody to the result of creating a proxy for inputBody. - if (!TransformStream) { - TransformStream = (__nccwpck_require__(3774).TransformStream) - } - - // https://streams.spec.whatwg.org/#readablestream-create-a-proxy - const identityTransform = new TransformStream() - inputBody.stream.pipeThrough(identityTransform) - finalBody = { - source: inputBody.source, - length: inputBody.length, - stream: identityTransform.readable - } - } - - // 41. Set this’s request’s body to finalBody. - this[kState].body = finalBody - } - - // Returns request’s HTTP method, which is "GET" by default. - get method () { - webidl.brandCheck(this, Request) - - // The method getter steps are to return this’s request’s method. - return this[kState].method - } - - // Returns the URL of request as a string. - get url () { - webidl.brandCheck(this, Request) - - // The url getter steps are to return this’s request’s URL, serialized. - return URLSerializer(this[kState].url) - } - - // Returns a Headers object consisting of the headers associated with request. - // Note that headers added in the network layer by the user agent will not - // be accounted for in this object, e.g., the "Host" header. - get headers () { - webidl.brandCheck(this, Request) - - // The headers getter steps are to return this’s headers. - return this[kHeaders] - } - - // Returns the kind of resource requested by request, e.g., "document" - // or "script". - get destination () { - webidl.brandCheck(this, Request) - - // The destination getter are to return this’s request’s destination. - return this[kState].destination - } - - // Returns the referrer of request. Its value can be a same-origin URL if - // explicitly set in init, the empty string to indicate no referrer, and - // "about:client" when defaulting to the global’s default. This is used - // during fetching to determine the value of the `Referer` header of the - // request being made. - get referrer () { - webidl.brandCheck(this, Request) - - // 1. If this’s request’s referrer is "no-referrer", then return the - // empty string. - if (this[kState].referrer === 'no-referrer') { - return '' - } - - // 2. If this’s request’s referrer is "client", then return - // "about:client". - if (this[kState].referrer === 'client') { - return 'about:client' - } - - // Return this’s request’s referrer, serialized. - return this[kState].referrer.toString() - } - - // Returns the referrer policy associated with request. - // This is used during fetching to compute the value of the request’s - // referrer. - get referrerPolicy () { - webidl.brandCheck(this, Request) - - // The referrerPolicy getter steps are to return this’s request’s referrer policy. - return this[kState].referrerPolicy - } - - // Returns the mode associated with request, which is a string indicating - // whether the request will use CORS, or will be restricted to same-origin - // URLs. - get mode () { - webidl.brandCheck(this, Request) - - // The mode getter steps are to return this’s request’s mode. - return this[kState].mode - } - - // Returns the credentials mode associated with request, - // which is a string indicating whether credentials will be sent with the - // request always, never, or only when sent to a same-origin URL. - get credentials () { - // The credentials getter steps are to return this’s request’s credentials mode. - return this[kState].credentials - } - - // Returns the cache mode associated with request, - // which is a string indicating how the request will - // interact with the browser’s cache when fetching. - get cache () { - webidl.brandCheck(this, Request) - - // The cache getter steps are to return this’s request’s cache mode. - return this[kState].cache - } - - // Returns the redirect mode associated with request, - // which is a string indicating how redirects for the - // request will be handled during fetching. A request - // will follow redirects by default. - get redirect () { - webidl.brandCheck(this, Request) - - // The redirect getter steps are to return this’s request’s redirect mode. - return this[kState].redirect - } - - // Returns request’s subresource integrity metadata, which is a - // cryptographic hash of the resource being fetched. Its value - // consists of multiple hashes separated by whitespace. [SRI] - get integrity () { - webidl.brandCheck(this, Request) - - // The integrity getter steps are to return this’s request’s integrity - // metadata. - return this[kState].integrity - } - - // Returns a boolean indicating whether or not request can outlive the - // global in which it was created. - get keepalive () { - webidl.brandCheck(this, Request) - - // The keepalive getter steps are to return this’s request’s keepalive. - return this[kState].keepalive - } - - // Returns a boolean indicating whether or not request is for a reload - // navigation. - get isReloadNavigation () { - webidl.brandCheck(this, Request) - - // The isReloadNavigation getter steps are to return true if this’s - // request’s reload-navigation flag is set; otherwise false. - return this[kState].reloadNavigation - } - - // Returns a boolean indicating whether or not request is for a history - // navigation (a.k.a. back-foward navigation). - get isHistoryNavigation () { - webidl.brandCheck(this, Request) - - // The isHistoryNavigation getter steps are to return true if this’s request’s - // history-navigation flag is set; otherwise false. - return this[kState].historyNavigation - } - - // Returns the signal associated with request, which is an AbortSignal - // object indicating whether or not request has been aborted, and its - // abort event handler. - get signal () { - webidl.brandCheck(this, Request) - - // The signal getter steps are to return this’s signal. - return this[kSignal] - } - - get body () { - webidl.brandCheck(this, Request) - - return this[kState].body ? this[kState].body.stream : null - } - - get bodyUsed () { - webidl.brandCheck(this, Request) - - return !!this[kState].body && util.isDisturbed(this[kState].body.stream) - } - - get duplex () { - webidl.brandCheck(this, Request) - - return 'half' - } - - // Returns a clone of request. - clone () { - webidl.brandCheck(this, Request) - - // 1. If this is unusable, then throw a TypeError. - if (this.bodyUsed || this.body?.locked) { - throw new TypeError('unusable') - } - - // 2. Let clonedRequest be the result of cloning this’s request. - const clonedRequest = cloneRequest(this[kState]) - - // 3. Let clonedRequestObject be the result of creating a Request object, - // given clonedRequest, this’s headers’s guard, and this’s relevant Realm. - const clonedRequestObject = new Request(kConstruct) - clonedRequestObject[kState] = clonedRequest - clonedRequestObject[kRealm] = this[kRealm] - clonedRequestObject[kHeaders] = new Headers(kConstruct) - clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList - clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard] - clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm] - - // 4. Make clonedRequestObject’s signal follow this’s signal. - const ac = new AbortController() - if (this.signal.aborted) { - ac.abort(this.signal.reason) - } else { - util.addAbortListener( - this.signal, - () => { - ac.abort(this.signal.reason) - } - ) - } - clonedRequestObject[kSignal] = ac.signal - - // 4. Return clonedRequestObject. - return clonedRequestObject - } -} - -mixinBody(Request) - -function makeRequest (init) { - // https://fetch.spec.whatwg.org/#requests - const request = { - method: 'GET', - localURLsOnly: false, - unsafeRequest: false, - body: null, - client: null, - reservedClient: null, - replacesClientId: '', - window: 'client', - keepalive: false, - serviceWorkers: 'all', - initiator: '', - destination: '', - priority: null, - origin: 'client', - policyContainer: 'client', - referrer: 'client', - referrerPolicy: '', - mode: 'no-cors', - useCORSPreflightFlag: false, - credentials: 'same-origin', - useCredentials: false, - cache: 'default', - redirect: 'follow', - integrity: '', - cryptoGraphicsNonceMetadata: '', - parserMetadata: '', - reloadNavigation: false, - historyNavigation: false, - userActivation: false, - taintedOrigin: false, - redirectCount: 0, - responseTainting: 'basic', - preventNoCacheCacheControlHeaderModification: false, - done: false, - timingAllowFailed: false, - ...init, - headersList: init.headersList - ? new HeadersList(init.headersList) - : new HeadersList() - } - request.url = request.urlList[0] - return request -} - -// https://fetch.spec.whatwg.org/#concept-request-clone -function cloneRequest (request) { - // To clone a request request, run these steps: - - // 1. Let newRequest be a copy of request, except for its body. - const newRequest = makeRequest({ ...request, body: null }) - - // 2. If request’s body is non-null, set newRequest’s body to the - // result of cloning request’s body. - if (request.body != null) { - newRequest.body = cloneBody(request.body) - } - - // 3. Return newRequest. - return newRequest -} - -Object.defineProperties(Request.prototype, { - method: kEnumerableProperty, - url: kEnumerableProperty, - headers: kEnumerableProperty, - redirect: kEnumerableProperty, - clone: kEnumerableProperty, - signal: kEnumerableProperty, - duplex: kEnumerableProperty, - destination: kEnumerableProperty, - body: kEnumerableProperty, - bodyUsed: kEnumerableProperty, - isHistoryNavigation: kEnumerableProperty, - isReloadNavigation: kEnumerableProperty, - keepalive: kEnumerableProperty, - integrity: kEnumerableProperty, - cache: kEnumerableProperty, - credentials: kEnumerableProperty, - attribute: kEnumerableProperty, - referrerPolicy: kEnumerableProperty, - referrer: kEnumerableProperty, - mode: kEnumerableProperty, - [Symbol.toStringTag]: { - value: 'Request', - configurable: true - } -}) - -webidl.converters.Request = webidl.interfaceConverter( - Request -) - -// https://fetch.spec.whatwg.org/#requestinfo -webidl.converters.RequestInfo = function (V) { - if (typeof V === 'string') { - return webidl.converters.USVString(V) - } - - if (V instanceof Request) { - return webidl.converters.Request(V) - } - - return webidl.converters.USVString(V) -} - -webidl.converters.AbortSignal = webidl.interfaceConverter( - AbortSignal -) - -// https://fetch.spec.whatwg.org/#requestinit -webidl.converters.RequestInit = webidl.dictionaryConverter([ - { - key: 'method', - converter: webidl.converters.ByteString - }, - { - key: 'headers', - converter: webidl.converters.HeadersInit - }, - { - key: 'body', - converter: webidl.nullableConverter( - webidl.converters.BodyInit - ) - }, - { - key: 'referrer', - converter: webidl.converters.USVString - }, - { - key: 'referrerPolicy', - converter: webidl.converters.DOMString, - // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy - allowedValues: referrerPolicy - }, - { - key: 'mode', - converter: webidl.converters.DOMString, - // https://fetch.spec.whatwg.org/#concept-request-mode - allowedValues: requestMode - }, - { - key: 'credentials', - converter: webidl.converters.DOMString, - // https://fetch.spec.whatwg.org/#requestcredentials - allowedValues: requestCredentials - }, - { - key: 'cache', - converter: webidl.converters.DOMString, - // https://fetch.spec.whatwg.org/#requestcache - allowedValues: requestCache - }, - { - key: 'redirect', - converter: webidl.converters.DOMString, - // https://fetch.spec.whatwg.org/#requestredirect - allowedValues: requestRedirect - }, - { - key: 'integrity', - converter: webidl.converters.DOMString - }, - { - key: 'keepalive', - converter: webidl.converters.boolean - }, - { - key: 'signal', - converter: webidl.nullableConverter( - (signal) => webidl.converters.AbortSignal( - signal, - { strict: false } - ) - ) - }, - { - key: 'window', - converter: webidl.converters.any - }, - { - key: 'duplex', - converter: webidl.converters.DOMString, - allowedValues: requestDuplex - } -]) - -module.exports = { Request, makeRequest } - - -/***/ }), - -/***/ 8676: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { Headers, HeadersList, fill } = __nccwpck_require__(6349) -const { extractBody, cloneBody, mixinBody } = __nccwpck_require__(8923) -const util = __nccwpck_require__(3440) -const { kEnumerableProperty } = util -const { - isValidReasonPhrase, - isCancelled, - isAborted, - isBlobLike, - serializeJavascriptValueToJSONString, - isErrorLike, - isomorphicEncode -} = __nccwpck_require__(5523) -const { - redirectStatusSet, - nullBodyStatus, - DOMException -} = __nccwpck_require__(7326) -const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(9710) -const { webidl } = __nccwpck_require__(4222) -const { FormData } = __nccwpck_require__(3073) -const { getGlobalOrigin } = __nccwpck_require__(5628) -const { URLSerializer } = __nccwpck_require__(4322) -const { kHeadersList, kConstruct } = __nccwpck_require__(6443) -const assert = __nccwpck_require__(2613) -const { types } = __nccwpck_require__(9023) - -const ReadableStream = globalThis.ReadableStream || (__nccwpck_require__(3774).ReadableStream) -const textEncoder = new TextEncoder('utf-8') - -// https://fetch.spec.whatwg.org/#response-class -class Response { - // Creates network error Response. - static error () { - // TODO - const relevantRealm = { settingsObject: {} } - - // The static error() method steps are to return the result of creating a - // Response object, given a new network error, "immutable", and this’s - // relevant Realm. - const responseObject = new Response() - responseObject[kState] = makeNetworkError() - responseObject[kRealm] = relevantRealm - responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList - responseObject[kHeaders][kGuard] = 'immutable' - responseObject[kHeaders][kRealm] = relevantRealm - return responseObject - } - - // https://fetch.spec.whatwg.org/#dom-response-json - static json (data, init = {}) { - webidl.argumentLengthCheck(arguments, 1, { header: 'Response.json' }) - - if (init !== null) { - init = webidl.converters.ResponseInit(init) - } - - // 1. Let bytes the result of running serialize a JavaScript value to JSON bytes on data. - const bytes = textEncoder.encode( - serializeJavascriptValueToJSONString(data) - ) - - // 2. Let body be the result of extracting bytes. - const body = extractBody(bytes) - - // 3. Let responseObject be the result of creating a Response object, given a new response, - // "response", and this’s relevant Realm. - const relevantRealm = { settingsObject: {} } - const responseObject = new Response() - responseObject[kRealm] = relevantRealm - responseObject[kHeaders][kGuard] = 'response' - responseObject[kHeaders][kRealm] = relevantRealm - - // 4. Perform initialize a response given responseObject, init, and (body, "application/json"). - initializeResponse(responseObject, init, { body: body[0], type: 'application/json' }) - - // 5. Return responseObject. - return responseObject - } - - // Creates a redirect Response that redirects to url with status status. - static redirect (url, status = 302) { - const relevantRealm = { settingsObject: {} } - - webidl.argumentLengthCheck(arguments, 1, { header: 'Response.redirect' }) - - url = webidl.converters.USVString(url) - status = webidl.converters['unsigned short'](status) - - // 1. Let parsedURL be the result of parsing url with current settings - // object’s API base URL. - // 2. If parsedURL is failure, then throw a TypeError. - // TODO: base-URL? - let parsedURL - try { - parsedURL = new URL(url, getGlobalOrigin()) - } catch (err) { - throw Object.assign(new TypeError('Failed to parse URL from ' + url), { - cause: err - }) - } - - // 3. If status is not a redirect status, then throw a RangeError. - if (!redirectStatusSet.has(status)) { - throw new RangeError('Invalid status code ' + status) - } - - // 4. Let responseObject be the result of creating a Response object, - // given a new response, "immutable", and this’s relevant Realm. - const responseObject = new Response() - responseObject[kRealm] = relevantRealm - responseObject[kHeaders][kGuard] = 'immutable' - responseObject[kHeaders][kRealm] = relevantRealm - - // 5. Set responseObject’s response’s status to status. - responseObject[kState].status = status - - // 6. Let value be parsedURL, serialized and isomorphic encoded. - const value = isomorphicEncode(URLSerializer(parsedURL)) - - // 7. Append `Location`/value to responseObject’s response’s header list. - responseObject[kState].headersList.append('location', value) - - // 8. Return responseObject. - return responseObject - } - - // https://fetch.spec.whatwg.org/#dom-response - constructor (body = null, init = {}) { - if (body !== null) { - body = webidl.converters.BodyInit(body) - } - - init = webidl.converters.ResponseInit(init) - - // TODO - this[kRealm] = { settingsObject: {} } - - // 1. Set this’s response to a new response. - this[kState] = makeResponse({}) - - // 2. Set this’s headers to a new Headers object with this’s relevant - // Realm, whose header list is this’s response’s header list and guard - // is "response". - this[kHeaders] = new Headers(kConstruct) - this[kHeaders][kGuard] = 'response' - this[kHeaders][kHeadersList] = this[kState].headersList - this[kHeaders][kRealm] = this[kRealm] - - // 3. Let bodyWithType be null. - let bodyWithType = null - - // 4. If body is non-null, then set bodyWithType to the result of extracting body. - if (body != null) { - const [extractedBody, type] = extractBody(body) - bodyWithType = { body: extractedBody, type } - } - - // 5. Perform initialize a response given this, init, and bodyWithType. - initializeResponse(this, init, bodyWithType) - } - - // Returns response’s type, e.g., "cors". - get type () { - webidl.brandCheck(this, Response) - - // The type getter steps are to return this’s response’s type. - return this[kState].type - } - - // Returns response’s URL, if it has one; otherwise the empty string. - get url () { - webidl.brandCheck(this, Response) - - const urlList = this[kState].urlList - - // The url getter steps are to return the empty string if this’s - // response’s URL is null; otherwise this’s response’s URL, - // serialized with exclude fragment set to true. - const url = urlList[urlList.length - 1] ?? null - - if (url === null) { - return '' - } - - return URLSerializer(url, true) - } - - // Returns whether response was obtained through a redirect. - get redirected () { - webidl.brandCheck(this, Response) - - // The redirected getter steps are to return true if this’s response’s URL - // list has more than one item; otherwise false. - return this[kState].urlList.length > 1 - } - - // Returns response’s status. - get status () { - webidl.brandCheck(this, Response) - - // The status getter steps are to return this’s response’s status. - return this[kState].status - } - - // Returns whether response’s status is an ok status. - get ok () { - webidl.brandCheck(this, Response) - - // The ok getter steps are to return true if this’s response’s status is an - // ok status; otherwise false. - return this[kState].status >= 200 && this[kState].status <= 299 - } - - // Returns response’s status message. - get statusText () { - webidl.brandCheck(this, Response) - - // The statusText getter steps are to return this’s response’s status - // message. - return this[kState].statusText - } - - // Returns response’s headers as Headers. - get headers () { - webidl.brandCheck(this, Response) - - // The headers getter steps are to return this’s headers. - return this[kHeaders] - } - - get body () { - webidl.brandCheck(this, Response) - - return this[kState].body ? this[kState].body.stream : null - } - - get bodyUsed () { - webidl.brandCheck(this, Response) - - return !!this[kState].body && util.isDisturbed(this[kState].body.stream) - } - - // Returns a clone of response. - clone () { - webidl.brandCheck(this, Response) - - // 1. If this is unusable, then throw a TypeError. - if (this.bodyUsed || (this.body && this.body.locked)) { - throw webidl.errors.exception({ - header: 'Response.clone', - message: 'Body has already been consumed.' - }) - } - - // 2. Let clonedResponse be the result of cloning this’s response. - const clonedResponse = cloneResponse(this[kState]) - - // 3. Return the result of creating a Response object, given - // clonedResponse, this’s headers’s guard, and this’s relevant Realm. - const clonedResponseObject = new Response() - clonedResponseObject[kState] = clonedResponse - clonedResponseObject[kRealm] = this[kRealm] - clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList - clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard] - clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm] - - return clonedResponseObject - } -} - -mixinBody(Response) - -Object.defineProperties(Response.prototype, { - type: kEnumerableProperty, - url: kEnumerableProperty, - status: kEnumerableProperty, - ok: kEnumerableProperty, - redirected: kEnumerableProperty, - statusText: kEnumerableProperty, - headers: kEnumerableProperty, - clone: kEnumerableProperty, - body: kEnumerableProperty, - bodyUsed: kEnumerableProperty, - [Symbol.toStringTag]: { - value: 'Response', - configurable: true - } -}) - -Object.defineProperties(Response, { - json: kEnumerableProperty, - redirect: kEnumerableProperty, - error: kEnumerableProperty -}) - -// https://fetch.spec.whatwg.org/#concept-response-clone -function cloneResponse (response) { - // To clone a response response, run these steps: - - // 1. If response is a filtered response, then return a new identical - // filtered response whose internal response is a clone of response’s - // internal response. - if (response.internalResponse) { - return filterResponse( - cloneResponse(response.internalResponse), - response.type - ) - } - - // 2. Let newResponse be a copy of response, except for its body. - const newResponse = makeResponse({ ...response, body: null }) - - // 3. If response’s body is non-null, then set newResponse’s body to the - // result of cloning response’s body. - if (response.body != null) { - newResponse.body = cloneBody(response.body) - } - - // 4. Return newResponse. - return newResponse -} - -function makeResponse (init) { - return { - aborted: false, - rangeRequested: false, - timingAllowPassed: false, - requestIncludesCredentials: false, - type: 'default', - status: 200, - timingInfo: null, - cacheState: '', - statusText: '', - ...init, - headersList: init.headersList - ? new HeadersList(init.headersList) - : new HeadersList(), - urlList: init.urlList ? [...init.urlList] : [] - } -} - -function makeNetworkError (reason) { - const isError = isErrorLike(reason) - return makeResponse({ - type: 'error', - status: 0, - error: isError - ? reason - : new Error(reason ? String(reason) : reason), - aborted: reason && reason.name === 'AbortError' - }) -} - -function makeFilteredResponse (response, state) { - state = { - internalResponse: response, - ...state - } - - return new Proxy(response, { - get (target, p) { - return p in state ? state[p] : target[p] - }, - set (target, p, value) { - assert(!(p in state)) - target[p] = value - return true - } - }) -} - -// https://fetch.spec.whatwg.org/#concept-filtered-response -function filterResponse (response, type) { - // Set response to the following filtered response with response as its - // internal response, depending on request’s response tainting: - if (type === 'basic') { - // A basic filtered response is a filtered response whose type is "basic" - // and header list excludes any headers in internal response’s header list - // whose name is a forbidden response-header name. - - // Note: undici does not implement forbidden response-header names - return makeFilteredResponse(response, { - type: 'basic', - headersList: response.headersList - }) - } else if (type === 'cors') { - // A CORS filtered response is a filtered response whose type is "cors" - // and header list excludes any headers in internal response’s header - // list whose name is not a CORS-safelisted response-header name, given - // internal response’s CORS-exposed header-name list. - - // Note: undici does not implement CORS-safelisted response-header names - return makeFilteredResponse(response, { - type: 'cors', - headersList: response.headersList - }) - } else if (type === 'opaque') { - // An opaque filtered response is a filtered response whose type is - // "opaque", URL list is the empty list, status is 0, status message - // is the empty byte sequence, header list is empty, and body is null. - - return makeFilteredResponse(response, { - type: 'opaque', - urlList: Object.freeze([]), - status: 0, - statusText: '', - body: null - }) - } else if (type === 'opaqueredirect') { - // An opaque-redirect filtered response is a filtered response whose type - // is "opaqueredirect", status is 0, status message is the empty byte - // sequence, header list is empty, and body is null. - - return makeFilteredResponse(response, { - type: 'opaqueredirect', - status: 0, - statusText: '', - headersList: [], - body: null - }) - } else { - assert(false) - } -} - -// https://fetch.spec.whatwg.org/#appropriate-network-error -function makeAppropriateNetworkError (fetchParams, err = null) { - // 1. Assert: fetchParams is canceled. - assert(isCancelled(fetchParams)) - - // 2. Return an aborted network error if fetchParams is aborted; - // otherwise return a network error. - return isAborted(fetchParams) - ? makeNetworkError(Object.assign(new DOMException('The operation was aborted.', 'AbortError'), { cause: err })) - : makeNetworkError(Object.assign(new DOMException('Request was cancelled.'), { cause: err })) -} - -// https://whatpr.org/fetch/1392.html#initialize-a-response -function initializeResponse (response, init, body) { - // 1. If init["status"] is not in the range 200 to 599, inclusive, then - // throw a RangeError. - if (init.status !== null && (init.status < 200 || init.status > 599)) { - throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.') - } - - // 2. If init["statusText"] does not match the reason-phrase token production, - // then throw a TypeError. - if ('statusText' in init && init.statusText != null) { - // See, https://datatracker.ietf.org/doc/html/rfc7230#section-3.1.2: - // reason-phrase = *( HTAB / SP / VCHAR / obs-text ) - if (!isValidReasonPhrase(String(init.statusText))) { - throw new TypeError('Invalid statusText') - } - } - - // 3. Set response’s response’s status to init["status"]. - if ('status' in init && init.status != null) { - response[kState].status = init.status - } - - // 4. Set response’s response’s status message to init["statusText"]. - if ('statusText' in init && init.statusText != null) { - response[kState].statusText = init.statusText - } - - // 5. If init["headers"] exists, then fill response’s headers with init["headers"]. - if ('headers' in init && init.headers != null) { - fill(response[kHeaders], init.headers) - } - - // 6. If body was given, then: - if (body) { - // 1. If response's status is a null body status, then throw a TypeError. - if (nullBodyStatus.includes(response.status)) { - throw webidl.errors.exception({ - header: 'Response constructor', - message: 'Invalid response status code ' + response.status - }) - } - - // 2. Set response's body to body's body. - response[kState].body = body.body - - // 3. If body's type is non-null and response's header list does not contain - // `Content-Type`, then append (`Content-Type`, body's type) to response's header list. - if (body.type != null && !response[kState].headersList.contains('Content-Type')) { - response[kState].headersList.append('content-type', body.type) - } - } -} - -webidl.converters.ReadableStream = webidl.interfaceConverter( - ReadableStream -) - -webidl.converters.FormData = webidl.interfaceConverter( - FormData -) - -webidl.converters.URLSearchParams = webidl.interfaceConverter( - URLSearchParams -) - -// https://fetch.spec.whatwg.org/#typedefdef-xmlhttprequestbodyinit -webidl.converters.XMLHttpRequestBodyInit = function (V) { - if (typeof V === 'string') { - return webidl.converters.USVString(V) - } - - if (isBlobLike(V)) { - return webidl.converters.Blob(V, { strict: false }) - } - - if (types.isArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) { - return webidl.converters.BufferSource(V) - } - - if (util.isFormDataLike(V)) { - return webidl.converters.FormData(V, { strict: false }) - } - - if (V instanceof URLSearchParams) { - return webidl.converters.URLSearchParams(V) - } - - return webidl.converters.DOMString(V) -} - -// https://fetch.spec.whatwg.org/#bodyinit -webidl.converters.BodyInit = function (V) { - if (V instanceof ReadableStream) { - return webidl.converters.ReadableStream(V) - } - - // Note: the spec doesn't include async iterables, - // this is an undici extension. - if (V?.[Symbol.asyncIterator]) { - return V - } - - return webidl.converters.XMLHttpRequestBodyInit(V) -} - -webidl.converters.ResponseInit = webidl.dictionaryConverter([ - { - key: 'status', - converter: webidl.converters['unsigned short'], - defaultValue: 200 - }, - { - key: 'statusText', - converter: webidl.converters.ByteString, - defaultValue: '' - }, - { - key: 'headers', - converter: webidl.converters.HeadersInit - } -]) - -module.exports = { - makeNetworkError, - makeResponse, - makeAppropriateNetworkError, - filterResponse, - Response, - cloneResponse -} - - -/***/ }), - -/***/ 9710: -/***/ ((module) => { - -"use strict"; - - -module.exports = { - kUrl: Symbol('url'), - kHeaders: Symbol('headers'), - kSignal: Symbol('signal'), - kState: Symbol('state'), - kGuard: Symbol('guard'), - kRealm: Symbol('realm') -} - - -/***/ }), - -/***/ 5523: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = __nccwpck_require__(7326) -const { getGlobalOrigin } = __nccwpck_require__(5628) -const { performance } = __nccwpck_require__(2987) -const { isBlobLike, toUSVString, ReadableStreamFrom } = __nccwpck_require__(3440) -const assert = __nccwpck_require__(2613) -const { isUint8Array } = __nccwpck_require__(8253) - -let supportedHashes = [] - -// https://nodejs.org/api/crypto.html#determining-if-crypto-support-is-unavailable -/** @type {import('crypto')|undefined} */ -let crypto - -try { - crypto = __nccwpck_require__(6982) - const possibleRelevantHashes = ['sha256', 'sha384', 'sha512'] - supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)) -/* c8 ignore next 3 */ -} catch { -} - -function responseURL (response) { - // https://fetch.spec.whatwg.org/#responses - // A response has an associated URL. It is a pointer to the last URL - // in response’s URL list and null if response’s URL list is empty. - const urlList = response.urlList - const length = urlList.length - return length === 0 ? null : urlList[length - 1].toString() -} - -// https://fetch.spec.whatwg.org/#concept-response-location-url -function responseLocationURL (response, requestFragment) { - // 1. If response’s status is not a redirect status, then return null. - if (!redirectStatusSet.has(response.status)) { - return null - } - - // 2. Let location be the result of extracting header list values given - // `Location` and response’s header list. - let location = response.headersList.get('location') - - // 3. If location is a header value, then set location to the result of - // parsing location with response’s URL. - if (location !== null && isValidHeaderValue(location)) { - location = new URL(location, responseURL(response)) - } - - // 4. If location is a URL whose fragment is null, then set location’s - // fragment to requestFragment. - if (location && !location.hash) { - location.hash = requestFragment - } - - // 5. Return location. - return location -} - -/** @returns {URL} */ -function requestCurrentURL (request) { - return request.urlList[request.urlList.length - 1] -} - -function requestBadPort (request) { - // 1. Let url be request’s current URL. - const url = requestCurrentURL(request) - - // 2. If url’s scheme is an HTTP(S) scheme and url’s port is a bad port, - // then return blocked. - if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) { - return 'blocked' - } - - // 3. Return allowed. - return 'allowed' -} - -function isErrorLike (object) { - return object instanceof Error || ( - object?.constructor?.name === 'Error' || - object?.constructor?.name === 'DOMException' - ) -} - -// Check whether |statusText| is a ByteString and -// matches the Reason-Phrase token production. -// RFC 2616: https://tools.ietf.org/html/rfc2616 -// RFC 7230: https://tools.ietf.org/html/rfc7230 -// "reason-phrase = *( HTAB / SP / VCHAR / obs-text )" -// https://github.com/chromium/chromium/blob/94.0.4604.1/third_party/blink/renderer/core/fetch/response.cc#L116 -function isValidReasonPhrase (statusText) { - for (let i = 0; i < statusText.length; ++i) { - const c = statusText.charCodeAt(i) - if ( - !( - ( - c === 0x09 || // HTAB - (c >= 0x20 && c <= 0x7e) || // SP / VCHAR - (c >= 0x80 && c <= 0xff) - ) // obs-text - ) - ) { - return false - } - } - return true -} - -/** - * @see https://tools.ietf.org/html/rfc7230#section-3.2.6 - * @param {number} c - */ -function isTokenCharCode (c) { - switch (c) { - case 0x22: - case 0x28: - case 0x29: - case 0x2c: - case 0x2f: - case 0x3a: - case 0x3b: - case 0x3c: - case 0x3d: - case 0x3e: - case 0x3f: - case 0x40: - case 0x5b: - case 0x5c: - case 0x5d: - case 0x7b: - case 0x7d: - // DQUOTE and "(),/:;<=>?@[\]{}" - return false - default: - // VCHAR %x21-7E - return c >= 0x21 && c <= 0x7e - } -} - -/** - * @param {string} characters - */ -function isValidHTTPToken (characters) { - if (characters.length === 0) { - return false - } - for (let i = 0; i < characters.length; ++i) { - if (!isTokenCharCode(characters.charCodeAt(i))) { - return false - } - } - return true -} - -/** - * @see https://fetch.spec.whatwg.org/#header-name - * @param {string} potentialValue - */ -function isValidHeaderName (potentialValue) { - return isValidHTTPToken(potentialValue) -} - -/** - * @see https://fetch.spec.whatwg.org/#header-value - * @param {string} potentialValue - */ -function isValidHeaderValue (potentialValue) { - // - Has no leading or trailing HTTP tab or space bytes. - // - Contains no 0x00 (NUL) or HTTP newline bytes. - if ( - potentialValue.startsWith('\t') || - potentialValue.startsWith(' ') || - potentialValue.endsWith('\t') || - potentialValue.endsWith(' ') - ) { - return false - } - - if ( - potentialValue.includes('\0') || - potentialValue.includes('\r') || - potentialValue.includes('\n') - ) { - return false - } - - return true -} - -// https://w3c.github.io/webappsec-referrer-policy/#set-requests-referrer-policy-on-redirect -function setRequestReferrerPolicyOnRedirect (request, actualResponse) { - // Given a request request and a response actualResponse, this algorithm - // updates request’s referrer policy according to the Referrer-Policy - // header (if any) in actualResponse. - - // 1. Let policy be the result of executing § 8.1 Parse a referrer policy - // from a Referrer-Policy header on actualResponse. - - // 8.1 Parse a referrer policy from a Referrer-Policy header - // 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy` and response’s header list. - const { headersList } = actualResponse - // 2. Let policy be the empty string. - // 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty string, then set policy to token. - // 4. Return policy. - const policyHeader = (headersList.get('referrer-policy') ?? '').split(',') - - // Note: As the referrer-policy can contain multiple policies - // separated by comma, we need to loop through all of them - // and pick the first valid one. - // Ref: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy#specify_a_fallback_policy - let policy = '' - if (policyHeader.length > 0) { - // The right-most policy takes precedence. - // The left-most policy is the fallback. - for (let i = policyHeader.length; i !== 0; i--) { - const token = policyHeader[i - 1].trim() - if (referrerPolicyTokens.has(token)) { - policy = token - break - } - } - } - - // 2. If policy is not the empty string, then set request’s referrer policy to policy. - if (policy !== '') { - request.referrerPolicy = policy - } -} - -// https://fetch.spec.whatwg.org/#cross-origin-resource-policy-check -function crossOriginResourcePolicyCheck () { - // TODO - return 'allowed' -} - -// https://fetch.spec.whatwg.org/#concept-cors-check -function corsCheck () { - // TODO - return 'success' -} - -// https://fetch.spec.whatwg.org/#concept-tao-check -function TAOCheck () { - // TODO - return 'success' -} - -function appendFetchMetadata (httpRequest) { - // https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-dest-header - // TODO - - // https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-mode-header - - // 1. Assert: r’s url is a potentially trustworthy URL. - // TODO - - // 2. Let header be a Structured Header whose value is a token. - let header = null - - // 3. Set header’s value to r’s mode. - header = httpRequest.mode - - // 4. Set a structured field value `Sec-Fetch-Mode`/header in r’s header list. - httpRequest.headersList.set('sec-fetch-mode', header) - - // https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-site-header - // TODO - - // https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-user-header - // TODO -} - -// https://fetch.spec.whatwg.org/#append-a-request-origin-header -function appendRequestOriginHeader (request) { - // 1. Let serializedOrigin be the result of byte-serializing a request origin with request. - let serializedOrigin = request.origin - - // 2. If request’s response tainting is "cors" or request’s mode is "websocket", then append (`Origin`, serializedOrigin) to request’s header list. - if (request.responseTainting === 'cors' || request.mode === 'websocket') { - if (serializedOrigin) { - request.headersList.append('origin', serializedOrigin) - } - - // 3. Otherwise, if request’s method is neither `GET` nor `HEAD`, then: - } else if (request.method !== 'GET' && request.method !== 'HEAD') { - // 1. Switch on request’s referrer policy: - switch (request.referrerPolicy) { - case 'no-referrer': - // Set serializedOrigin to `null`. - serializedOrigin = null - break - case 'no-referrer-when-downgrade': - case 'strict-origin': - case 'strict-origin-when-cross-origin': - // If request’s origin is a tuple origin, its scheme is "https", and request’s current URL’s scheme is not "https", then set serializedOrigin to `null`. - if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) { - serializedOrigin = null - } - break - case 'same-origin': - // If request’s origin is not same origin with request’s current URL’s origin, then set serializedOrigin to `null`. - if (!sameOrigin(request, requestCurrentURL(request))) { - serializedOrigin = null - } - break - default: - // Do nothing. - } - - if (serializedOrigin) { - // 2. Append (`Origin`, serializedOrigin) to request’s header list. - request.headersList.append('origin', serializedOrigin) - } - } -} - -function coarsenedSharedCurrentTime (crossOriginIsolatedCapability) { - // TODO - return performance.now() -} - -// https://fetch.spec.whatwg.org/#create-an-opaque-timing-info -function createOpaqueTimingInfo (timingInfo) { - return { - startTime: timingInfo.startTime ?? 0, - redirectStartTime: 0, - redirectEndTime: 0, - postRedirectStartTime: timingInfo.startTime ?? 0, - finalServiceWorkerStartTime: 0, - finalNetworkResponseStartTime: 0, - finalNetworkRequestStartTime: 0, - endTime: 0, - encodedBodySize: 0, - decodedBodySize: 0, - finalConnectionTimingInfo: null - } -} - -// https://html.spec.whatwg.org/multipage/origin.html#policy-container -function makePolicyContainer () { - // Note: the fetch spec doesn't make use of embedder policy or CSP list - return { - referrerPolicy: 'strict-origin-when-cross-origin' - } -} - -// https://html.spec.whatwg.org/multipage/origin.html#clone-a-policy-container -function clonePolicyContainer (policyContainer) { - return { - referrerPolicy: policyContainer.referrerPolicy - } -} - -// https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer -function determineRequestsReferrer (request) { - // 1. Let policy be request's referrer policy. - const policy = request.referrerPolicy - - // Note: policy cannot (shouldn't) be null or an empty string. - assert(policy) - - // 2. Let environment be request’s client. - - let referrerSource = null - - // 3. Switch on request’s referrer: - if (request.referrer === 'client') { - // Note: node isn't a browser and doesn't implement document/iframes, - // so we bypass this step and replace it with our own. - - const globalOrigin = getGlobalOrigin() - - if (!globalOrigin || globalOrigin.origin === 'null') { - return 'no-referrer' - } - - // note: we need to clone it as it's mutated - referrerSource = new URL(globalOrigin) - } else if (request.referrer instanceof URL) { - // Let referrerSource be request’s referrer. - referrerSource = request.referrer - } - - // 4. Let request’s referrerURL be the result of stripping referrerSource for - // use as a referrer. - let referrerURL = stripURLForReferrer(referrerSource) - - // 5. Let referrerOrigin be the result of stripping referrerSource for use as - // a referrer, with the origin-only flag set to true. - const referrerOrigin = stripURLForReferrer(referrerSource, true) - - // 6. If the result of serializing referrerURL is a string whose length is - // greater than 4096, set referrerURL to referrerOrigin. - if (referrerURL.toString().length > 4096) { - referrerURL = referrerOrigin - } - - const areSameOrigin = sameOrigin(request, referrerURL) - const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && - !isURLPotentiallyTrustworthy(request.url) - - // 8. Execute the switch statements corresponding to the value of policy: - switch (policy) { - case 'origin': return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true) - case 'unsafe-url': return referrerURL - case 'same-origin': - return areSameOrigin ? referrerOrigin : 'no-referrer' - case 'origin-when-cross-origin': - return areSameOrigin ? referrerURL : referrerOrigin - case 'strict-origin-when-cross-origin': { - const currentURL = requestCurrentURL(request) - - // 1. If the origin of referrerURL and the origin of request’s current - // URL are the same, then return referrerURL. - if (sameOrigin(referrerURL, currentURL)) { - return referrerURL - } - - // 2. If referrerURL is a potentially trustworthy URL and request’s - // current URL is not a potentially trustworthy URL, then return no - // referrer. - if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) { - return 'no-referrer' - } - - // 3. Return referrerOrigin. - return referrerOrigin - } - case 'strict-origin': // eslint-disable-line - /** - * 1. If referrerURL is a potentially trustworthy URL and - * request’s current URL is not a potentially trustworthy URL, - * then return no referrer. - * 2. Return referrerOrigin - */ - case 'no-referrer-when-downgrade': // eslint-disable-line - /** - * 1. If referrerURL is a potentially trustworthy URL and - * request’s current URL is not a potentially trustworthy URL, - * then return no referrer. - * 2. Return referrerOrigin - */ - - default: // eslint-disable-line - return isNonPotentiallyTrustWorthy ? 'no-referrer' : referrerOrigin - } -} - -/** - * @see https://w3c.github.io/webappsec-referrer-policy/#strip-url - * @param {URL} url - * @param {boolean|undefined} originOnly - */ -function stripURLForReferrer (url, originOnly) { - // 1. Assert: url is a URL. - assert(url instanceof URL) - - // 2. If url’s scheme is a local scheme, then return no referrer. - if (url.protocol === 'file:' || url.protocol === 'about:' || url.protocol === 'blank:') { - return 'no-referrer' - } - - // 3. Set url’s username to the empty string. - url.username = '' - - // 4. Set url’s password to the empty string. - url.password = '' - - // 5. Set url’s fragment to null. - url.hash = '' - - // 6. If the origin-only flag is true, then: - if (originOnly) { - // 1. Set url’s path to « the empty string ». - url.pathname = '' - - // 2. Set url’s query to null. - url.search = '' - } - - // 7. Return url. - return url -} - -function isURLPotentiallyTrustworthy (url) { - if (!(url instanceof URL)) { - return false - } - - // If child of about, return true - if (url.href === 'about:blank' || url.href === 'about:srcdoc') { - return true - } - - // If scheme is data, return true - if (url.protocol === 'data:') return true - - // If file, return true - if (url.protocol === 'file:') return true - - return isOriginPotentiallyTrustworthy(url.origin) - - function isOriginPotentiallyTrustworthy (origin) { - // If origin is explicitly null, return false - if (origin == null || origin === 'null') return false - - const originAsURL = new URL(origin) - - // If secure, return true - if (originAsURL.protocol === 'https:' || originAsURL.protocol === 'wss:') { - return true - } - - // If localhost or variants, return true - if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || - (originAsURL.hostname === 'localhost' || originAsURL.hostname.includes('localhost.')) || - (originAsURL.hostname.endsWith('.localhost'))) { - return true - } - - // If any other, return false - return false - } -} - -/** - * @see https://w3c.github.io/webappsec-subresource-integrity/#does-response-match-metadatalist - * @param {Uint8Array} bytes - * @param {string} metadataList - */ -function bytesMatch (bytes, metadataList) { - // If node is not built with OpenSSL support, we cannot check - // a request's integrity, so allow it by default (the spec will - // allow requests if an invalid hash is given, as precedence). - /* istanbul ignore if: only if node is built with --without-ssl */ - if (crypto === undefined) { - return true - } - - // 1. Let parsedMetadata be the result of parsing metadataList. - const parsedMetadata = parseMetadata(metadataList) - - // 2. If parsedMetadata is no metadata, return true. - if (parsedMetadata === 'no metadata') { - return true - } - - // 3. If response is not eligible for integrity validation, return false. - // TODO - - // 4. If parsedMetadata is the empty set, return true. - if (parsedMetadata.length === 0) { - return true - } - - // 5. Let metadata be the result of getting the strongest - // metadata from parsedMetadata. - const strongest = getStrongestMetadata(parsedMetadata) - const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest) - - // 6. For each item in metadata: - for (const item of metadata) { - // 1. Let algorithm be the alg component of item. - const algorithm = item.algo - - // 2. Let expectedValue be the val component of item. - const expectedValue = item.hash - - // See https://github.com/web-platform-tests/wpt/commit/e4c5cc7a5e48093220528dfdd1c4012dc3837a0e - // "be liberal with padding". This is annoying, and it's not even in the spec. - - // 3. Let actualValue be the result of applying algorithm to bytes. - let actualValue = crypto.createHash(algorithm).update(bytes).digest('base64') - - if (actualValue[actualValue.length - 1] === '=') { - if (actualValue[actualValue.length - 2] === '=') { - actualValue = actualValue.slice(0, -2) - } else { - actualValue = actualValue.slice(0, -1) - } - } - - // 4. If actualValue is a case-sensitive match for expectedValue, - // return true. - if (compareBase64Mixed(actualValue, expectedValue)) { - return true - } - } - - // 7. Return false. - return false -} - -// https://w3c.github.io/webappsec-subresource-integrity/#grammardef-hash-with-options -// https://www.w3.org/TR/CSP2/#source-list-syntax -// https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1 -const parseHashWithOptions = /(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i - -/** - * @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata - * @param {string} metadata - */ -function parseMetadata (metadata) { - // 1. Let result be the empty set. - /** @type {{ algo: string, hash: string }[]} */ - const result = [] - - // 2. Let empty be equal to true. - let empty = true - - // 3. For each token returned by splitting metadata on spaces: - for (const token of metadata.split(' ')) { - // 1. Set empty to false. - empty = false - - // 2. Parse token as a hash-with-options. - const parsedToken = parseHashWithOptions.exec(token) - - // 3. If token does not parse, continue to the next token. - if ( - parsedToken === null || - parsedToken.groups === undefined || - parsedToken.groups.algo === undefined - ) { - // Note: Chromium blocks the request at this point, but Firefox - // gives a warning that an invalid integrity was given. The - // correct behavior is to ignore these, and subsequently not - // check the integrity of the resource. - continue - } - - // 4. Let algorithm be the hash-algo component of token. - const algorithm = parsedToken.groups.algo.toLowerCase() - - // 5. If algorithm is a hash function recognized by the user - // agent, add the parsed token to result. - if (supportedHashes.includes(algorithm)) { - result.push(parsedToken.groups) - } - } - - // 4. Return no metadata if empty is true, otherwise return result. - if (empty === true) { - return 'no metadata' - } - - return result -} - -/** - * @param {{ algo: 'sha256' | 'sha384' | 'sha512' }[]} metadataList - */ -function getStrongestMetadata (metadataList) { - // Let algorithm be the algo component of the first item in metadataList. - // Can be sha256 - let algorithm = metadataList[0].algo - // If the algorithm is sha512, then it is the strongest - // and we can return immediately - if (algorithm[3] === '5') { - return algorithm - } - - for (let i = 1; i < metadataList.length; ++i) { - const metadata = metadataList[i] - // If the algorithm is sha512, then it is the strongest - // and we can break the loop immediately - if (metadata.algo[3] === '5') { - algorithm = 'sha512' - break - // If the algorithm is sha384, then a potential sha256 or sha384 is ignored - } else if (algorithm[3] === '3') { - continue - // algorithm is sha256, check if algorithm is sha384 and if so, set it as - // the strongest - } else if (metadata.algo[3] === '3') { - algorithm = 'sha384' - } - } - return algorithm -} - -function filterMetadataListByAlgorithm (metadataList, algorithm) { - if (metadataList.length === 1) { - return metadataList - } - - let pos = 0 - for (let i = 0; i < metadataList.length; ++i) { - if (metadataList[i].algo === algorithm) { - metadataList[pos++] = metadataList[i] - } - } - - metadataList.length = pos - - return metadataList -} - -/** - * Compares two base64 strings, allowing for base64url - * in the second string. - * -* @param {string} actualValue always base64 - * @param {string} expectedValue base64 or base64url - * @returns {boolean} - */ -function compareBase64Mixed (actualValue, expectedValue) { - if (actualValue.length !== expectedValue.length) { - return false - } - for (let i = 0; i < actualValue.length; ++i) { - if (actualValue[i] !== expectedValue[i]) { - if ( - (actualValue[i] === '+' && expectedValue[i] === '-') || - (actualValue[i] === '/' && expectedValue[i] === '_') - ) { - continue - } - return false - } - } - - return true -} - -// https://w3c.github.io/webappsec-upgrade-insecure-requests/#upgrade-request -function tryUpgradeRequestToAPotentiallyTrustworthyURL (request) { - // TODO -} - -/** - * @link {https://html.spec.whatwg.org/multipage/origin.html#same-origin} - * @param {URL} A - * @param {URL} B - */ -function sameOrigin (A, B) { - // 1. If A and B are the same opaque origin, then return true. - if (A.origin === B.origin && A.origin === 'null') { - return true - } - - // 2. If A and B are both tuple origins and their schemes, - // hosts, and port are identical, then return true. - if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) { - return true - } - - // 3. Return false. - return false -} - -function createDeferredPromise () { - let res - let rej - const promise = new Promise((resolve, reject) => { - res = resolve - rej = reject - }) - - return { promise, resolve: res, reject: rej } -} - -function isAborted (fetchParams) { - return fetchParams.controller.state === 'aborted' -} - -function isCancelled (fetchParams) { - return fetchParams.controller.state === 'aborted' || - fetchParams.controller.state === 'terminated' -} - -const normalizeMethodRecord = { - delete: 'DELETE', - DELETE: 'DELETE', - get: 'GET', - GET: 'GET', - head: 'HEAD', - HEAD: 'HEAD', - options: 'OPTIONS', - OPTIONS: 'OPTIONS', - post: 'POST', - POST: 'POST', - put: 'PUT', - PUT: 'PUT' -} - -// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`. -Object.setPrototypeOf(normalizeMethodRecord, null) - -/** - * @see https://fetch.spec.whatwg.org/#concept-method-normalize - * @param {string} method - */ -function normalizeMethod (method) { - return normalizeMethodRecord[method.toLowerCase()] ?? method -} - -// https://infra.spec.whatwg.org/#serialize-a-javascript-value-to-a-json-string -function serializeJavascriptValueToJSONString (value) { - // 1. Let result be ? Call(%JSON.stringify%, undefined, « value »). - const result = JSON.stringify(value) - - // 2. If result is undefined, then throw a TypeError. - if (result === undefined) { - throw new TypeError('Value is not JSON serializable') - } - - // 3. Assert: result is a string. - assert(typeof result === 'string') - - // 4. Return result. - return result -} - -// https://tc39.es/ecma262/#sec-%25iteratorprototype%25-object -const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())) - -/** - * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object - * @param {() => unknown[]} iterator - * @param {string} name name of the instance - * @param {'key'|'value'|'key+value'} kind - */ -function makeIterator (iterator, name, kind) { - const object = { - index: 0, - kind, - target: iterator - } - - const i = { - next () { - // 1. Let interface be the interface for which the iterator prototype object exists. - - // 2. Let thisValue be the this value. - - // 3. Let object be ? ToObject(thisValue). - - // 4. If object is a platform object, then perform a security - // check, passing: - - // 5. If object is not a default iterator object for interface, - // then throw a TypeError. - if (Object.getPrototypeOf(this) !== i) { - throw new TypeError( - `'next' called on an object that does not implement interface ${name} Iterator.` - ) - } - - // 6. Let index be object’s index. - // 7. Let kind be object’s kind. - // 8. Let values be object’s target's value pairs to iterate over. - const { index, kind, target } = object - const values = target() - - // 9. Let len be the length of values. - const len = values.length - - // 10. If index is greater than or equal to len, then return - // CreateIterResultObject(undefined, true). - if (index >= len) { - return { value: undefined, done: true } - } - - // 11. Let pair be the entry in values at index index. - const pair = values[index] - - // 12. Set object’s index to index + 1. - object.index = index + 1 - - // 13. Return the iterator result for pair and kind. - return iteratorResult(pair, kind) - }, - // The class string of an iterator prototype object for a given interface is the - // result of concatenating the identifier of the interface and the string " Iterator". - [Symbol.toStringTag]: `${name} Iterator` - } - - // The [[Prototype]] internal slot of an iterator prototype object must be %IteratorPrototype%. - Object.setPrototypeOf(i, esIteratorPrototype) - // esIteratorPrototype needs to be the prototype of i - // which is the prototype of an empty object. Yes, it's confusing. - return Object.setPrototypeOf({}, i) -} - -// https://webidl.spec.whatwg.org/#iterator-result -function iteratorResult (pair, kind) { - let result - - // 1. Let result be a value determined by the value of kind: - switch (kind) { - case 'key': { - // 1. Let idlKey be pair’s key. - // 2. Let key be the result of converting idlKey to an - // ECMAScript value. - // 3. result is key. - result = pair[0] - break - } - case 'value': { - // 1. Let idlValue be pair’s value. - // 2. Let value be the result of converting idlValue to - // an ECMAScript value. - // 3. result is value. - result = pair[1] - break - } - case 'key+value': { - // 1. Let idlKey be pair’s key. - // 2. Let idlValue be pair’s value. - // 3. Let key be the result of converting idlKey to an - // ECMAScript value. - // 4. Let value be the result of converting idlValue to - // an ECMAScript value. - // 5. Let array be ! ArrayCreate(2). - // 6. Call ! CreateDataProperty(array, "0", key). - // 7. Call ! CreateDataProperty(array, "1", value). - // 8. result is array. - result = pair - break - } - } - - // 2. Return CreateIterResultObject(result, false). - return { value: result, done: false } -} - -/** - * @see https://fetch.spec.whatwg.org/#body-fully-read - */ -async function fullyReadBody (body, processBody, processBodyError) { - // 1. If taskDestination is null, then set taskDestination to - // the result of starting a new parallel queue. - - // 2. Let successSteps given a byte sequence bytes be to queue a - // fetch task to run processBody given bytes, with taskDestination. - const successSteps = processBody - - // 3. Let errorSteps be to queue a fetch task to run processBodyError, - // with taskDestination. - const errorSteps = processBodyError - - // 4. Let reader be the result of getting a reader for body’s stream. - // If that threw an exception, then run errorSteps with that - // exception and return. - let reader - - try { - reader = body.stream.getReader() - } catch (e) { - errorSteps(e) - return - } - - // 5. Read all bytes from reader, given successSteps and errorSteps. - try { - const result = await readAllBytes(reader) - successSteps(result) - } catch (e) { - errorSteps(e) - } -} - -/** @type {ReadableStream} */ -let ReadableStream = globalThis.ReadableStream - -function isReadableStreamLike (stream) { - if (!ReadableStream) { - ReadableStream = (__nccwpck_require__(3774).ReadableStream) - } - - return stream instanceof ReadableStream || ( - stream[Symbol.toStringTag] === 'ReadableStream' && - typeof stream.tee === 'function' - ) -} - -const MAXIMUM_ARGUMENT_LENGTH = 65535 - -/** - * @see https://infra.spec.whatwg.org/#isomorphic-decode - * @param {number[]|Uint8Array} input - */ -function isomorphicDecode (input) { - // 1. To isomorphic decode a byte sequence input, return a string whose code point - // length is equal to input’s length and whose code points have the same values - // as the values of input’s bytes, in the same order. - - if (input.length < MAXIMUM_ARGUMENT_LENGTH) { - return String.fromCharCode(...input) - } - - return input.reduce((previous, current) => previous + String.fromCharCode(current), '') -} - -/** - * @param {ReadableStreamController} controller - */ -function readableStreamClose (controller) { - try { - controller.close() - } catch (err) { - // TODO: add comment explaining why this error occurs. - if (!err.message.includes('Controller is already closed')) { - throw err - } - } -} - -/** - * @see https://infra.spec.whatwg.org/#isomorphic-encode - * @param {string} input - */ -function isomorphicEncode (input) { - // 1. Assert: input contains no code points greater than U+00FF. - for (let i = 0; i < input.length; i++) { - assert(input.charCodeAt(i) <= 0xFF) - } - - // 2. Return a byte sequence whose length is equal to input’s code - // point length and whose bytes have the same values as the - // values of input’s code points, in the same order - return input -} - -/** - * @see https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes - * @see https://streams.spec.whatwg.org/#read-loop - * @param {ReadableStreamDefaultReader} reader - */ -async function readAllBytes (reader) { - const bytes = [] - let byteLength = 0 - - while (true) { - const { done, value: chunk } = await reader.read() - - if (done) { - // 1. Call successSteps with bytes. - return Buffer.concat(bytes, byteLength) - } - - // 1. If chunk is not a Uint8Array object, call failureSteps - // with a TypeError and abort these steps. - if (!isUint8Array(chunk)) { - throw new TypeError('Received non-Uint8Array chunk') - } - - // 2. Append the bytes represented by chunk to bytes. - bytes.push(chunk) - byteLength += chunk.length - - // 3. Read-loop given reader, bytes, successSteps, and failureSteps. - } -} - -/** - * @see https://fetch.spec.whatwg.org/#is-local - * @param {URL} url - */ -function urlIsLocal (url) { - assert('protocol' in url) // ensure it's a url object - - const protocol = url.protocol - - return protocol === 'about:' || protocol === 'blob:' || protocol === 'data:' -} - -/** - * @param {string|URL} url - */ -function urlHasHttpsScheme (url) { - if (typeof url === 'string') { - return url.startsWith('https:') - } - - return url.protocol === 'https:' -} - -/** - * @see https://fetch.spec.whatwg.org/#http-scheme - * @param {URL} url - */ -function urlIsHttpHttpsScheme (url) { - assert('protocol' in url) // ensure it's a url object - - const protocol = url.protocol - - return protocol === 'http:' || protocol === 'https:' -} - -/** - * Fetch supports node >= 16.8.0, but Object.hasOwn was added in v16.9.0. - */ -const hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key)) - -module.exports = { - isAborted, - isCancelled, - createDeferredPromise, - ReadableStreamFrom, - toUSVString, - tryUpgradeRequestToAPotentiallyTrustworthyURL, - coarsenedSharedCurrentTime, - determineRequestsReferrer, - makePolicyContainer, - clonePolicyContainer, - appendFetchMetadata, - appendRequestOriginHeader, - TAOCheck, - corsCheck, - crossOriginResourcePolicyCheck, - createOpaqueTimingInfo, - setRequestReferrerPolicyOnRedirect, - isValidHTTPToken, - requestBadPort, - requestCurrentURL, - responseURL, - responseLocationURL, - isBlobLike, - isURLPotentiallyTrustworthy, - isValidReasonPhrase, - sameOrigin, - normalizeMethod, - serializeJavascriptValueToJSONString, - makeIterator, - isValidHeaderName, - isValidHeaderValue, - hasOwn, - isErrorLike, - fullyReadBody, - bytesMatch, - isReadableStreamLike, - readableStreamClose, - isomorphicEncode, - isomorphicDecode, - urlIsLocal, - urlHasHttpsScheme, - urlIsHttpHttpsScheme, - readAllBytes, - normalizeMethodRecord, - parseMetadata -} - - -/***/ }), - -/***/ 4222: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { types } = __nccwpck_require__(9023) -const { hasOwn, toUSVString } = __nccwpck_require__(5523) - -/** @type {import('../../types/webidl').Webidl} */ -const webidl = {} -webidl.converters = {} -webidl.util = {} -webidl.errors = {} - -webidl.errors.exception = function (message) { - return new TypeError(`${message.header}: ${message.message}`) -} - -webidl.errors.conversionFailed = function (context) { - const plural = context.types.length === 1 ? '' : ' one of' - const message = - `${context.argument} could not be converted to` + - `${plural}: ${context.types.join(', ')}.` - - return webidl.errors.exception({ - header: context.prefix, - message - }) -} - -webidl.errors.invalidArgument = function (context) { - return webidl.errors.exception({ - header: context.prefix, - message: `"${context.value}" is an invalid ${context.type}.` - }) -} - -// https://webidl.spec.whatwg.org/#implements -webidl.brandCheck = function (V, I, opts = undefined) { - if (opts?.strict !== false && !(V instanceof I)) { - throw new TypeError('Illegal invocation') - } else { - return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag] - } -} - -webidl.argumentLengthCheck = function ({ length }, min, ctx) { - if (length < min) { - throw webidl.errors.exception({ - message: `${min} argument${min !== 1 ? 's' : ''} required, ` + - `but${length ? ' only' : ''} ${length} found.`, - ...ctx - }) - } -} - -webidl.illegalConstructor = function () { - throw webidl.errors.exception({ - header: 'TypeError', - message: 'Illegal constructor' - }) -} - -// https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values -webidl.util.Type = function (V) { - switch (typeof V) { - case 'undefined': return 'Undefined' - case 'boolean': return 'Boolean' - case 'string': return 'String' - case 'symbol': return 'Symbol' - case 'number': return 'Number' - case 'bigint': return 'BigInt' - case 'function': - case 'object': { - if (V === null) { - return 'Null' - } - - return 'Object' - } - } -} - -// https://webidl.spec.whatwg.org/#abstract-opdef-converttoint -webidl.util.ConvertToInt = function (V, bitLength, signedness, opts = {}) { - let upperBound - let lowerBound - - // 1. If bitLength is 64, then: - if (bitLength === 64) { - // 1. Let upperBound be 2^53 − 1. - upperBound = Math.pow(2, 53) - 1 - - // 2. If signedness is "unsigned", then let lowerBound be 0. - if (signedness === 'unsigned') { - lowerBound = 0 - } else { - // 3. Otherwise let lowerBound be −2^53 + 1. - lowerBound = Math.pow(-2, 53) + 1 - } - } else if (signedness === 'unsigned') { - // 2. Otherwise, if signedness is "unsigned", then: - - // 1. Let lowerBound be 0. - lowerBound = 0 - - // 2. Let upperBound be 2^bitLength − 1. - upperBound = Math.pow(2, bitLength) - 1 - } else { - // 3. Otherwise: - - // 1. Let lowerBound be -2^bitLength − 1. - lowerBound = Math.pow(-2, bitLength) - 1 - - // 2. Let upperBound be 2^bitLength − 1 − 1. - upperBound = Math.pow(2, bitLength - 1) - 1 - } - - // 4. Let x be ? ToNumber(V). - let x = Number(V) - - // 5. If x is −0, then set x to +0. - if (x === 0) { - x = 0 - } - - // 6. If the conversion is to an IDL type associated - // with the [EnforceRange] extended attribute, then: - if (opts.enforceRange === true) { - // 1. If x is NaN, +∞, or −∞, then throw a TypeError. - if ( - Number.isNaN(x) || - x === Number.POSITIVE_INFINITY || - x === Number.NEGATIVE_INFINITY - ) { - throw webidl.errors.exception({ - header: 'Integer conversion', - message: `Could not convert ${V} to an integer.` - }) - } - - // 2. Set x to IntegerPart(x). - x = webidl.util.IntegerPart(x) - - // 3. If x < lowerBound or x > upperBound, then - // throw a TypeError. - if (x < lowerBound || x > upperBound) { - throw webidl.errors.exception({ - header: 'Integer conversion', - message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` - }) - } - - // 4. Return x. - return x - } - - // 7. If x is not NaN and the conversion is to an IDL - // type associated with the [Clamp] extended - // attribute, then: - if (!Number.isNaN(x) && opts.clamp === true) { - // 1. Set x to min(max(x, lowerBound), upperBound). - x = Math.min(Math.max(x, lowerBound), upperBound) - - // 2. Round x to the nearest integer, choosing the - // even integer if it lies halfway between two, - // and choosing +0 rather than −0. - if (Math.floor(x) % 2 === 0) { - x = Math.floor(x) - } else { - x = Math.ceil(x) - } - - // 3. Return x. - return x - } - - // 8. If x is NaN, +0, +∞, or −∞, then return +0. - if ( - Number.isNaN(x) || - (x === 0 && Object.is(0, x)) || - x === Number.POSITIVE_INFINITY || - x === Number.NEGATIVE_INFINITY - ) { - return 0 - } - - // 9. Set x to IntegerPart(x). - x = webidl.util.IntegerPart(x) - - // 10. Set x to x modulo 2^bitLength. - x = x % Math.pow(2, bitLength) - - // 11. If signedness is "signed" and x ≥ 2^bitLength − 1, - // then return x − 2^bitLength. - if (signedness === 'signed' && x >= Math.pow(2, bitLength) - 1) { - return x - Math.pow(2, bitLength) - } - - // 12. Otherwise, return x. - return x -} - -// https://webidl.spec.whatwg.org/#abstract-opdef-integerpart -webidl.util.IntegerPart = function (n) { - // 1. Let r be floor(abs(n)). - const r = Math.floor(Math.abs(n)) - - // 2. If n < 0, then return -1 × r. - if (n < 0) { - return -1 * r - } - - // 3. Otherwise, return r. - return r -} - -// https://webidl.spec.whatwg.org/#es-sequence -webidl.sequenceConverter = function (converter) { - return (V) => { - // 1. If Type(V) is not Object, throw a TypeError. - if (webidl.util.Type(V) !== 'Object') { - throw webidl.errors.exception({ - header: 'Sequence', - message: `Value of type ${webidl.util.Type(V)} is not an Object.` - }) - } - - // 2. Let method be ? GetMethod(V, @@iterator). - /** @type {Generator} */ - const method = V?.[Symbol.iterator]?.() - const seq = [] - - // 3. If method is undefined, throw a TypeError. - if ( - method === undefined || - typeof method.next !== 'function' - ) { - throw webidl.errors.exception({ - header: 'Sequence', - message: 'Object is not an iterator.' - }) - } - - // https://webidl.spec.whatwg.org/#create-sequence-from-iterable - while (true) { - const { done, value } = method.next() - - if (done) { - break - } - - seq.push(converter(value)) - } - - return seq - } -} - -// https://webidl.spec.whatwg.org/#es-to-record -webidl.recordConverter = function (keyConverter, valueConverter) { - return (O) => { - // 1. If Type(O) is not Object, throw a TypeError. - if (webidl.util.Type(O) !== 'Object') { - throw webidl.errors.exception({ - header: 'Record', - message: `Value of type ${webidl.util.Type(O)} is not an Object.` - }) - } - - // 2. Let result be a new empty instance of record. - const result = {} - - if (!types.isProxy(O)) { - // Object.keys only returns enumerable properties - const keys = Object.keys(O) - - for (const key of keys) { - // 1. Let typedKey be key converted to an IDL value of type K. - const typedKey = keyConverter(key) - - // 2. Let value be ? Get(O, key). - // 3. Let typedValue be value converted to an IDL value of type V. - const typedValue = valueConverter(O[key]) - - // 4. Set result[typedKey] to typedValue. - result[typedKey] = typedValue - } - - // 5. Return result. - return result - } - - // 3. Let keys be ? O.[[OwnPropertyKeys]](). - const keys = Reflect.ownKeys(O) - - // 4. For each key of keys. - for (const key of keys) { - // 1. Let desc be ? O.[[GetOwnProperty]](key). - const desc = Reflect.getOwnPropertyDescriptor(O, key) - - // 2. If desc is not undefined and desc.[[Enumerable]] is true: - if (desc?.enumerable) { - // 1. Let typedKey be key converted to an IDL value of type K. - const typedKey = keyConverter(key) - - // 2. Let value be ? Get(O, key). - // 3. Let typedValue be value converted to an IDL value of type V. - const typedValue = valueConverter(O[key]) - - // 4. Set result[typedKey] to typedValue. - result[typedKey] = typedValue - } - } - - // 5. Return result. - return result - } -} - -webidl.interfaceConverter = function (i) { - return (V, opts = {}) => { - if (opts.strict !== false && !(V instanceof i)) { - throw webidl.errors.exception({ - header: i.name, - message: `Expected ${V} to be an instance of ${i.name}.` - }) - } - - return V - } -} - -webidl.dictionaryConverter = function (converters) { - return (dictionary) => { - const type = webidl.util.Type(dictionary) - const dict = {} - - if (type === 'Null' || type === 'Undefined') { - return dict - } else if (type !== 'Object') { - throw webidl.errors.exception({ - header: 'Dictionary', - message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` - }) - } - - for (const options of converters) { - const { key, defaultValue, required, converter } = options - - if (required === true) { - if (!hasOwn(dictionary, key)) { - throw webidl.errors.exception({ - header: 'Dictionary', - message: `Missing required key "${key}".` - }) - } - } - - let value = dictionary[key] - const hasDefault = hasOwn(options, 'defaultValue') - - // Only use defaultValue if value is undefined and - // a defaultValue options was provided. - if (hasDefault && value !== null) { - value = value ?? defaultValue - } - - // A key can be optional and have no default value. - // When this happens, do not perform a conversion, - // and do not assign the key a value. - if (required || hasDefault || value !== undefined) { - value = converter(value) - - if ( - options.allowedValues && - !options.allowedValues.includes(value) - ) { - throw webidl.errors.exception({ - header: 'Dictionary', - message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(', ')}.` - }) - } - - dict[key] = value - } - } - - return dict - } -} - -webidl.nullableConverter = function (converter) { - return (V) => { - if (V === null) { - return V - } - - return converter(V) - } -} - -// https://webidl.spec.whatwg.org/#es-DOMString -webidl.converters.DOMString = function (V, opts = {}) { - // 1. If V is null and the conversion is to an IDL type - // associated with the [LegacyNullToEmptyString] - // extended attribute, then return the DOMString value - // that represents the empty string. - if (V === null && opts.legacyNullToEmptyString) { - return '' - } - - // 2. Let x be ? ToString(V). - if (typeof V === 'symbol') { - throw new TypeError('Could not convert argument of type symbol to string.') - } - - // 3. Return the IDL DOMString value that represents the - // same sequence of code units as the one the - // ECMAScript String value x represents. - return String(V) -} - -// https://webidl.spec.whatwg.org/#es-ByteString -webidl.converters.ByteString = function (V) { - // 1. Let x be ? ToString(V). - // Note: DOMString converter perform ? ToString(V) - const x = webidl.converters.DOMString(V) - - // 2. If the value of any element of x is greater than - // 255, then throw a TypeError. - for (let index = 0; index < x.length; index++) { - if (x.charCodeAt(index) > 255) { - throw new TypeError( - 'Cannot convert argument to a ByteString because the character at ' + - `index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.` - ) - } - } - - // 3. Return an IDL ByteString value whose length is the - // length of x, and where the value of each element is - // the value of the corresponding element of x. - return x -} - -// https://webidl.spec.whatwg.org/#es-USVString -webidl.converters.USVString = toUSVString - -// https://webidl.spec.whatwg.org/#es-boolean -webidl.converters.boolean = function (V) { - // 1. Let x be the result of computing ToBoolean(V). - const x = Boolean(V) - - // 2. Return the IDL boolean value that is the one that represents - // the same truth value as the ECMAScript Boolean value x. - return x -} - -// https://webidl.spec.whatwg.org/#es-any -webidl.converters.any = function (V) { - return V -} - -// https://webidl.spec.whatwg.org/#es-long-long -webidl.converters['long long'] = function (V) { - // 1. Let x be ? ConvertToInt(V, 64, "signed"). - const x = webidl.util.ConvertToInt(V, 64, 'signed') - - // 2. Return the IDL long long value that represents - // the same numeric value as x. - return x -} - -// https://webidl.spec.whatwg.org/#es-unsigned-long-long -webidl.converters['unsigned long long'] = function (V) { - // 1. Let x be ? ConvertToInt(V, 64, "unsigned"). - const x = webidl.util.ConvertToInt(V, 64, 'unsigned') - - // 2. Return the IDL unsigned long long value that - // represents the same numeric value as x. - return x -} - -// https://webidl.spec.whatwg.org/#es-unsigned-long -webidl.converters['unsigned long'] = function (V) { - // 1. Let x be ? ConvertToInt(V, 32, "unsigned"). - const x = webidl.util.ConvertToInt(V, 32, 'unsigned') - - // 2. Return the IDL unsigned long value that - // represents the same numeric value as x. - return x -} - -// https://webidl.spec.whatwg.org/#es-unsigned-short -webidl.converters['unsigned short'] = function (V, opts) { - // 1. Let x be ? ConvertToInt(V, 16, "unsigned"). - const x = webidl.util.ConvertToInt(V, 16, 'unsigned', opts) - - // 2. Return the IDL unsigned short value that represents - // the same numeric value as x. - return x -} - -// https://webidl.spec.whatwg.org/#idl-ArrayBuffer -webidl.converters.ArrayBuffer = function (V, opts = {}) { - // 1. If Type(V) is not Object, or V does not have an - // [[ArrayBufferData]] internal slot, then throw a - // TypeError. - // see: https://tc39.es/ecma262/#sec-properties-of-the-arraybuffer-instances - // see: https://tc39.es/ecma262/#sec-properties-of-the-sharedarraybuffer-instances - if ( - webidl.util.Type(V) !== 'Object' || - !types.isAnyArrayBuffer(V) - ) { - throw webidl.errors.conversionFailed({ - prefix: `${V}`, - argument: `${V}`, - types: ['ArrayBuffer'] - }) - } - - // 2. If the conversion is not to an IDL type associated - // with the [AllowShared] extended attribute, and - // IsSharedArrayBuffer(V) is true, then throw a - // TypeError. - if (opts.allowShared === false && types.isSharedArrayBuffer(V)) { - throw webidl.errors.exception({ - header: 'ArrayBuffer', - message: 'SharedArrayBuffer is not allowed.' - }) - } - - // 3. If the conversion is not to an IDL type associated - // with the [AllowResizable] extended attribute, and - // IsResizableArrayBuffer(V) is true, then throw a - // TypeError. - // Note: resizable ArrayBuffers are currently a proposal. - - // 4. Return the IDL ArrayBuffer value that is a - // reference to the same object as V. - return V -} - -webidl.converters.TypedArray = function (V, T, opts = {}) { - // 1. Let T be the IDL type V is being converted to. - - // 2. If Type(V) is not Object, or V does not have a - // [[TypedArrayName]] internal slot with a value - // equal to T’s name, then throw a TypeError. - if ( - webidl.util.Type(V) !== 'Object' || - !types.isTypedArray(V) || - V.constructor.name !== T.name - ) { - throw webidl.errors.conversionFailed({ - prefix: `${T.name}`, - argument: `${V}`, - types: [T.name] - }) - } - - // 3. If the conversion is not to an IDL type associated - // with the [AllowShared] extended attribute, and - // IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is - // true, then throw a TypeError. - if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { - throw webidl.errors.exception({ - header: 'ArrayBuffer', - message: 'SharedArrayBuffer is not allowed.' - }) - } - - // 4. If the conversion is not to an IDL type associated - // with the [AllowResizable] extended attribute, and - // IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is - // true, then throw a TypeError. - // Note: resizable array buffers are currently a proposal - - // 5. Return the IDL value of type T that is a reference - // to the same object as V. - return V -} - -webidl.converters.DataView = function (V, opts = {}) { - // 1. If Type(V) is not Object, or V does not have a - // [[DataView]] internal slot, then throw a TypeError. - if (webidl.util.Type(V) !== 'Object' || !types.isDataView(V)) { - throw webidl.errors.exception({ - header: 'DataView', - message: 'Object is not a DataView.' - }) - } - - // 2. If the conversion is not to an IDL type associated - // with the [AllowShared] extended attribute, and - // IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true, - // then throw a TypeError. - if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { - throw webidl.errors.exception({ - header: 'ArrayBuffer', - message: 'SharedArrayBuffer is not allowed.' - }) - } - - // 3. If the conversion is not to an IDL type associated - // with the [AllowResizable] extended attribute, and - // IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is - // true, then throw a TypeError. - // Note: resizable ArrayBuffers are currently a proposal - - // 4. Return the IDL DataView value that is a reference - // to the same object as V. - return V -} - -// https://webidl.spec.whatwg.org/#BufferSource -webidl.converters.BufferSource = function (V, opts = {}) { - if (types.isAnyArrayBuffer(V)) { - return webidl.converters.ArrayBuffer(V, opts) - } - - if (types.isTypedArray(V)) { - return webidl.converters.TypedArray(V, V.constructor) - } - - if (types.isDataView(V)) { - return webidl.converters.DataView(V, opts) - } - - throw new TypeError(`Could not convert ${V} to a BufferSource.`) -} - -webidl.converters['sequence'] = webidl.sequenceConverter( - webidl.converters.ByteString -) - -webidl.converters['sequence>'] = webidl.sequenceConverter( - webidl.converters['sequence'] -) - -webidl.converters['record'] = webidl.recordConverter( - webidl.converters.ByteString, - webidl.converters.ByteString -) - -module.exports = { - webidl -} - - -/***/ }), - -/***/ 396: -/***/ ((module) => { - -"use strict"; - - -/** - * @see https://encoding.spec.whatwg.org/#concept-encoding-get - * @param {string|undefined} label - */ -function getEncoding (label) { - if (!label) { - return 'failure' - } - - // 1. Remove any leading and trailing ASCII whitespace from label. - // 2. If label is an ASCII case-insensitive match for any of the - // labels listed in the table below, then return the - // corresponding encoding; otherwise return failure. - switch (label.trim().toLowerCase()) { - case 'unicode-1-1-utf-8': - case 'unicode11utf8': - case 'unicode20utf8': - case 'utf-8': - case 'utf8': - case 'x-unicode20utf8': - return 'UTF-8' - case '866': - case 'cp866': - case 'csibm866': - case 'ibm866': - return 'IBM866' - case 'csisolatin2': - case 'iso-8859-2': - case 'iso-ir-101': - case 'iso8859-2': - case 'iso88592': - case 'iso_8859-2': - case 'iso_8859-2:1987': - case 'l2': - case 'latin2': - return 'ISO-8859-2' - case 'csisolatin3': - case 'iso-8859-3': - case 'iso-ir-109': - case 'iso8859-3': - case 'iso88593': - case 'iso_8859-3': - case 'iso_8859-3:1988': - case 'l3': - case 'latin3': - return 'ISO-8859-3' - case 'csisolatin4': - case 'iso-8859-4': - case 'iso-ir-110': - case 'iso8859-4': - case 'iso88594': - case 'iso_8859-4': - case 'iso_8859-4:1988': - case 'l4': - case 'latin4': - return 'ISO-8859-4' - case 'csisolatincyrillic': - case 'cyrillic': - case 'iso-8859-5': - case 'iso-ir-144': - case 'iso8859-5': - case 'iso88595': - case 'iso_8859-5': - case 'iso_8859-5:1988': - return 'ISO-8859-5' - case 'arabic': - case 'asmo-708': - case 'csiso88596e': - case 'csiso88596i': - case 'csisolatinarabic': - case 'ecma-114': - case 'iso-8859-6': - case 'iso-8859-6-e': - case 'iso-8859-6-i': - case 'iso-ir-127': - case 'iso8859-6': - case 'iso88596': - case 'iso_8859-6': - case 'iso_8859-6:1987': - return 'ISO-8859-6' - case 'csisolatingreek': - case 'ecma-118': - case 'elot_928': - case 'greek': - case 'greek8': - case 'iso-8859-7': - case 'iso-ir-126': - case 'iso8859-7': - case 'iso88597': - case 'iso_8859-7': - case 'iso_8859-7:1987': - case 'sun_eu_greek': - return 'ISO-8859-7' - case 'csiso88598e': - case 'csisolatinhebrew': - case 'hebrew': - case 'iso-8859-8': - case 'iso-8859-8-e': - case 'iso-ir-138': - case 'iso8859-8': - case 'iso88598': - case 'iso_8859-8': - case 'iso_8859-8:1988': - case 'visual': - return 'ISO-8859-8' - case 'csiso88598i': - case 'iso-8859-8-i': - case 'logical': - return 'ISO-8859-8-I' - case 'csisolatin6': - case 'iso-8859-10': - case 'iso-ir-157': - case 'iso8859-10': - case 'iso885910': - case 'l6': - case 'latin6': - return 'ISO-8859-10' - case 'iso-8859-13': - case 'iso8859-13': - case 'iso885913': - return 'ISO-8859-13' - case 'iso-8859-14': - case 'iso8859-14': - case 'iso885914': - return 'ISO-8859-14' - case 'csisolatin9': - case 'iso-8859-15': - case 'iso8859-15': - case 'iso885915': - case 'iso_8859-15': - case 'l9': - return 'ISO-8859-15' - case 'iso-8859-16': - return 'ISO-8859-16' - case 'cskoi8r': - case 'koi': - case 'koi8': - case 'koi8-r': - case 'koi8_r': - return 'KOI8-R' - case 'koi8-ru': - case 'koi8-u': - return 'KOI8-U' - case 'csmacintosh': - case 'mac': - case 'macintosh': - case 'x-mac-roman': - return 'macintosh' - case 'iso-8859-11': - case 'iso8859-11': - case 'iso885911': - case 'tis-620': - case 'windows-874': - return 'windows-874' - case 'cp1250': - case 'windows-1250': - case 'x-cp1250': - return 'windows-1250' - case 'cp1251': - case 'windows-1251': - case 'x-cp1251': - return 'windows-1251' - case 'ansi_x3.4-1968': - case 'ascii': - case 'cp1252': - case 'cp819': - case 'csisolatin1': - case 'ibm819': - case 'iso-8859-1': - case 'iso-ir-100': - case 'iso8859-1': - case 'iso88591': - case 'iso_8859-1': - case 'iso_8859-1:1987': - case 'l1': - case 'latin1': - case 'us-ascii': - case 'windows-1252': - case 'x-cp1252': - return 'windows-1252' - case 'cp1253': - case 'windows-1253': - case 'x-cp1253': - return 'windows-1253' - case 'cp1254': - case 'csisolatin5': - case 'iso-8859-9': - case 'iso-ir-148': - case 'iso8859-9': - case 'iso88599': - case 'iso_8859-9': - case 'iso_8859-9:1989': - case 'l5': - case 'latin5': - case 'windows-1254': - case 'x-cp1254': - return 'windows-1254' - case 'cp1255': - case 'windows-1255': - case 'x-cp1255': - return 'windows-1255' - case 'cp1256': - case 'windows-1256': - case 'x-cp1256': - return 'windows-1256' - case 'cp1257': - case 'windows-1257': - case 'x-cp1257': - return 'windows-1257' - case 'cp1258': - case 'windows-1258': - case 'x-cp1258': - return 'windows-1258' - case 'x-mac-cyrillic': - case 'x-mac-ukrainian': - return 'x-mac-cyrillic' - case 'chinese': - case 'csgb2312': - case 'csiso58gb231280': - case 'gb2312': - case 'gb_2312': - case 'gb_2312-80': - case 'gbk': - case 'iso-ir-58': - case 'x-gbk': - return 'GBK' - case 'gb18030': - return 'gb18030' - case 'big5': - case 'big5-hkscs': - case 'cn-big5': - case 'csbig5': - case 'x-x-big5': - return 'Big5' - case 'cseucpkdfmtjapanese': - case 'euc-jp': - case 'x-euc-jp': - return 'EUC-JP' - case 'csiso2022jp': - case 'iso-2022-jp': - return 'ISO-2022-JP' - case 'csshiftjis': - case 'ms932': - case 'ms_kanji': - case 'shift-jis': - case 'shift_jis': - case 'sjis': - case 'windows-31j': - case 'x-sjis': - return 'Shift_JIS' - case 'cseuckr': - case 'csksc56011987': - case 'euc-kr': - case 'iso-ir-149': - case 'korean': - case 'ks_c_5601-1987': - case 'ks_c_5601-1989': - case 'ksc5601': - case 'ksc_5601': - case 'windows-949': - return 'EUC-KR' - case 'csiso2022kr': - case 'hz-gb-2312': - case 'iso-2022-cn': - case 'iso-2022-cn-ext': - case 'iso-2022-kr': - case 'replacement': - return 'replacement' - case 'unicodefffe': - case 'utf-16be': - return 'UTF-16BE' - case 'csunicode': - case 'iso-10646-ucs-2': - case 'ucs-2': - case 'unicode': - case 'unicodefeff': - case 'utf-16': - case 'utf-16le': - return 'UTF-16LE' - case 'x-user-defined': - return 'x-user-defined' - default: return 'failure' - } -} - -module.exports = { - getEncoding -} - - -/***/ }), - -/***/ 2160: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { - staticPropertyDescriptors, - readOperation, - fireAProgressEvent -} = __nccwpck_require__(165) -const { - kState, - kError, - kResult, - kEvents, - kAborted -} = __nccwpck_require__(6812) -const { webidl } = __nccwpck_require__(4222) -const { kEnumerableProperty } = __nccwpck_require__(3440) - -class FileReader extends EventTarget { - constructor () { - super() - - this[kState] = 'empty' - this[kResult] = null - this[kError] = null - this[kEvents] = { - loadend: null, - error: null, - abort: null, - load: null, - progress: null, - loadstart: null - } - } - - /** - * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer - * @param {import('buffer').Blob} blob - */ - readAsArrayBuffer (blob) { - webidl.brandCheck(this, FileReader) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FileReader.readAsArrayBuffer' }) - - blob = webidl.converters.Blob(blob, { strict: false }) - - // The readAsArrayBuffer(blob) method, when invoked, - // must initiate a read operation for blob with ArrayBuffer. - readOperation(this, blob, 'ArrayBuffer') - } - - /** - * @see https://w3c.github.io/FileAPI/#readAsBinaryString - * @param {import('buffer').Blob} blob - */ - readAsBinaryString (blob) { - webidl.brandCheck(this, FileReader) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FileReader.readAsBinaryString' }) - - blob = webidl.converters.Blob(blob, { strict: false }) - - // The readAsBinaryString(blob) method, when invoked, - // must initiate a read operation for blob with BinaryString. - readOperation(this, blob, 'BinaryString') - } - - /** - * @see https://w3c.github.io/FileAPI/#readAsDataText - * @param {import('buffer').Blob} blob - * @param {string?} encoding - */ - readAsText (blob, encoding = undefined) { - webidl.brandCheck(this, FileReader) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FileReader.readAsText' }) - - blob = webidl.converters.Blob(blob, { strict: false }) - - if (encoding !== undefined) { - encoding = webidl.converters.DOMString(encoding) - } - - // The readAsText(blob, encoding) method, when invoked, - // must initiate a read operation for blob with Text and encoding. - readOperation(this, blob, 'Text', encoding) - } - - /** - * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL - * @param {import('buffer').Blob} blob - */ - readAsDataURL (blob) { - webidl.brandCheck(this, FileReader) - - webidl.argumentLengthCheck(arguments, 1, { header: 'FileReader.readAsDataURL' }) - - blob = webidl.converters.Blob(blob, { strict: false }) - - // The readAsDataURL(blob) method, when invoked, must - // initiate a read operation for blob with DataURL. - readOperation(this, blob, 'DataURL') - } - - /** - * @see https://w3c.github.io/FileAPI/#dfn-abort - */ - abort () { - // 1. If this's state is "empty" or if this's state is - // "done" set this's result to null and terminate - // this algorithm. - if (this[kState] === 'empty' || this[kState] === 'done') { - this[kResult] = null - return - } - - // 2. If this's state is "loading" set this's state to - // "done" and set this's result to null. - if (this[kState] === 'loading') { - this[kState] = 'done' - this[kResult] = null - } - - // 3. If there are any tasks from this on the file reading - // task source in an affiliated task queue, then remove - // those tasks from that task queue. - this[kAborted] = true - - // 4. Terminate the algorithm for the read method being processed. - // TODO - - // 5. Fire a progress event called abort at this. - fireAProgressEvent('abort', this) - - // 6. If this's state is not "loading", fire a progress - // event called loadend at this. - if (this[kState] !== 'loading') { - fireAProgressEvent('loadend', this) - } - } - - /** - * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate - */ - get readyState () { - webidl.brandCheck(this, FileReader) - - switch (this[kState]) { - case 'empty': return this.EMPTY - case 'loading': return this.LOADING - case 'done': return this.DONE - } - } - - /** - * @see https://w3c.github.io/FileAPI/#dom-filereader-result - */ - get result () { - webidl.brandCheck(this, FileReader) - - // The result attribute’s getter, when invoked, must return - // this's result. - return this[kResult] - } - - /** - * @see https://w3c.github.io/FileAPI/#dom-filereader-error - */ - get error () { - webidl.brandCheck(this, FileReader) - - // The error attribute’s getter, when invoked, must return - // this's error. - return this[kError] - } - - get onloadend () { - webidl.brandCheck(this, FileReader) - - return this[kEvents].loadend - } - - set onloadend (fn) { - webidl.brandCheck(this, FileReader) - - if (this[kEvents].loadend) { - this.removeEventListener('loadend', this[kEvents].loadend) - } - - if (typeof fn === 'function') { - this[kEvents].loadend = fn - this.addEventListener('loadend', fn) - } else { - this[kEvents].loadend = null - } - } - - get onerror () { - webidl.brandCheck(this, FileReader) - - return this[kEvents].error - } - - set onerror (fn) { - webidl.brandCheck(this, FileReader) - - if (this[kEvents].error) { - this.removeEventListener('error', this[kEvents].error) - } - - if (typeof fn === 'function') { - this[kEvents].error = fn - this.addEventListener('error', fn) - } else { - this[kEvents].error = null - } - } - - get onloadstart () { - webidl.brandCheck(this, FileReader) - - return this[kEvents].loadstart - } - - set onloadstart (fn) { - webidl.brandCheck(this, FileReader) - - if (this[kEvents].loadstart) { - this.removeEventListener('loadstart', this[kEvents].loadstart) - } - - if (typeof fn === 'function') { - this[kEvents].loadstart = fn - this.addEventListener('loadstart', fn) - } else { - this[kEvents].loadstart = null - } - } - - get onprogress () { - webidl.brandCheck(this, FileReader) - - return this[kEvents].progress - } - - set onprogress (fn) { - webidl.brandCheck(this, FileReader) - - if (this[kEvents].progress) { - this.removeEventListener('progress', this[kEvents].progress) - } - - if (typeof fn === 'function') { - this[kEvents].progress = fn - this.addEventListener('progress', fn) - } else { - this[kEvents].progress = null - } - } - - get onload () { - webidl.brandCheck(this, FileReader) - - return this[kEvents].load - } - - set onload (fn) { - webidl.brandCheck(this, FileReader) - - if (this[kEvents].load) { - this.removeEventListener('load', this[kEvents].load) - } - - if (typeof fn === 'function') { - this[kEvents].load = fn - this.addEventListener('load', fn) - } else { - this[kEvents].load = null - } - } - - get onabort () { - webidl.brandCheck(this, FileReader) - - return this[kEvents].abort - } - - set onabort (fn) { - webidl.brandCheck(this, FileReader) - - if (this[kEvents].abort) { - this.removeEventListener('abort', this[kEvents].abort) - } - - if (typeof fn === 'function') { - this[kEvents].abort = fn - this.addEventListener('abort', fn) - } else { - this[kEvents].abort = null - } - } -} - -// https://w3c.github.io/FileAPI/#dom-filereader-empty -FileReader.EMPTY = FileReader.prototype.EMPTY = 0 -// https://w3c.github.io/FileAPI/#dom-filereader-loading -FileReader.LOADING = FileReader.prototype.LOADING = 1 -// https://w3c.github.io/FileAPI/#dom-filereader-done -FileReader.DONE = FileReader.prototype.DONE = 2 - -Object.defineProperties(FileReader.prototype, { - EMPTY: staticPropertyDescriptors, - LOADING: staticPropertyDescriptors, - DONE: staticPropertyDescriptors, - readAsArrayBuffer: kEnumerableProperty, - readAsBinaryString: kEnumerableProperty, - readAsText: kEnumerableProperty, - readAsDataURL: kEnumerableProperty, - abort: kEnumerableProperty, - readyState: kEnumerableProperty, - result: kEnumerableProperty, - error: kEnumerableProperty, - onloadstart: kEnumerableProperty, - onprogress: kEnumerableProperty, - onload: kEnumerableProperty, - onabort: kEnumerableProperty, - onerror: kEnumerableProperty, - onloadend: kEnumerableProperty, - [Symbol.toStringTag]: { - value: 'FileReader', - writable: false, - enumerable: false, - configurable: true - } -}) - -Object.defineProperties(FileReader, { - EMPTY: staticPropertyDescriptors, - LOADING: staticPropertyDescriptors, - DONE: staticPropertyDescriptors -}) - -module.exports = { - FileReader -} - - -/***/ }), - -/***/ 5976: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { webidl } = __nccwpck_require__(4222) - -const kState = Symbol('ProgressEvent state') - -/** - * @see https://xhr.spec.whatwg.org/#progressevent - */ -class ProgressEvent extends Event { - constructor (type, eventInitDict = {}) { - type = webidl.converters.DOMString(type) - eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {}) - - super(type, eventInitDict) - - this[kState] = { - lengthComputable: eventInitDict.lengthComputable, - loaded: eventInitDict.loaded, - total: eventInitDict.total - } - } - - get lengthComputable () { - webidl.brandCheck(this, ProgressEvent) - - return this[kState].lengthComputable - } - - get loaded () { - webidl.brandCheck(this, ProgressEvent) - - return this[kState].loaded - } - - get total () { - webidl.brandCheck(this, ProgressEvent) - - return this[kState].total - } -} - -webidl.converters.ProgressEventInit = webidl.dictionaryConverter([ - { - key: 'lengthComputable', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'loaded', - converter: webidl.converters['unsigned long long'], - defaultValue: 0 - }, - { - key: 'total', - converter: webidl.converters['unsigned long long'], - defaultValue: 0 - }, - { - key: 'bubbles', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'cancelable', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'composed', - converter: webidl.converters.boolean, - defaultValue: false - } -]) - -module.exports = { - ProgressEvent -} - - -/***/ }), - -/***/ 6812: -/***/ ((module) => { - -"use strict"; - - -module.exports = { - kState: Symbol('FileReader state'), - kResult: Symbol('FileReader result'), - kError: Symbol('FileReader error'), - kLastProgressEventFired: Symbol('FileReader last progress event fired timestamp'), - kEvents: Symbol('FileReader events'), - kAborted: Symbol('FileReader aborted') -} - - -/***/ }), - -/***/ 165: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { - kState, - kError, - kResult, - kAborted, - kLastProgressEventFired -} = __nccwpck_require__(6812) -const { ProgressEvent } = __nccwpck_require__(5976) -const { getEncoding } = __nccwpck_require__(396) -const { DOMException } = __nccwpck_require__(7326) -const { serializeAMimeType, parseMIMEType } = __nccwpck_require__(4322) -const { types } = __nccwpck_require__(9023) -const { StringDecoder } = __nccwpck_require__(3193) -const { btoa } = __nccwpck_require__(181) - -/** @type {PropertyDescriptor} */ -const staticPropertyDescriptors = { - enumerable: true, - writable: false, - configurable: false -} - -/** - * @see https://w3c.github.io/FileAPI/#readOperation - * @param {import('./filereader').FileReader} fr - * @param {import('buffer').Blob} blob - * @param {string} type - * @param {string?} encodingName - */ -function readOperation (fr, blob, type, encodingName) { - // 1. If fr’s state is "loading", throw an InvalidStateError - // DOMException. - if (fr[kState] === 'loading') { - throw new DOMException('Invalid state', 'InvalidStateError') - } - - // 2. Set fr’s state to "loading". - fr[kState] = 'loading' - - // 3. Set fr’s result to null. - fr[kResult] = null - - // 4. Set fr’s error to null. - fr[kError] = null - - // 5. Let stream be the result of calling get stream on blob. - /** @type {import('stream/web').ReadableStream} */ - const stream = blob.stream() - - // 6. Let reader be the result of getting a reader from stream. - const reader = stream.getReader() - - // 7. Let bytes be an empty byte sequence. - /** @type {Uint8Array[]} */ - const bytes = [] - - // 8. Let chunkPromise be the result of reading a chunk from - // stream with reader. - let chunkPromise = reader.read() - - // 9. Let isFirstChunk be true. - let isFirstChunk = true - - // 10. In parallel, while true: - // Note: "In parallel" just means non-blocking - // Note 2: readOperation itself cannot be async as double - // reading the body would then reject the promise, instead - // of throwing an error. - ;(async () => { - while (!fr[kAborted]) { - // 1. Wait for chunkPromise to be fulfilled or rejected. - try { - const { done, value } = await chunkPromise - - // 2. If chunkPromise is fulfilled, and isFirstChunk is - // true, queue a task to fire a progress event called - // loadstart at fr. - if (isFirstChunk && !fr[kAborted]) { - queueMicrotask(() => { - fireAProgressEvent('loadstart', fr) - }) - } - - // 3. Set isFirstChunk to false. - isFirstChunk = false - - // 4. If chunkPromise is fulfilled with an object whose - // done property is false and whose value property is - // a Uint8Array object, run these steps: - if (!done && types.isUint8Array(value)) { - // 1. Let bs be the byte sequence represented by the - // Uint8Array object. - - // 2. Append bs to bytes. - bytes.push(value) - - // 3. If roughly 50ms have passed since these steps - // were last invoked, queue a task to fire a - // progress event called progress at fr. - if ( - ( - fr[kLastProgressEventFired] === undefined || - Date.now() - fr[kLastProgressEventFired] >= 50 - ) && - !fr[kAborted] - ) { - fr[kLastProgressEventFired] = Date.now() - queueMicrotask(() => { - fireAProgressEvent('progress', fr) - }) - } - - // 4. Set chunkPromise to the result of reading a - // chunk from stream with reader. - chunkPromise = reader.read() - } else if (done) { - // 5. Otherwise, if chunkPromise is fulfilled with an - // object whose done property is true, queue a task - // to run the following steps and abort this algorithm: - queueMicrotask(() => { - // 1. Set fr’s state to "done". - fr[kState] = 'done' - - // 2. Let result be the result of package data given - // bytes, type, blob’s type, and encodingName. - try { - const result = packageData(bytes, type, blob.type, encodingName) - - // 4. Else: - - if (fr[kAborted]) { - return - } - - // 1. Set fr’s result to result. - fr[kResult] = result - - // 2. Fire a progress event called load at the fr. - fireAProgressEvent('load', fr) - } catch (error) { - // 3. If package data threw an exception error: - - // 1. Set fr’s error to error. - fr[kError] = error - - // 2. Fire a progress event called error at fr. - fireAProgressEvent('error', fr) - } - - // 5. If fr’s state is not "loading", fire a progress - // event called loadend at the fr. - if (fr[kState] !== 'loading') { - fireAProgressEvent('loadend', fr) - } - }) - - break - } - } catch (error) { - if (fr[kAborted]) { - return - } - - // 6. Otherwise, if chunkPromise is rejected with an - // error error, queue a task to run the following - // steps and abort this algorithm: - queueMicrotask(() => { - // 1. Set fr’s state to "done". - fr[kState] = 'done' - - // 2. Set fr’s error to error. - fr[kError] = error - - // 3. Fire a progress event called error at fr. - fireAProgressEvent('error', fr) - - // 4. If fr’s state is not "loading", fire a progress - // event called loadend at fr. - if (fr[kState] !== 'loading') { - fireAProgressEvent('loadend', fr) - } - }) - - break - } - } - })() -} - -/** - * @see https://w3c.github.io/FileAPI/#fire-a-progress-event - * @see https://dom.spec.whatwg.org/#concept-event-fire - * @param {string} e The name of the event - * @param {import('./filereader').FileReader} reader - */ -function fireAProgressEvent (e, reader) { - // The progress event e does not bubble. e.bubbles must be false - // The progress event e is NOT cancelable. e.cancelable must be false - const event = new ProgressEvent(e, { - bubbles: false, - cancelable: false - }) - - reader.dispatchEvent(event) -} - -/** - * @see https://w3c.github.io/FileAPI/#blob-package-data - * @param {Uint8Array[]} bytes - * @param {string} type - * @param {string?} mimeType - * @param {string?} encodingName - */ -function packageData (bytes, type, mimeType, encodingName) { - // 1. A Blob has an associated package data algorithm, given - // bytes, a type, a optional mimeType, and a optional - // encodingName, which switches on type and runs the - // associated steps: - - switch (type) { - case 'DataURL': { - // 1. Return bytes as a DataURL [RFC2397] subject to - // the considerations below: - // * Use mimeType as part of the Data URL if it is - // available in keeping with the Data URL - // specification [RFC2397]. - // * If mimeType is not available return a Data URL - // without a media-type. [RFC2397]. - - // https://datatracker.ietf.org/doc/html/rfc2397#section-3 - // dataurl := "data:" [ mediatype ] [ ";base64" ] "," data - // mediatype := [ type "/" subtype ] *( ";" parameter ) - // data := *urlchar - // parameter := attribute "=" value - let dataURL = 'data:' - - const parsed = parseMIMEType(mimeType || 'application/octet-stream') - - if (parsed !== 'failure') { - dataURL += serializeAMimeType(parsed) - } - - dataURL += ';base64,' - - const decoder = new StringDecoder('latin1') - - for (const chunk of bytes) { - dataURL += btoa(decoder.write(chunk)) - } - - dataURL += btoa(decoder.end()) - - return dataURL - } - case 'Text': { - // 1. Let encoding be failure - let encoding = 'failure' - - // 2. If the encodingName is present, set encoding to the - // result of getting an encoding from encodingName. - if (encodingName) { - encoding = getEncoding(encodingName) - } - - // 3. If encoding is failure, and mimeType is present: - if (encoding === 'failure' && mimeType) { - // 1. Let type be the result of parse a MIME type - // given mimeType. - const type = parseMIMEType(mimeType) - - // 2. If type is not failure, set encoding to the result - // of getting an encoding from type’s parameters["charset"]. - if (type !== 'failure') { - encoding = getEncoding(type.parameters.get('charset')) - } - } - - // 4. If encoding is failure, then set encoding to UTF-8. - if (encoding === 'failure') { - encoding = 'UTF-8' - } - - // 5. Decode bytes using fallback encoding encoding, and - // return the result. - return decode(bytes, encoding) - } - case 'ArrayBuffer': { - // Return a new ArrayBuffer whose contents are bytes. - const sequence = combineByteSequences(bytes) - - return sequence.buffer - } - case 'BinaryString': { - // Return bytes as a binary string, in which every byte - // is represented by a code unit of equal value [0..255]. - let binaryString = '' - - const decoder = new StringDecoder('latin1') - - for (const chunk of bytes) { - binaryString += decoder.write(chunk) - } - - binaryString += decoder.end() - - return binaryString - } - } -} - -/** - * @see https://encoding.spec.whatwg.org/#decode - * @param {Uint8Array[]} ioQueue - * @param {string} encoding - */ -function decode (ioQueue, encoding) { - const bytes = combineByteSequences(ioQueue) - - // 1. Let BOMEncoding be the result of BOM sniffing ioQueue. - const BOMEncoding = BOMSniffing(bytes) - - let slice = 0 - - // 2. If BOMEncoding is non-null: - if (BOMEncoding !== null) { - // 1. Set encoding to BOMEncoding. - encoding = BOMEncoding - - // 2. Read three bytes from ioQueue, if BOMEncoding is - // UTF-8; otherwise read two bytes. - // (Do nothing with those bytes.) - slice = BOMEncoding === 'UTF-8' ? 3 : 2 - } - - // 3. Process a queue with an instance of encoding’s - // decoder, ioQueue, output, and "replacement". - - // 4. Return output. - - const sliced = bytes.slice(slice) - return new TextDecoder(encoding).decode(sliced) -} - -/** - * @see https://encoding.spec.whatwg.org/#bom-sniff - * @param {Uint8Array} ioQueue - */ -function BOMSniffing (ioQueue) { - // 1. Let BOM be the result of peeking 3 bytes from ioQueue, - // converted to a byte sequence. - const [a, b, c] = ioQueue - - // 2. For each of the rows in the table below, starting with - // the first one and going down, if BOM starts with the - // bytes given in the first column, then return the - // encoding given in the cell in the second column of that - // row. Otherwise, return null. - if (a === 0xEF && b === 0xBB && c === 0xBF) { - return 'UTF-8' - } else if (a === 0xFE && b === 0xFF) { - return 'UTF-16BE' - } else if (a === 0xFF && b === 0xFE) { - return 'UTF-16LE' - } - - return null -} - -/** - * @param {Uint8Array[]} sequences - */ -function combineByteSequences (sequences) { - const size = sequences.reduce((a, b) => { - return a + b.byteLength - }, 0) - - let offset = 0 - - return sequences.reduce((a, b) => { - a.set(b, offset) - offset += b.byteLength - return a - }, new Uint8Array(size)) -} - -module.exports = { - staticPropertyDescriptors, - readOperation, - fireAProgressEvent -} - - -/***/ }), - -/***/ 2581: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -// We include a version number for the Dispatcher API. In case of breaking changes, -// this version number must be increased to avoid conflicts. -const globalDispatcher = Symbol.for('undici.globalDispatcher.1') -const { InvalidArgumentError } = __nccwpck_require__(8707) -const Agent = __nccwpck_require__(9965) - -if (getGlobalDispatcher() === undefined) { - setGlobalDispatcher(new Agent()) -} - -function setGlobalDispatcher (agent) { - if (!agent || typeof agent.dispatch !== 'function') { - throw new InvalidArgumentError('Argument agent must implement Agent') - } - Object.defineProperty(globalThis, globalDispatcher, { - value: agent, - writable: true, - enumerable: false, - configurable: false - }) -} - -function getGlobalDispatcher () { - return globalThis[globalDispatcher] -} - -module.exports = { - setGlobalDispatcher, - getGlobalDispatcher -} - - -/***/ }), - -/***/ 8840: -/***/ ((module) => { - -"use strict"; - - -module.exports = class DecoratorHandler { - constructor (handler) { - this.handler = handler - } - - onConnect (...args) { - return this.handler.onConnect(...args) - } - - onError (...args) { - return this.handler.onError(...args) - } - - onUpgrade (...args) { - return this.handler.onUpgrade(...args) - } - - onHeaders (...args) { - return this.handler.onHeaders(...args) - } - - onData (...args) { - return this.handler.onData(...args) - } - - onComplete (...args) { - return this.handler.onComplete(...args) - } - - onBodySent (...args) { - return this.handler.onBodySent(...args) - } -} - - -/***/ }), - -/***/ 8299: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const util = __nccwpck_require__(3440) -const { kBodyUsed } = __nccwpck_require__(6443) -const assert = __nccwpck_require__(2613) -const { InvalidArgumentError } = __nccwpck_require__(8707) -const EE = __nccwpck_require__(4434) - -const redirectableStatusCodes = [300, 301, 302, 303, 307, 308] - -const kBody = Symbol('body') - -class BodyAsyncIterable { - constructor (body) { - this[kBody] = body - this[kBodyUsed] = false - } - - async * [Symbol.asyncIterator] () { - assert(!this[kBodyUsed], 'disturbed') - this[kBodyUsed] = true - yield * this[kBody] - } -} - -class RedirectHandler { - constructor (dispatch, maxRedirections, opts, handler) { - if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { - throw new InvalidArgumentError('maxRedirections must be a positive number') - } - - util.validateHandler(handler, opts.method, opts.upgrade) - - this.dispatch = dispatch - this.location = null - this.abort = null - this.opts = { ...opts, maxRedirections: 0 } // opts must be a copy - this.maxRedirections = maxRedirections - this.handler = handler - this.history = [] - - if (util.isStream(this.opts.body)) { - // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp - // so that it can be dispatched again? - // TODO (fix): Do we need 100-expect support to provide a way to do this properly? - if (util.bodyLength(this.opts.body) === 0) { - this.opts.body - .on('data', function () { - assert(false) - }) - } - - if (typeof this.opts.body.readableDidRead !== 'boolean') { - this.opts.body[kBodyUsed] = false - EE.prototype.on.call(this.opts.body, 'data', function () { - this[kBodyUsed] = true - }) - } - } else if (this.opts.body && typeof this.opts.body.pipeTo === 'function') { - // TODO (fix): We can't access ReadableStream internal state - // to determine whether or not it has been disturbed. This is just - // a workaround. - this.opts.body = new BodyAsyncIterable(this.opts.body) - } else if ( - this.opts.body && - typeof this.opts.body !== 'string' && - !ArrayBuffer.isView(this.opts.body) && - util.isIterable(this.opts.body) - ) { - // TODO: Should we allow re-using iterable if !this.opts.idempotent - // or through some other flag? - this.opts.body = new BodyAsyncIterable(this.opts.body) - } - } - - onConnect (abort) { - this.abort = abort - this.handler.onConnect(abort, { history: this.history }) - } - - onUpgrade (statusCode, headers, socket) { - this.handler.onUpgrade(statusCode, headers, socket) - } - - onError (error) { - this.handler.onError(error) - } - - onHeaders (statusCode, headers, resume, statusText) { - this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) - ? null - : parseLocation(statusCode, headers) - - if (this.opts.origin) { - this.history.push(new URL(this.opts.path, this.opts.origin)) - } - - if (!this.location) { - return this.handler.onHeaders(statusCode, headers, resume, statusText) - } - - const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))) - const path = search ? `${pathname}${search}` : pathname - - // Remove headers referring to the original URL. - // By default it is Host only, unless it's a 303 (see below), which removes also all Content-* headers. - // https://tools.ietf.org/html/rfc7231#section-6.4 - this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin) - this.opts.path = path - this.opts.origin = origin - this.opts.maxRedirections = 0 - this.opts.query = null - - // https://tools.ietf.org/html/rfc7231#section-6.4.4 - // In case of HTTP 303, always replace method to be either HEAD or GET - if (statusCode === 303 && this.opts.method !== 'HEAD') { - this.opts.method = 'GET' - this.opts.body = null - } - } - - onData (chunk) { - if (this.location) { - /* - https://tools.ietf.org/html/rfc7231#section-6.4 - - TLDR: undici always ignores 3xx response bodies. - - Redirection is used to serve the requested resource from another URL, so it is assumes that - no body is generated (and thus can be ignored). Even though generating a body is not prohibited. - - For status 301, 302, 303, 307 and 308 (the latter from RFC 7238), the specs mention that the body usually - (which means it's optional and not mandated) contain just an hyperlink to the value of - the Location response header, so the body can be ignored safely. - - For status 300, which is "Multiple Choices", the spec mentions both generating a Location - response header AND a response body with the other possible location to follow. - Since the spec explicitily chooses not to specify a format for such body and leave it to - servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it. - */ - } else { - return this.handler.onData(chunk) - } - } - - onComplete (trailers) { - if (this.location) { - /* - https://tools.ietf.org/html/rfc7231#section-6.4 - - TLDR: undici always ignores 3xx response trailers as they are not expected in case of redirections - and neither are useful if present. - - See comment on onData method above for more detailed informations. - */ - - this.location = null - this.abort = null - - this.dispatch(this.opts, this) - } else { - this.handler.onComplete(trailers) - } - } - - onBodySent (chunk) { - if (this.handler.onBodySent) { - this.handler.onBodySent(chunk) - } - } -} - -function parseLocation (statusCode, headers) { - if (redirectableStatusCodes.indexOf(statusCode) === -1) { - return null - } - - for (let i = 0; i < headers.length; i += 2) { - if (headers[i].toString().toLowerCase() === 'location') { - return headers[i + 1] - } - } -} - -// https://tools.ietf.org/html/rfc7231#section-6.4.4 -function shouldRemoveHeader (header, removeContent, unknownOrigin) { - if (header.length === 4) { - return util.headerNameToString(header) === 'host' - } - if (removeContent && util.headerNameToString(header).startsWith('content-')) { - return true - } - if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { - const name = util.headerNameToString(header) - return name === 'authorization' || name === 'cookie' || name === 'proxy-authorization' - } - return false -} - -// https://tools.ietf.org/html/rfc7231#section-6.4 -function cleanRequestHeaders (headers, removeContent, unknownOrigin) { - const ret = [] - if (Array.isArray(headers)) { - for (let i = 0; i < headers.length; i += 2) { - if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) { - ret.push(headers[i], headers[i + 1]) - } - } - } else if (headers && typeof headers === 'object') { - for (const key of Object.keys(headers)) { - if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) { - ret.push(key, headers[key]) - } - } - } else { - assert(headers == null, 'headers must be an object or an array') - } - return ret -} - -module.exports = RedirectHandler - - -/***/ }), - -/***/ 3573: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -const assert = __nccwpck_require__(2613) - -const { kRetryHandlerDefaultRetry } = __nccwpck_require__(6443) -const { RequestRetryError } = __nccwpck_require__(8707) -const { isDisturbed, parseHeaders, parseRangeHeader } = __nccwpck_require__(3440) - -function calculateRetryAfterHeader (retryAfter) { - const current = Date.now() - const diff = new Date(retryAfter).getTime() - current - - return diff -} - -class RetryHandler { - constructor (opts, handlers) { - const { retryOptions, ...dispatchOpts } = opts - const { - // Retry scoped - retry: retryFn, - maxRetries, - maxTimeout, - minTimeout, - timeoutFactor, - // Response scoped - methods, - errorCodes, - retryAfter, - statusCodes - } = retryOptions ?? {} - - this.dispatch = handlers.dispatch - this.handler = handlers.handler - this.opts = dispatchOpts - this.abort = null - this.aborted = false - this.retryOpts = { - retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry], - retryAfter: retryAfter ?? true, - maxTimeout: maxTimeout ?? 30 * 1000, // 30s, - timeout: minTimeout ?? 500, // .5s - timeoutFactor: timeoutFactor ?? 2, - maxRetries: maxRetries ?? 5, - // What errors we should retry - methods: methods ?? ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'], - // Indicates which errors to retry - statusCodes: statusCodes ?? [500, 502, 503, 504, 429], - // List of errors to retry - errorCodes: errorCodes ?? [ - 'ECONNRESET', - 'ECONNREFUSED', - 'ENOTFOUND', - 'ENETDOWN', - 'ENETUNREACH', - 'EHOSTDOWN', - 'EHOSTUNREACH', - 'EPIPE' - ] - } - - this.retryCount = 0 - this.start = 0 - this.end = null - this.etag = null - this.resume = null - - // Handle possible onConnect duplication - this.handler.onConnect(reason => { - this.aborted = true - if (this.abort) { - this.abort(reason) - } else { - this.reason = reason - } - }) - } - - onRequestSent () { - if (this.handler.onRequestSent) { - this.handler.onRequestSent() - } - } - - onUpgrade (statusCode, headers, socket) { - if (this.handler.onUpgrade) { - this.handler.onUpgrade(statusCode, headers, socket) - } - } - - onConnect (abort) { - if (this.aborted) { - abort(this.reason) - } else { - this.abort = abort - } - } - - onBodySent (chunk) { - if (this.handler.onBodySent) return this.handler.onBodySent(chunk) - } - - static [kRetryHandlerDefaultRetry] (err, { state, opts }, cb) { - const { statusCode, code, headers } = err - const { method, retryOptions } = opts - const { - maxRetries, - timeout, - maxTimeout, - timeoutFactor, - statusCodes, - errorCodes, - methods - } = retryOptions - let { counter, currentTimeout } = state - - currentTimeout = - currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout - - // Any code that is not a Undici's originated and allowed to retry - if ( - code && - code !== 'UND_ERR_REQ_RETRY' && - code !== 'UND_ERR_SOCKET' && - !errorCodes.includes(code) - ) { - cb(err) - return - } - - // If a set of method are provided and the current method is not in the list - if (Array.isArray(methods) && !methods.includes(method)) { - cb(err) - return - } - - // If a set of status code are provided and the current status code is not in the list - if ( - statusCode != null && - Array.isArray(statusCodes) && - !statusCodes.includes(statusCode) - ) { - cb(err) - return - } - - // If we reached the max number of retries - if (counter > maxRetries) { - cb(err) - return - } - - let retryAfterHeader = headers != null && headers['retry-after'] - if (retryAfterHeader) { - retryAfterHeader = Number(retryAfterHeader) - retryAfterHeader = isNaN(retryAfterHeader) - ? calculateRetryAfterHeader(retryAfterHeader) - : retryAfterHeader * 1e3 // Retry-After is in seconds - } - - const retryTimeout = - retryAfterHeader > 0 - ? Math.min(retryAfterHeader, maxTimeout) - : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout) - - state.currentTimeout = retryTimeout - - setTimeout(() => cb(null), retryTimeout) - } - - onHeaders (statusCode, rawHeaders, resume, statusMessage) { - const headers = parseHeaders(rawHeaders) - - this.retryCount += 1 - - if (statusCode >= 300) { - this.abort( - new RequestRetryError('Request failed', statusCode, { - headers, - count: this.retryCount - }) - ) - return false - } - - // Checkpoint for resume from where we left it - if (this.resume != null) { - this.resume = null - - if (statusCode !== 206) { - return true - } - - const contentRange = parseRangeHeader(headers['content-range']) - // If no content range - if (!contentRange) { - this.abort( - new RequestRetryError('Content-Range mismatch', statusCode, { - headers, - count: this.retryCount - }) - ) - return false - } - - // Let's start with a weak etag check - if (this.etag != null && this.etag !== headers.etag) { - this.abort( - new RequestRetryError('ETag mismatch', statusCode, { - headers, - count: this.retryCount - }) - ) - return false - } - - const { start, size, end = size } = contentRange - - assert(this.start === start, 'content-range mismatch') - assert(this.end == null || this.end === end, 'content-range mismatch') - - this.resume = resume - return true - } - - if (this.end == null) { - if (statusCode === 206) { - // First time we receive 206 - const range = parseRangeHeader(headers['content-range']) - - if (range == null) { - return this.handler.onHeaders( - statusCode, - rawHeaders, - resume, - statusMessage - ) - } - - const { start, size, end = size } = range - - assert( - start != null && Number.isFinite(start) && this.start !== start, - 'content-range mismatch' - ) - assert(Number.isFinite(start)) - assert( - end != null && Number.isFinite(end) && this.end !== end, - 'invalid content-length' - ) - - this.start = start - this.end = end - } - - // We make our best to checkpoint the body for further range headers - if (this.end == null) { - const contentLength = headers['content-length'] - this.end = contentLength != null ? Number(contentLength) : null - } - - assert(Number.isFinite(this.start)) - assert( - this.end == null || Number.isFinite(this.end), - 'invalid content-length' - ) - - this.resume = resume - this.etag = headers.etag != null ? headers.etag : null - - return this.handler.onHeaders( - statusCode, - rawHeaders, - resume, - statusMessage - ) - } - - const err = new RequestRetryError('Request failed', statusCode, { - headers, - count: this.retryCount - }) - - this.abort(err) - - return false - } - - onData (chunk) { - this.start += chunk.length - - return this.handler.onData(chunk) - } - - onComplete (rawTrailers) { - this.retryCount = 0 - return this.handler.onComplete(rawTrailers) - } - - onError (err) { - if (this.aborted || isDisturbed(this.opts.body)) { - return this.handler.onError(err) - } - - this.retryOpts.retry( - err, - { - state: { counter: this.retryCount++, currentTimeout: this.retryAfter }, - opts: { retryOptions: this.retryOpts, ...this.opts } - }, - onRetry.bind(this) - ) - - function onRetry (err) { - if (err != null || this.aborted || isDisturbed(this.opts.body)) { - return this.handler.onError(err) - } - - if (this.start !== 0) { - this.opts = { - ...this.opts, - headers: { - ...this.opts.headers, - range: `bytes=${this.start}-${this.end ?? ''}` - } - } - } - - try { - this.dispatch(this.opts, this) - } catch (err) { - this.handler.onError(err) - } - } - } -} - -module.exports = RetryHandler - - -/***/ }), - -/***/ 4415: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const RedirectHandler = __nccwpck_require__(8299) - -function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections }) { - return (dispatch) => { - return function Intercept (opts, handler) { - const { maxRedirections = defaultMaxRedirections } = opts - - if (!maxRedirections) { - return dispatch(opts, handler) - } - - const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler) - opts = { ...opts, maxRedirections: 0 } // Stop sub dispatcher from also redirecting. - return dispatch(opts, redirectHandler) - } - } -} - -module.exports = createRedirectInterceptor - - -/***/ }), - -/***/ 2824: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0; -const utils_1 = __nccwpck_require__(172); -// C headers -var ERROR; -(function (ERROR) { - ERROR[ERROR["OK"] = 0] = "OK"; - ERROR[ERROR["INTERNAL"] = 1] = "INTERNAL"; - ERROR[ERROR["STRICT"] = 2] = "STRICT"; - ERROR[ERROR["LF_EXPECTED"] = 3] = "LF_EXPECTED"; - ERROR[ERROR["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; - ERROR[ERROR["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; - ERROR[ERROR["INVALID_METHOD"] = 6] = "INVALID_METHOD"; - ERROR[ERROR["INVALID_URL"] = 7] = "INVALID_URL"; - ERROR[ERROR["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; - ERROR[ERROR["INVALID_VERSION"] = 9] = "INVALID_VERSION"; - ERROR[ERROR["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; - ERROR[ERROR["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; - ERROR[ERROR["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; - ERROR[ERROR["INVALID_STATUS"] = 13] = "INVALID_STATUS"; - ERROR[ERROR["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; - ERROR[ERROR["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; - ERROR[ERROR["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; - ERROR[ERROR["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; - ERROR[ERROR["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; - ERROR[ERROR["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; - ERROR[ERROR["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; - ERROR[ERROR["PAUSED"] = 21] = "PAUSED"; - ERROR[ERROR["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; - ERROR[ERROR["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; - ERROR[ERROR["USER"] = 24] = "USER"; -})(ERROR = exports.ERROR || (exports.ERROR = {})); -var TYPE; -(function (TYPE) { - TYPE[TYPE["BOTH"] = 0] = "BOTH"; - TYPE[TYPE["REQUEST"] = 1] = "REQUEST"; - TYPE[TYPE["RESPONSE"] = 2] = "RESPONSE"; -})(TYPE = exports.TYPE || (exports.TYPE = {})); -var FLAGS; -(function (FLAGS) { - FLAGS[FLAGS["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; - FLAGS[FLAGS["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; - FLAGS[FLAGS["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; - FLAGS[FLAGS["CHUNKED"] = 8] = "CHUNKED"; - FLAGS[FLAGS["UPGRADE"] = 16] = "UPGRADE"; - FLAGS[FLAGS["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; - FLAGS[FLAGS["SKIPBODY"] = 64] = "SKIPBODY"; - FLAGS[FLAGS["TRAILING"] = 128] = "TRAILING"; - // 1 << 8 is unused - FLAGS[FLAGS["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; -})(FLAGS = exports.FLAGS || (exports.FLAGS = {})); -var LENIENT_FLAGS; -(function (LENIENT_FLAGS) { - LENIENT_FLAGS[LENIENT_FLAGS["HEADERS"] = 1] = "HEADERS"; - LENIENT_FLAGS[LENIENT_FLAGS["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; - LENIENT_FLAGS[LENIENT_FLAGS["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; -})(LENIENT_FLAGS = exports.LENIENT_FLAGS || (exports.LENIENT_FLAGS = {})); -var METHODS; -(function (METHODS) { - METHODS[METHODS["DELETE"] = 0] = "DELETE"; - METHODS[METHODS["GET"] = 1] = "GET"; - METHODS[METHODS["HEAD"] = 2] = "HEAD"; - METHODS[METHODS["POST"] = 3] = "POST"; - METHODS[METHODS["PUT"] = 4] = "PUT"; - /* pathological */ - METHODS[METHODS["CONNECT"] = 5] = "CONNECT"; - METHODS[METHODS["OPTIONS"] = 6] = "OPTIONS"; - METHODS[METHODS["TRACE"] = 7] = "TRACE"; - /* WebDAV */ - METHODS[METHODS["COPY"] = 8] = "COPY"; - METHODS[METHODS["LOCK"] = 9] = "LOCK"; - METHODS[METHODS["MKCOL"] = 10] = "MKCOL"; - METHODS[METHODS["MOVE"] = 11] = "MOVE"; - METHODS[METHODS["PROPFIND"] = 12] = "PROPFIND"; - METHODS[METHODS["PROPPATCH"] = 13] = "PROPPATCH"; - METHODS[METHODS["SEARCH"] = 14] = "SEARCH"; - METHODS[METHODS["UNLOCK"] = 15] = "UNLOCK"; - METHODS[METHODS["BIND"] = 16] = "BIND"; - METHODS[METHODS["REBIND"] = 17] = "REBIND"; - METHODS[METHODS["UNBIND"] = 18] = "UNBIND"; - METHODS[METHODS["ACL"] = 19] = "ACL"; - /* subversion */ - METHODS[METHODS["REPORT"] = 20] = "REPORT"; - METHODS[METHODS["MKACTIVITY"] = 21] = "MKACTIVITY"; - METHODS[METHODS["CHECKOUT"] = 22] = "CHECKOUT"; - METHODS[METHODS["MERGE"] = 23] = "MERGE"; - /* upnp */ - METHODS[METHODS["M-SEARCH"] = 24] = "M-SEARCH"; - METHODS[METHODS["NOTIFY"] = 25] = "NOTIFY"; - METHODS[METHODS["SUBSCRIBE"] = 26] = "SUBSCRIBE"; - METHODS[METHODS["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; - /* RFC-5789 */ - METHODS[METHODS["PATCH"] = 28] = "PATCH"; - METHODS[METHODS["PURGE"] = 29] = "PURGE"; - /* CalDAV */ - METHODS[METHODS["MKCALENDAR"] = 30] = "MKCALENDAR"; - /* RFC-2068, section 19.6.1.2 */ - METHODS[METHODS["LINK"] = 31] = "LINK"; - METHODS[METHODS["UNLINK"] = 32] = "UNLINK"; - /* icecast */ - METHODS[METHODS["SOURCE"] = 33] = "SOURCE"; - /* RFC-7540, section 11.6 */ - METHODS[METHODS["PRI"] = 34] = "PRI"; - /* RFC-2326 RTSP */ - METHODS[METHODS["DESCRIBE"] = 35] = "DESCRIBE"; - METHODS[METHODS["ANNOUNCE"] = 36] = "ANNOUNCE"; - METHODS[METHODS["SETUP"] = 37] = "SETUP"; - METHODS[METHODS["PLAY"] = 38] = "PLAY"; - METHODS[METHODS["PAUSE"] = 39] = "PAUSE"; - METHODS[METHODS["TEARDOWN"] = 40] = "TEARDOWN"; - METHODS[METHODS["GET_PARAMETER"] = 41] = "GET_PARAMETER"; - METHODS[METHODS["SET_PARAMETER"] = 42] = "SET_PARAMETER"; - METHODS[METHODS["REDIRECT"] = 43] = "REDIRECT"; - METHODS[METHODS["RECORD"] = 44] = "RECORD"; - /* RAOP */ - METHODS[METHODS["FLUSH"] = 45] = "FLUSH"; -})(METHODS = exports.METHODS || (exports.METHODS = {})); -exports.METHODS_HTTP = [ - METHODS.DELETE, - METHODS.GET, - METHODS.HEAD, - METHODS.POST, - METHODS.PUT, - METHODS.CONNECT, - METHODS.OPTIONS, - METHODS.TRACE, - METHODS.COPY, - METHODS.LOCK, - METHODS.MKCOL, - METHODS.MOVE, - METHODS.PROPFIND, - METHODS.PROPPATCH, - METHODS.SEARCH, - METHODS.UNLOCK, - METHODS.BIND, - METHODS.REBIND, - METHODS.UNBIND, - METHODS.ACL, - METHODS.REPORT, - METHODS.MKACTIVITY, - METHODS.CHECKOUT, - METHODS.MERGE, - METHODS['M-SEARCH'], - METHODS.NOTIFY, - METHODS.SUBSCRIBE, - METHODS.UNSUBSCRIBE, - METHODS.PATCH, - METHODS.PURGE, - METHODS.MKCALENDAR, - METHODS.LINK, - METHODS.UNLINK, - METHODS.PRI, - // TODO(indutny): should we allow it with HTTP? - METHODS.SOURCE, -]; -exports.METHODS_ICE = [ - METHODS.SOURCE, -]; -exports.METHODS_RTSP = [ - METHODS.OPTIONS, - METHODS.DESCRIBE, - METHODS.ANNOUNCE, - METHODS.SETUP, - METHODS.PLAY, - METHODS.PAUSE, - METHODS.TEARDOWN, - METHODS.GET_PARAMETER, - METHODS.SET_PARAMETER, - METHODS.REDIRECT, - METHODS.RECORD, - METHODS.FLUSH, - // For AirPlay - METHODS.GET, - METHODS.POST, -]; -exports.METHOD_MAP = utils_1.enumToMap(METHODS); -exports.H_METHOD_MAP = {}; -Object.keys(exports.METHOD_MAP).forEach((key) => { - if (/^H/.test(key)) { - exports.H_METHOD_MAP[key] = exports.METHOD_MAP[key]; - } -}); -var FINISH; -(function (FINISH) { - FINISH[FINISH["SAFE"] = 0] = "SAFE"; - FINISH[FINISH["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; - FINISH[FINISH["UNSAFE"] = 2] = "UNSAFE"; -})(FINISH = exports.FINISH || (exports.FINISH = {})); -exports.ALPHA = []; -for (let i = 'A'.charCodeAt(0); i <= 'Z'.charCodeAt(0); i++) { - // Upper case - exports.ALPHA.push(String.fromCharCode(i)); - // Lower case - exports.ALPHA.push(String.fromCharCode(i + 0x20)); -} -exports.NUM_MAP = { - 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, - 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, -}; -exports.HEX_MAP = { - 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, - 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, - A: 0XA, B: 0XB, C: 0XC, D: 0XD, E: 0XE, F: 0XF, - a: 0xa, b: 0xb, c: 0xc, d: 0xd, e: 0xe, f: 0xf, -}; -exports.NUM = [ - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', -]; -exports.ALPHANUM = exports.ALPHA.concat(exports.NUM); -exports.MARK = ['-', '_', '.', '!', '~', '*', '\'', '(', ')']; -exports.USERINFO_CHARS = exports.ALPHANUM - .concat(exports.MARK) - .concat(['%', ';', ':', '&', '=', '+', '$', ',']); -// TODO(indutny): use RFC -exports.STRICT_URL_CHAR = [ - '!', '"', '$', '%', '&', '\'', - '(', ')', '*', '+', ',', '-', '.', '/', - ':', ';', '<', '=', '>', - '@', '[', '\\', ']', '^', '_', - '`', - '{', '|', '}', '~', -].concat(exports.ALPHANUM); -exports.URL_CHAR = exports.STRICT_URL_CHAR - .concat(['\t', '\f']); -// All characters with 0x80 bit set to 1 -for (let i = 0x80; i <= 0xff; i++) { - exports.URL_CHAR.push(i); -} -exports.HEX = exports.NUM.concat(['a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F']); -/* Tokens as defined by rfc 2616. Also lowercases them. - * token = 1* - * separators = "(" | ")" | "<" | ">" | "@" - * | "," | ";" | ":" | "\" | <"> - * | "/" | "[" | "]" | "?" | "=" - * | "{" | "}" | SP | HT - */ -exports.STRICT_TOKEN = [ - '!', '#', '$', '%', '&', '\'', - '*', '+', '-', '.', - '^', '_', '`', - '|', '~', -].concat(exports.ALPHANUM); -exports.TOKEN = exports.STRICT_TOKEN.concat([' ']); -/* - * Verify that a char is a valid visible (printable) US-ASCII - * character or %x80-FF - */ -exports.HEADER_CHARS = ['\t']; -for (let i = 32; i <= 255; i++) { - if (i !== 127) { - exports.HEADER_CHARS.push(i); - } -} -// ',' = \x44 -exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44); -exports.MAJOR = exports.NUM_MAP; -exports.MINOR = exports.MAJOR; -var HEADER_STATE; -(function (HEADER_STATE) { - HEADER_STATE[HEADER_STATE["GENERAL"] = 0] = "GENERAL"; - HEADER_STATE[HEADER_STATE["CONNECTION"] = 1] = "CONNECTION"; - HEADER_STATE[HEADER_STATE["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; - HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; - HEADER_STATE[HEADER_STATE["UPGRADE"] = 4] = "UPGRADE"; - HEADER_STATE[HEADER_STATE["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; - HEADER_STATE[HEADER_STATE["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; - HEADER_STATE[HEADER_STATE["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; - HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; -})(HEADER_STATE = exports.HEADER_STATE || (exports.HEADER_STATE = {})); -exports.SPECIAL_HEADERS = { - 'connection': HEADER_STATE.CONNECTION, - 'content-length': HEADER_STATE.CONTENT_LENGTH, - 'proxy-connection': HEADER_STATE.CONNECTION, - 'transfer-encoding': HEADER_STATE.TRANSFER_ENCODING, - 'upgrade': HEADER_STATE.UPGRADE, -}; -//# sourceMappingURL=constants.js.map - -/***/ }), - -/***/ 3870: -/***/ ((module) => { - -module.exports = 'AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGADf39/AGABfwBgAn9/AGAGf39/f39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQACA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAA0ZFAwMEAAAFAAAAAAAABQEFAAUFBQAABgAAAAAGBgYGAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAAABAQcAAAUFAwABBAUBcAESEgUDAQACBggBfwFBgNQECwfRBSIGbWVtb3J5AgALX2luaXRpYWxpemUACRlfX2luZGlyZWN0X2Z1bmN0aW9uX3RhYmxlAQALbGxodHRwX2luaXQAChhsbGh0dHBfc2hvdWxkX2tlZXBfYWxpdmUAQQxsbGh0dHBfYWxsb2MADAZtYWxsb2MARgtsbGh0dHBfZnJlZQANBGZyZWUASA9sbGh0dHBfZ2V0X3R5cGUADhVsbGh0dHBfZ2V0X2h0dHBfbWFqb3IADxVsbGh0dHBfZ2V0X2h0dHBfbWlub3IAEBFsbGh0dHBfZ2V0X21ldGhvZAARFmxsaHR0cF9nZXRfc3RhdHVzX2NvZGUAEhJsbGh0dHBfZ2V0X3VwZ3JhZGUAEwxsbGh0dHBfcmVzZXQAFA5sbGh0dHBfZXhlY3V0ZQAVFGxsaHR0cF9zZXR0aW5nc19pbml0ABYNbGxodHRwX2ZpbmlzaAAXDGxsaHR0cF9wYXVzZQAYDWxsaHR0cF9yZXN1bWUAGRtsbGh0dHBfcmVzdW1lX2FmdGVyX3VwZ3JhZGUAGhBsbGh0dHBfZ2V0X2Vycm5vABsXbGxodHRwX2dldF9lcnJvcl9yZWFzb24AHBdsbGh0dHBfc2V0X2Vycm9yX3JlYXNvbgAdFGxsaHR0cF9nZXRfZXJyb3JfcG9zAB4RbGxodHRwX2Vycm5vX25hbWUAHxJsbGh0dHBfbWV0aG9kX25hbWUAIBJsbGh0dHBfc3RhdHVzX25hbWUAIRpsbGh0dHBfc2V0X2xlbmllbnRfaGVhZGVycwAiIWxsaHR0cF9zZXRfbGVuaWVudF9jaHVua2VkX2xlbmd0aAAjHWxsaHR0cF9zZXRfbGVuaWVudF9rZWVwX2FsaXZlACQkbGxodHRwX3NldF9sZW5pZW50X3RyYW5zZmVyX2VuY29kaW5nACUYbGxodHRwX21lc3NhZ2VfbmVlZHNfZW9mAD8JFwEAQQELEQECAwQFCwYHNTk3MS8tJyspCsLgAkUCAAsIABCIgICAAAsZACAAEMKAgIAAGiAAIAI2AjggACABOgAoCxwAIAAgAC8BMiAALQAuIAAQwYCAgAAQgICAgAALKgEBf0HAABDGgICAACIBEMKAgIAAGiABQYCIgIAANgI4IAEgADoAKCABCwoAIAAQyICAgAALBwAgAC0AKAsHACAALQAqCwcAIAAtACsLBwAgAC0AKQsHACAALwEyCwcAIAAtAC4LRQEEfyAAKAIYIQEgAC0ALSECIAAtACghAyAAKAI4IQQgABDCgICAABogACAENgI4IAAgAzoAKCAAIAI6AC0gACABNgIYCxEAIAAgASABIAJqEMOAgIAACxAAIABBAEHcABDMgICAABoLZwEBf0EAIQECQCAAKAIMDQACQAJAAkACQCAALQAvDgMBAAMCCyAAKAI4IgFFDQAgASgCLCIBRQ0AIAAgARGAgICAAAAiAQ0DC0EADwsQyoCAgAAACyAAQcOWgIAANgIQQQ4hAQsgAQseAAJAIAAoAgwNACAAQdGbgIAANgIQIABBFTYCDAsLFgACQCAAKAIMQRVHDQAgAEEANgIMCwsWAAJAIAAoAgxBFkcNACAAQQA2AgwLCwcAIAAoAgwLBwAgACgCEAsJACAAIAE2AhALBwAgACgCFAsiAAJAIABBJEkNABDKgICAAAALIABBAnRBoLOAgABqKAIACyIAAkAgAEEuSQ0AEMqAgIAAAAsgAEECdEGwtICAAGooAgAL7gsBAX9B66iAgAAhAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABBnH9qDvQDY2IAAWFhYWFhYQIDBAVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhBgcICQoLDA0OD2FhYWFhEGFhYWFhYWFhYWFhEWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRITFBUWFxgZGhthYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2YTc4OTphYWFhYWFhYTthYWE8YWFhYT0+P2FhYWFhYWFhQGFhQWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYUJDREVGR0hJSktMTU5PUFFSU2FhYWFhYWFhVFVWV1hZWlthXF1hYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFeYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhX2BhC0Hhp4CAAA8LQaShgIAADwtBy6yAgAAPC0H+sYCAAA8LQcCkgIAADwtBq6SAgAAPC0GNqICAAA8LQeKmgIAADwtBgLCAgAAPC0G5r4CAAA8LQdekgIAADwtB75+AgAAPC0Hhn4CAAA8LQfqfgIAADwtB8qCAgAAPC0Gor4CAAA8LQa6ygIAADwtBiLCAgAAPC0Hsp4CAAA8LQYKigIAADwtBjp2AgAAPC0HQroCAAA8LQcqjgIAADwtBxbKAgAAPC0HfnICAAA8LQdKcgIAADwtBxKCAgAAPC0HXoICAAA8LQaKfgIAADwtB7a6AgAAPC0GrsICAAA8LQdSlgIAADwtBzK6AgAAPC0H6roCAAA8LQfyrgIAADwtB0rCAgAAPC0HxnYCAAA8LQbuggIAADwtB96uAgAAPC0GQsYCAAA8LQdexgIAADwtBoq2AgAAPC0HUp4CAAA8LQeCrgIAADwtBn6yAgAAPC0HrsYCAAA8LQdWfgIAADwtByrGAgAAPC0HepYCAAA8LQdSegIAADwtB9JyAgAAPC0GnsoCAAA8LQbGdgIAADwtBoJ2AgAAPC0G5sYCAAA8LQbywgIAADwtBkqGAgAAPC0GzpoCAAA8LQemsgIAADwtBrJ6AgAAPC0HUq4CAAA8LQfemgIAADwtBgKaAgAAPC0GwoYCAAA8LQf6egIAADwtBjaOAgAAPC0GJrYCAAA8LQfeigIAADwtBoLGAgAAPC0Gun4CAAA8LQcalgIAADwtB6J6AgAAPC0GTooCAAA8LQcKvgIAADwtBw52AgAAPC0GLrICAAA8LQeGdgIAADwtBja+AgAAPC0HqoYCAAA8LQbStgIAADwtB0q+AgAAPC0HfsoCAAA8LQdKygIAADwtB8LCAgAAPC0GpooCAAA8LQfmjgIAADwtBmZ6AgAAPC0G1rICAAA8LQZuwgIAADwtBkrKAgAAPC0G2q4CAAA8LQcKigIAADwtB+LKAgAAPC0GepYCAAA8LQdCigIAADwtBup6AgAAPC0GBnoCAAA8LEMqAgIAAAAtB1qGAgAAhAQsgAQsWACAAIAAtAC1B/gFxIAFBAEdyOgAtCxkAIAAgAC0ALUH9AXEgAUEAR0EBdHI6AC0LGQAgACAALQAtQfsBcSABQQBHQQJ0cjoALQsZACAAIAAtAC1B9wFxIAFBAEdBA3RyOgAtCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAgAiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCBCIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQcaRgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIwIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAggiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2ioCAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCNCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIMIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZqAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAjgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCECIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZWQgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAI8IgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAhQiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEGqm4CAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCQCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIYIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZOAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCJCIERQ0AIAAgBBGAgICAAAAhAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIsIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAigiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2iICAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCUCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIcIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABBwpmAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCICIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZSUgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAJMIgRFDQAgACAEEYCAgIAAACEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAlQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCWCIERQ0AIAAgBBGAgICAAAAhAwsgAwtFAQF/AkACQCAALwEwQRRxQRRHDQBBASEDIAAtAChBAUYNASAALwEyQeUARiEDDAELIAAtAClBBUYhAwsgACADOgAuQQAL/gEBA39BASEDAkAgAC8BMCIEQQhxDQAgACkDIEIAUiEDCwJAAkAgAC0ALkUNAEEBIQUgAC0AKUEFRg0BQQEhBSAEQcAAcUUgA3FBAUcNAQtBACEFIARBwABxDQBBAiEFIARB//8DcSIDQQhxDQACQCADQYAEcUUNAAJAIAAtAChBAUcNACAALQAtQQpxDQBBBQ8LQQQPCwJAIANBIHENAAJAIAAtAChBAUYNACAALwEyQf//A3EiAEGcf2pB5ABJDQAgAEHMAUYNACAAQbACRg0AQQQhBSAEQShxRQ0CIANBiARxQYAERg0CC0EADwtBAEEDIAApAyBQGyEFCyAFC2IBAn9BACEBAkAgAC0AKEEBRg0AIAAvATJB//8DcSICQZx/akHkAEkNACACQcwBRg0AIAJBsAJGDQAgAC8BMCIAQcAAcQ0AQQEhASAAQYgEcUGABEYNACAAQShxRSEBCyABC6cBAQN/AkACQAJAIAAtACpFDQAgAC0AK0UNAEEAIQMgAC8BMCIEQQJxRQ0BDAILQQAhAyAALwEwIgRBAXFFDQELQQEhAyAALQAoQQFGDQAgAC8BMkH//wNxIgVBnH9qQeQASQ0AIAVBzAFGDQAgBUGwAkYNACAEQcAAcQ0AQQAhAyAEQYgEcUGABEYNACAEQShxQQBHIQMLIABBADsBMCAAQQA6AC8gAwuZAQECfwJAAkACQCAALQAqRQ0AIAAtACtFDQBBACEBIAAvATAiAkECcUUNAQwCC0EAIQEgAC8BMCICQQFxRQ0BC0EBIQEgAC0AKEEBRg0AIAAvATJB//8DcSIAQZx/akHkAEkNACAAQcwBRg0AIABBsAJGDQAgAkHAAHENAEEAIQEgAkGIBHFBgARGDQAgAkEocUEARyEBCyABC1kAIABBGGpCADcDACAAQgA3AwAgAEE4akIANwMAIABBMGpCADcDACAAQShqQgA3AwAgAEEgakIANwMAIABBEGpCADcDACAAQQhqQgA3AwAgAEHdATYCHEEAC3sBAX8CQCAAKAIMIgMNAAJAIAAoAgRFDQAgACABNgIECwJAIAAgASACEMSAgIAAIgMNACAAKAIMDwsgACADNgIcQQAhAyAAKAIEIgFFDQAgACABIAIgACgCCBGBgICAAAAiAUUNACAAIAI2AhQgACABNgIMIAEhAwsgAwvk8wEDDn8DfgR/I4CAgIAAQRBrIgMkgICAgAAgASEEIAEhBSABIQYgASEHIAEhCCABIQkgASEKIAEhCyABIQwgASENIAEhDiABIQ8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCHCIQQX9qDt0B2gEB2QECAwQFBgcICQoLDA0O2AEPENcBERLWARMUFRYXGBkaG+AB3wEcHR7VAR8gISIjJCXUASYnKCkqKyzTAdIBLS7RAdABLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVG2wFHSElKzwHOAUvNAUzMAU1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1+f4ABgQGCAYMBhAGFAYYBhwGIAYkBigGLAYwBjQGOAY8BkAGRAZIBkwGUAZUBlgGXAZgBmQGaAZsBnAGdAZ4BnwGgAaEBogGjAaQBpQGmAacBqAGpAaoBqwGsAa0BrgGvAbABsQGyAbMBtAG1AbYBtwHLAcoBuAHJAbkByAG6AbsBvAG9Ab4BvwHAAcEBwgHDAcQBxQHGAQDcAQtBACEQDMYBC0EOIRAMxQELQQ0hEAzEAQtBDyEQDMMBC0EQIRAMwgELQRMhEAzBAQtBFCEQDMABC0EVIRAMvwELQRYhEAy+AQtBFyEQDL0BC0EYIRAMvAELQRkhEAy7AQtBGiEQDLoBC0EbIRAMuQELQRwhEAy4AQtBCCEQDLcBC0EdIRAMtgELQSAhEAy1AQtBHyEQDLQBC0EHIRAMswELQSEhEAyyAQtBIiEQDLEBC0EeIRAMsAELQSMhEAyvAQtBEiEQDK4BC0ERIRAMrQELQSQhEAysAQtBJSEQDKsBC0EmIRAMqgELQSchEAypAQtBwwEhEAyoAQtBKSEQDKcBC0ErIRAMpgELQSwhEAylAQtBLSEQDKQBC0EuIRAMowELQS8hEAyiAQtBxAEhEAyhAQtBMCEQDKABC0E0IRAMnwELQQwhEAyeAQtBMSEQDJ0BC0EyIRAMnAELQTMhEAybAQtBOSEQDJoBC0E1IRAMmQELQcUBIRAMmAELQQshEAyXAQtBOiEQDJYBC0E2IRAMlQELQQohEAyUAQtBNyEQDJMBC0E4IRAMkgELQTwhEAyRAQtBOyEQDJABC0E9IRAMjwELQQkhEAyOAQtBKCEQDI0BC0E+IRAMjAELQT8hEAyLAQtBwAAhEAyKAQtBwQAhEAyJAQtBwgAhEAyIAQtBwwAhEAyHAQtBxAAhEAyGAQtBxQAhEAyFAQtBxgAhEAyEAQtBKiEQDIMBC0HHACEQDIIBC0HIACEQDIEBC0HJACEQDIABC0HKACEQDH8LQcsAIRAMfgtBzQAhEAx9C0HMACEQDHwLQc4AIRAMewtBzwAhEAx6C0HQACEQDHkLQdEAIRAMeAtB0gAhEAx3C0HTACEQDHYLQdQAIRAMdQtB1gAhEAx0C0HVACEQDHMLQQYhEAxyC0HXACEQDHELQQUhEAxwC0HYACEQDG8LQQQhEAxuC0HZACEQDG0LQdoAIRAMbAtB2wAhEAxrC0HcACEQDGoLQQMhEAxpC0HdACEQDGgLQd4AIRAMZwtB3wAhEAxmC0HhACEQDGULQeAAIRAMZAtB4gAhEAxjC0HjACEQDGILQQIhEAxhC0HkACEQDGALQeUAIRAMXwtB5gAhEAxeC0HnACEQDF0LQegAIRAMXAtB6QAhEAxbC0HqACEQDFoLQesAIRAMWQtB7AAhEAxYC0HtACEQDFcLQe4AIRAMVgtB7wAhEAxVC0HwACEQDFQLQfEAIRAMUwtB8gAhEAxSC0HzACEQDFELQfQAIRAMUAtB9QAhEAxPC0H2ACEQDE4LQfcAIRAMTQtB+AAhEAxMC0H5ACEQDEsLQfoAIRAMSgtB+wAhEAxJC0H8ACEQDEgLQf0AIRAMRwtB/gAhEAxGC0H/ACEQDEULQYABIRAMRAtBgQEhEAxDC0GCASEQDEILQYMBIRAMQQtBhAEhEAxAC0GFASEQDD8LQYYBIRAMPgtBhwEhEAw9C0GIASEQDDwLQYkBIRAMOwtBigEhEAw6C0GLASEQDDkLQYwBIRAMOAtBjQEhEAw3C0GOASEQDDYLQY8BIRAMNQtBkAEhEAw0C0GRASEQDDMLQZIBIRAMMgtBkwEhEAwxC0GUASEQDDALQZUBIRAMLwtBlgEhEAwuC0GXASEQDC0LQZgBIRAMLAtBmQEhEAwrC0GaASEQDCoLQZsBIRAMKQtBnAEhEAwoC0GdASEQDCcLQZ4BIRAMJgtBnwEhEAwlC0GgASEQDCQLQaEBIRAMIwtBogEhEAwiC0GjASEQDCELQaQBIRAMIAtBpQEhEAwfC0GmASEQDB4LQacBIRAMHQtBqAEhEAwcC0GpASEQDBsLQaoBIRAMGgtBqwEhEAwZC0GsASEQDBgLQa0BIRAMFwtBrgEhEAwWC0EBIRAMFQtBrwEhEAwUC0GwASEQDBMLQbEBIRAMEgtBswEhEAwRC0GyASEQDBALQbQBIRAMDwtBtQEhEAwOC0G2ASEQDA0LQbcBIRAMDAtBuAEhEAwLC0G5ASEQDAoLQboBIRAMCQtBuwEhEAwIC0HGASEQDAcLQbwBIRAMBgtBvQEhEAwFC0G+ASEQDAQLQb8BIRAMAwtBwAEhEAwCC0HCASEQDAELQcEBIRALA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAQDscBAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxweHyAhIyUoP0BBREVGR0hJSktMTU9QUVJT3gNXWVtcXWBiZWZnaGlqa2xtb3BxcnN0dXZ3eHl6e3x9foABggGFAYYBhwGJAYsBjAGNAY4BjwGQAZEBlAGVAZYBlwGYAZkBmgGbAZwBnQGeAZ8BoAGhAaIBowGkAaUBpgGnAagBqQGqAasBrAGtAa4BrwGwAbEBsgGzAbQBtQG2AbcBuAG5AboBuwG8Ab0BvgG/AcABwQHCAcMBxAHFAcYBxwHIAckBygHLAcwBzQHOAc8B0AHRAdIB0wHUAdUB1gHXAdgB2QHaAdsB3AHdAd4B4AHhAeIB4wHkAeUB5gHnAegB6QHqAesB7AHtAe4B7wHwAfEB8gHzAZkCpAKwAv4C/gILIAEiBCACRw3zAUHdASEQDP8DCyABIhAgAkcN3QFBwwEhEAz+AwsgASIBIAJHDZABQfcAIRAM/QMLIAEiASACRw2GAUHvACEQDPwDCyABIgEgAkcNf0HqACEQDPsDCyABIgEgAkcNe0HoACEQDPoDCyABIgEgAkcNeEHmACEQDPkDCyABIgEgAkcNGkEYIRAM+AMLIAEiASACRw0UQRIhEAz3AwsgASIBIAJHDVlBxQAhEAz2AwsgASIBIAJHDUpBPyEQDPUDCyABIgEgAkcNSEE8IRAM9AMLIAEiASACRw1BQTEhEAzzAwsgAC0ALkEBRg3rAwyHAgsgACABIgEgAhDAgICAAEEBRw3mASAAQgA3AyAM5wELIAAgASIBIAIQtICAgAAiEA3nASABIQEM9QILAkAgASIBIAJHDQBBBiEQDPADCyAAIAFBAWoiASACELuAgIAAIhAN6AEgASEBDDELIABCADcDIEESIRAM1QMLIAEiECACRw0rQR0hEAztAwsCQCABIgEgAkYNACABQQFqIQFBECEQDNQDC0EHIRAM7AMLIABCACAAKQMgIhEgAiABIhBrrSISfSITIBMgEVYbNwMgIBEgElYiFEUN5QFBCCEQDOsDCwJAIAEiASACRg0AIABBiYCAgAA2AgggACABNgIEIAEhAUEUIRAM0gMLQQkhEAzqAwsgASEBIAApAyBQDeQBIAEhAQzyAgsCQCABIgEgAkcNAEELIRAM6QMLIAAgAUEBaiIBIAIQtoCAgAAiEA3lASABIQEM8gILIAAgASIBIAIQuICAgAAiEA3lASABIQEM8gILIAAgASIBIAIQuICAgAAiEA3mASABIQEMDQsgACABIgEgAhC6gICAACIQDecBIAEhAQzwAgsCQCABIgEgAkcNAEEPIRAM5QMLIAEtAAAiEEE7Rg0IIBBBDUcN6AEgAUEBaiEBDO8CCyAAIAEiASACELqAgIAAIhAN6AEgASEBDPICCwNAAkAgAS0AAEHwtYCAAGotAAAiEEEBRg0AIBBBAkcN6wEgACgCBCEQIABBADYCBCAAIBAgAUEBaiIBELmAgIAAIhAN6gEgASEBDPQCCyABQQFqIgEgAkcNAAtBEiEQDOIDCyAAIAEiASACELqAgIAAIhAN6QEgASEBDAoLIAEiASACRw0GQRshEAzgAwsCQCABIgEgAkcNAEEWIRAM4AMLIABBioCAgAA2AgggACABNgIEIAAgASACELiAgIAAIhAN6gEgASEBQSAhEAzGAwsCQCABIgEgAkYNAANAAkAgAS0AAEHwt4CAAGotAAAiEEECRg0AAkAgEEF/ag4E5QHsAQDrAewBCyABQQFqIQFBCCEQDMgDCyABQQFqIgEgAkcNAAtBFSEQDN8DC0EVIRAM3gMLA0ACQCABLQAAQfC5gIAAai0AACIQQQJGDQAgEEF/ag4E3gHsAeAB6wHsAQsgAUEBaiIBIAJHDQALQRghEAzdAwsCQCABIgEgAkYNACAAQYuAgIAANgIIIAAgATYCBCABIQFBByEQDMQDC0EZIRAM3AMLIAFBAWohAQwCCwJAIAEiFCACRw0AQRohEAzbAwsgFCEBAkAgFC0AAEFzag4U3QLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gIA7gILQQAhECAAQQA2AhwgAEGvi4CAADYCECAAQQI2AgwgACAUQQFqNgIUDNoDCwJAIAEtAAAiEEE7Rg0AIBBBDUcN6AEgAUEBaiEBDOUCCyABQQFqIQELQSIhEAy/AwsCQCABIhAgAkcNAEEcIRAM2AMLQgAhESAQIQEgEC0AAEFQag435wHmAQECAwQFBgcIAAAAAAAAAAkKCwwNDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADxAREhMUAAtBHiEQDL0DC0ICIREM5QELQgMhEQzkAQtCBCERDOMBC0IFIREM4gELQgYhEQzhAQtCByERDOABC0IIIREM3wELQgkhEQzeAQtCCiERDN0BC0ILIREM3AELQgwhEQzbAQtCDSERDNoBC0IOIREM2QELQg8hEQzYAQtCCiERDNcBC0ILIREM1gELQgwhEQzVAQtCDSERDNQBC0IOIREM0wELQg8hEQzSAQtCACERAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAQLQAAQVBqDjflAeQBAAECAwQFBgfmAeYB5gHmAeYB5gHmAQgJCgsMDeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gEODxAREhPmAQtCAiERDOQBC0IDIREM4wELQgQhEQziAQtCBSERDOEBC0IGIREM4AELQgchEQzfAQtCCCERDN4BC0IJIREM3QELQgohEQzcAQtCCyERDNsBC0IMIREM2gELQg0hEQzZAQtCDiERDNgBC0IPIREM1wELQgohEQzWAQtCCyERDNUBC0IMIREM1AELQg0hEQzTAQtCDiERDNIBC0IPIREM0QELIABCACAAKQMgIhEgAiABIhBrrSISfSITIBMgEVYbNwMgIBEgElYiFEUN0gFBHyEQDMADCwJAIAEiASACRg0AIABBiYCAgAA2AgggACABNgIEIAEhAUEkIRAMpwMLQSAhEAy/AwsgACABIhAgAhC+gICAAEF/ag4FtgEAxQIB0QHSAQtBESEQDKQDCyAAQQE6AC8gECEBDLsDCyABIgEgAkcN0gFBJCEQDLsDCyABIg0gAkcNHkHGACEQDLoDCyAAIAEiASACELKAgIAAIhAN1AEgASEBDLUBCyABIhAgAkcNJkHQACEQDLgDCwJAIAEiASACRw0AQSghEAy4AwsgAEEANgIEIABBjICAgAA2AgggACABIAEQsYCAgAAiEA3TASABIQEM2AELAkAgASIQIAJHDQBBKSEQDLcDCyAQLQAAIgFBIEYNFCABQQlHDdMBIBBBAWohAQwVCwJAIAEiASACRg0AIAFBAWohAQwXC0EqIRAMtQMLAkAgASIQIAJHDQBBKyEQDLUDCwJAIBAtAAAiAUEJRg0AIAFBIEcN1QELIAAtACxBCEYN0wEgECEBDJEDCwJAIAEiASACRw0AQSwhEAy0AwsgAS0AAEEKRw3VASABQQFqIQEMyQILIAEiDiACRw3VAUEvIRAMsgMLA0ACQCABLQAAIhBBIEYNAAJAIBBBdmoOBADcAdwBANoBCyABIQEM4AELIAFBAWoiASACRw0AC0ExIRAMsQMLQTIhECABIhQgAkYNsAMgAiAUayAAKAIAIgFqIRUgFCABa0EDaiEWAkADQCAULQAAIhdBIHIgFyAXQb9/akH/AXFBGkkbQf8BcSABQfC7gIAAai0AAEcNAQJAIAFBA0cNAEEGIQEMlgMLIAFBAWohASAUQQFqIhQgAkcNAAsgACAVNgIADLEDCyAAQQA2AgAgFCEBDNkBC0EzIRAgASIUIAJGDa8DIAIgFGsgACgCACIBaiEVIBQgAWtBCGohFgJAA0AgFC0AACIXQSByIBcgF0G/f2pB/wFxQRpJG0H/AXEgAUH0u4CAAGotAABHDQECQCABQQhHDQBBBSEBDJUDCyABQQFqIQEgFEEBaiIUIAJHDQALIAAgFTYCAAywAwsgAEEANgIAIBQhAQzYAQtBNCEQIAEiFCACRg2uAyACIBRrIAAoAgAiAWohFSAUIAFrQQVqIRYCQANAIBQtAAAiF0EgciAXIBdBv39qQf8BcUEaSRtB/wFxIAFB0MKAgABqLQAARw0BAkAgAUEFRw0AQQchAQyUAwsgAUEBaiEBIBRBAWoiFCACRw0ACyAAIBU2AgAMrwMLIABBADYCACAUIQEM1wELAkAgASIBIAJGDQADQAJAIAEtAABBgL6AgABqLQAAIhBBAUYNACAQQQJGDQogASEBDN0BCyABQQFqIgEgAkcNAAtBMCEQDK4DC0EwIRAMrQMLAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgRg0AIBBBdmoOBNkB2gHaAdkB2gELIAFBAWoiASACRw0AC0E4IRAMrQMLQTghEAysAwsDQAJAIAEtAAAiEEEgRg0AIBBBCUcNAwsgAUEBaiIBIAJHDQALQTwhEAyrAwsDQAJAIAEtAAAiEEEgRg0AAkACQCAQQXZqDgTaAQEB2gEACyAQQSxGDdsBCyABIQEMBAsgAUEBaiIBIAJHDQALQT8hEAyqAwsgASEBDNsBC0HAACEQIAEiFCACRg2oAyACIBRrIAAoAgAiAWohFiAUIAFrQQZqIRcCQANAIBQtAABBIHIgAUGAwICAAGotAABHDQEgAUEGRg2OAyABQQFqIQEgFEEBaiIUIAJHDQALIAAgFjYCAAypAwsgAEEANgIAIBQhAQtBNiEQDI4DCwJAIAEiDyACRw0AQcEAIRAMpwMLIABBjICAgAA2AgggACAPNgIEIA8hASAALQAsQX9qDgTNAdUB1wHZAYcDCyABQQFqIQEMzAELAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgciAQIBBBv39qQf8BcUEaSRtB/wFxIhBBCUYNACAQQSBGDQACQAJAAkACQCAQQZ1/ag4TAAMDAwMDAwMBAwMDAwMDAwMDAgMLIAFBAWohAUExIRAMkQMLIAFBAWohAUEyIRAMkAMLIAFBAWohAUEzIRAMjwMLIAEhAQzQAQsgAUEBaiIBIAJHDQALQTUhEAylAwtBNSEQDKQDCwJAIAEiASACRg0AA0ACQCABLQAAQYC8gIAAai0AAEEBRg0AIAEhAQzTAQsgAUEBaiIBIAJHDQALQT0hEAykAwtBPSEQDKMDCyAAIAEiASACELCAgIAAIhAN1gEgASEBDAELIBBBAWohAQtBPCEQDIcDCwJAIAEiASACRw0AQcIAIRAMoAMLAkADQAJAIAEtAABBd2oOGAAC/gL+AoQD/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4CAP4CCyABQQFqIgEgAkcNAAtBwgAhEAygAwsgAUEBaiEBIAAtAC1BAXFFDb0BIAEhAQtBLCEQDIUDCyABIgEgAkcN0wFBxAAhEAydAwsDQAJAIAEtAABBkMCAgABqLQAAQQFGDQAgASEBDLcCCyABQQFqIgEgAkcNAAtBxQAhEAycAwsgDS0AACIQQSBGDbMBIBBBOkcNgQMgACgCBCEBIABBADYCBCAAIAEgDRCvgICAACIBDdABIA1BAWohAQyzAgtBxwAhECABIg0gAkYNmgMgAiANayAAKAIAIgFqIRYgDSABa0EFaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUGQwoCAAGotAABHDYADIAFBBUYN9AIgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMmgMLQcgAIRAgASINIAJGDZkDIAIgDWsgACgCACIBaiEWIA0gAWtBCWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFBlsKAgABqLQAARw3/AgJAIAFBCUcNAEECIQEM9QILIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJkDCwJAIAEiDSACRw0AQckAIRAMmQMLAkACQCANLQAAIgFBIHIgASABQb9/akH/AXFBGkkbQf8BcUGSf2oOBwCAA4ADgAOAA4ADAYADCyANQQFqIQFBPiEQDIADCyANQQFqIQFBPyEQDP8CC0HKACEQIAEiDSACRg2XAyACIA1rIAAoAgAiAWohFiANIAFrQQFqIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQaDCgIAAai0AAEcN/QIgAUEBRg3wAiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyXAwtBywAhECABIg0gAkYNlgMgAiANayAAKAIAIgFqIRYgDSABa0EOaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUGiwoCAAGotAABHDfwCIAFBDkYN8AIgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMlgMLQcwAIRAgASINIAJGDZUDIAIgDWsgACgCACIBaiEWIA0gAWtBD2ohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFBwMKAgABqLQAARw37AgJAIAFBD0cNAEEDIQEM8QILIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJUDC0HNACEQIAEiDSACRg2UAyACIA1rIAAoAgAiAWohFiANIAFrQQVqIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQdDCgIAAai0AAEcN+gICQCABQQVHDQBBBCEBDPACCyABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyUAwsCQCABIg0gAkcNAEHOACEQDJQDCwJAAkACQAJAIA0tAAAiAUEgciABIAFBv39qQf8BcUEaSRtB/wFxQZ1/ag4TAP0C/QL9Av0C/QL9Av0C/QL9Av0C/QL9AgH9Av0C/QICA/0CCyANQQFqIQFBwQAhEAz9AgsgDUEBaiEBQcIAIRAM/AILIA1BAWohAUHDACEQDPsCCyANQQFqIQFBxAAhEAz6AgsCQCABIgEgAkYNACAAQY2AgIAANgIIIAAgATYCBCABIQFBxQAhEAz6AgtBzwAhEAySAwsgECEBAkACQCAQLQAAQXZqDgQBqAKoAgCoAgsgEEEBaiEBC0EnIRAM+AILAkAgASIBIAJHDQBB0QAhEAyRAwsCQCABLQAAQSBGDQAgASEBDI0BCyABQQFqIQEgAC0ALUEBcUUNxwEgASEBDIwBCyABIhcgAkcNyAFB0gAhEAyPAwtB0wAhECABIhQgAkYNjgMgAiAUayAAKAIAIgFqIRYgFCABa0EBaiEXA0AgFC0AACABQdbCgIAAai0AAEcNzAEgAUEBRg3HASABQQFqIQEgFEEBaiIUIAJHDQALIAAgFjYCAAyOAwsCQCABIgEgAkcNAEHVACEQDI4DCyABLQAAQQpHDcwBIAFBAWohAQzHAQsCQCABIgEgAkcNAEHWACEQDI0DCwJAAkAgAS0AAEF2ag4EAM0BzQEBzQELIAFBAWohAQzHAQsgAUEBaiEBQcoAIRAM8wILIAAgASIBIAIQroCAgAAiEA3LASABIQFBzQAhEAzyAgsgAC0AKUEiRg2FAwymAgsCQCABIgEgAkcNAEHbACEQDIoDC0EAIRRBASEXQQEhFkEAIRACQAJAAkACQAJAAkACQAJAAkAgAS0AAEFQag4K1AHTAQABAgMEBQYI1QELQQIhEAwGC0EDIRAMBQtBBCEQDAQLQQUhEAwDC0EGIRAMAgtBByEQDAELQQghEAtBACEXQQAhFkEAIRQMzAELQQkhEEEBIRRBACEXQQAhFgzLAQsCQCABIgEgAkcNAEHdACEQDIkDCyABLQAAQS5HDcwBIAFBAWohAQymAgsgASIBIAJHDcwBQd8AIRAMhwMLAkAgASIBIAJGDQAgAEGOgICAADYCCCAAIAE2AgQgASEBQdAAIRAM7gILQeAAIRAMhgMLQeEAIRAgASIBIAJGDYUDIAIgAWsgACgCACIUaiEWIAEgFGtBA2ohFwNAIAEtAAAgFEHiwoCAAGotAABHDc0BIBRBA0YNzAEgFEEBaiEUIAFBAWoiASACRw0ACyAAIBY2AgAMhQMLQeIAIRAgASIBIAJGDYQDIAIgAWsgACgCACIUaiEWIAEgFGtBAmohFwNAIAEtAAAgFEHmwoCAAGotAABHDcwBIBRBAkYNzgEgFEEBaiEUIAFBAWoiASACRw0ACyAAIBY2AgAMhAMLQeMAIRAgASIBIAJGDYMDIAIgAWsgACgCACIUaiEWIAEgFGtBA2ohFwNAIAEtAAAgFEHpwoCAAGotAABHDcsBIBRBA0YNzgEgFEEBaiEUIAFBAWoiASACRw0ACyAAIBY2AgAMgwMLAkAgASIBIAJHDQBB5QAhEAyDAwsgACABQQFqIgEgAhCogICAACIQDc0BIAEhAUHWACEQDOkCCwJAIAEiASACRg0AA0ACQCABLQAAIhBBIEYNAAJAAkACQCAQQbh/ag4LAAHPAc8BzwHPAc8BzwHPAc8BAs8BCyABQQFqIQFB0gAhEAztAgsgAUEBaiEBQdMAIRAM7AILIAFBAWohAUHUACEQDOsCCyABQQFqIgEgAkcNAAtB5AAhEAyCAwtB5AAhEAyBAwsDQAJAIAEtAABB8MKAgABqLQAAIhBBAUYNACAQQX5qDgPPAdAB0QHSAQsgAUEBaiIBIAJHDQALQeYAIRAMgAMLAkAgASIBIAJGDQAgAUEBaiEBDAMLQecAIRAM/wILA0ACQCABLQAAQfDEgIAAai0AACIQQQFGDQACQCAQQX5qDgTSAdMB1AEA1QELIAEhAUHXACEQDOcCCyABQQFqIgEgAkcNAAtB6AAhEAz+AgsCQCABIgEgAkcNAEHpACEQDP4CCwJAIAEtAAAiEEF2ag4augHVAdUBvAHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHKAdUB1QEA0wELIAFBAWohAQtBBiEQDOMCCwNAAkAgAS0AAEHwxoCAAGotAABBAUYNACABIQEMngILIAFBAWoiASACRw0AC0HqACEQDPsCCwJAIAEiASACRg0AIAFBAWohAQwDC0HrACEQDPoCCwJAIAEiASACRw0AQewAIRAM+gILIAFBAWohAQwBCwJAIAEiASACRw0AQe0AIRAM+QILIAFBAWohAQtBBCEQDN4CCwJAIAEiFCACRw0AQe4AIRAM9wILIBQhAQJAAkACQCAULQAAQfDIgIAAai0AAEF/ag4H1AHVAdYBAJwCAQLXAQsgFEEBaiEBDAoLIBRBAWohAQzNAQtBACEQIABBADYCHCAAQZuSgIAANgIQIABBBzYCDCAAIBRBAWo2AhQM9gILAkADQAJAIAEtAABB8MiAgABqLQAAIhBBBEYNAAJAAkAgEEF/ag4H0gHTAdQB2QEABAHZAQsgASEBQdoAIRAM4AILIAFBAWohAUHcACEQDN8CCyABQQFqIgEgAkcNAAtB7wAhEAz2AgsgAUEBaiEBDMsBCwJAIAEiFCACRw0AQfAAIRAM9QILIBQtAABBL0cN1AEgFEEBaiEBDAYLAkAgASIUIAJHDQBB8QAhEAz0AgsCQCAULQAAIgFBL0cNACAUQQFqIQFB3QAhEAzbAgsgAUF2aiIEQRZLDdMBQQEgBHRBiYCAAnFFDdMBDMoCCwJAIAEiASACRg0AIAFBAWohAUHeACEQDNoCC0HyACEQDPICCwJAIAEiFCACRw0AQfQAIRAM8gILIBQhAQJAIBQtAABB8MyAgABqLQAAQX9qDgPJApQCANQBC0HhACEQDNgCCwJAIAEiFCACRg0AA0ACQCAULQAAQfDKgIAAai0AACIBQQNGDQACQCABQX9qDgLLAgDVAQsgFCEBQd8AIRAM2gILIBRBAWoiFCACRw0AC0HzACEQDPECC0HzACEQDPACCwJAIAEiASACRg0AIABBj4CAgAA2AgggACABNgIEIAEhAUHgACEQDNcCC0H1ACEQDO8CCwJAIAEiASACRw0AQfYAIRAM7wILIABBj4CAgAA2AgggACABNgIEIAEhAQtBAyEQDNQCCwNAIAEtAABBIEcNwwIgAUEBaiIBIAJHDQALQfcAIRAM7AILAkAgASIBIAJHDQBB+AAhEAzsAgsgAS0AAEEgRw3OASABQQFqIQEM7wELIAAgASIBIAIQrICAgAAiEA3OASABIQEMjgILAkAgASIEIAJHDQBB+gAhEAzqAgsgBC0AAEHMAEcN0QEgBEEBaiEBQRMhEAzPAQsCQCABIgQgAkcNAEH7ACEQDOkCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRADQCAELQAAIAFB8M6AgABqLQAARw3QASABQQVGDc4BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQfsAIRAM6AILAkAgASIEIAJHDQBB/AAhEAzoAgsCQAJAIAQtAABBvX9qDgwA0QHRAdEB0QHRAdEB0QHRAdEB0QEB0QELIARBAWohAUHmACEQDM8CCyAEQQFqIQFB5wAhEAzOAgsCQCABIgQgAkcNAEH9ACEQDOcCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDc8BIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEH9ACEQDOcCCyAAQQA2AgAgEEEBaiEBQRAhEAzMAQsCQCABIgQgAkcNAEH+ACEQDOYCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUH2zoCAAGotAABHDc4BIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEH+ACEQDOYCCyAAQQA2AgAgEEEBaiEBQRYhEAzLAQsCQCABIgQgAkcNAEH/ACEQDOUCCyACIARrIAAoAgAiAWohFCAEIAFrQQNqIRACQANAIAQtAAAgAUH8zoCAAGotAABHDc0BIAFBA0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEH/ACEQDOUCCyAAQQA2AgAgEEEBaiEBQQUhEAzKAQsCQCABIgQgAkcNAEGAASEQDOQCCyAELQAAQdkARw3LASAEQQFqIQFBCCEQDMkBCwJAIAEiBCACRw0AQYEBIRAM4wILAkACQCAELQAAQbJ/ag4DAMwBAcwBCyAEQQFqIQFB6wAhEAzKAgsgBEEBaiEBQewAIRAMyQILAkAgASIEIAJHDQBBggEhEAziAgsCQAJAIAQtAABBuH9qDggAywHLAcsBywHLAcsBAcsBCyAEQQFqIQFB6gAhEAzJAgsgBEEBaiEBQe0AIRAMyAILAkAgASIEIAJHDQBBgwEhEAzhAgsgAiAEayAAKAIAIgFqIRAgBCABa0ECaiEUAkADQCAELQAAIAFBgM+AgABqLQAARw3JASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBA2AgBBgwEhEAzhAgtBACEQIABBADYCACAUQQFqIQEMxgELAkAgASIEIAJHDQBBhAEhEAzgAgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBg8+AgABqLQAARw3IASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBhAEhEAzgAgsgAEEANgIAIBBBAWohAUEjIRAMxQELAkAgASIEIAJHDQBBhQEhEAzfAgsCQAJAIAQtAABBtH9qDggAyAHIAcgByAHIAcgBAcgBCyAEQQFqIQFB7wAhEAzGAgsgBEEBaiEBQfAAIRAMxQILAkAgASIEIAJHDQBBhgEhEAzeAgsgBC0AAEHFAEcNxQEgBEEBaiEBDIMCCwJAIAEiBCACRw0AQYcBIRAM3QILIAIgBGsgACgCACIBaiEUIAQgAWtBA2ohEAJAA0AgBC0AACABQYjPgIAAai0AAEcNxQEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYcBIRAM3QILIABBADYCACAQQQFqIQFBLSEQDMIBCwJAIAEiBCACRw0AQYgBIRAM3AILIAIgBGsgACgCACIBaiEUIAQgAWtBCGohEAJAA0AgBC0AACABQdDPgIAAai0AAEcNxAEgAUEIRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYgBIRAM3AILIABBADYCACAQQQFqIQFBKSEQDMEBCwJAIAEiASACRw0AQYkBIRAM2wILQQEhECABLQAAQd8ARw3AASABQQFqIQEMgQILAkAgASIEIAJHDQBBigEhEAzaAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQA0AgBC0AACABQYzPgIAAai0AAEcNwQEgAUEBRg2vAiABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGKASEQDNkCCwJAIAEiBCACRw0AQYsBIRAM2QILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQY7PgIAAai0AAEcNwQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYsBIRAM2QILIABBADYCACAQQQFqIQFBAiEQDL4BCwJAIAEiBCACRw0AQYwBIRAM2AILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfDPgIAAai0AAEcNwAEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYwBIRAM2AILIABBADYCACAQQQFqIQFBHyEQDL0BCwJAIAEiBCACRw0AQY0BIRAM1wILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfLPgIAAai0AAEcNvwEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQY0BIRAM1wILIABBADYCACAQQQFqIQFBCSEQDLwBCwJAIAEiBCACRw0AQY4BIRAM1gILAkACQCAELQAAQbd/ag4HAL8BvwG/Ab8BvwEBvwELIARBAWohAUH4ACEQDL0CCyAEQQFqIQFB+QAhEAy8AgsCQCABIgQgAkcNAEGPASEQDNUCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUGRz4CAAGotAABHDb0BIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGPASEQDNUCCyAAQQA2AgAgEEEBaiEBQRghEAy6AQsCQCABIgQgAkcNAEGQASEQDNQCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUGXz4CAAGotAABHDbwBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGQASEQDNQCCyAAQQA2AgAgEEEBaiEBQRchEAy5AQsCQCABIgQgAkcNAEGRASEQDNMCCyACIARrIAAoAgAiAWohFCAEIAFrQQZqIRACQANAIAQtAAAgAUGaz4CAAGotAABHDbsBIAFBBkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGRASEQDNMCCyAAQQA2AgAgEEEBaiEBQRUhEAy4AQsCQCABIgQgAkcNAEGSASEQDNICCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUGhz4CAAGotAABHDboBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGSASEQDNICCyAAQQA2AgAgEEEBaiEBQR4hEAy3AQsCQCABIgQgAkcNAEGTASEQDNECCyAELQAAQcwARw24ASAEQQFqIQFBCiEQDLYBCwJAIAQgAkcNAEGUASEQDNACCwJAAkAgBC0AAEG/f2oODwC5AbkBuQG5AbkBuQG5AbkBuQG5AbkBuQG5AQG5AQsgBEEBaiEBQf4AIRAMtwILIARBAWohAUH/ACEQDLYCCwJAIAQgAkcNAEGVASEQDM8CCwJAAkAgBC0AAEG/f2oOAwC4AQG4AQsgBEEBaiEBQf0AIRAMtgILIARBAWohBEGAASEQDLUCCwJAIAQgAkcNAEGWASEQDM4CCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUGnz4CAAGotAABHDbYBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGWASEQDM4CCyAAQQA2AgAgEEEBaiEBQQshEAyzAQsCQCAEIAJHDQBBlwEhEAzNAgsCQAJAAkACQCAELQAAQVNqDiMAuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AQG4AbgBuAG4AbgBArgBuAG4AQO4AQsgBEEBaiEBQfsAIRAMtgILIARBAWohAUH8ACEQDLUCCyAEQQFqIQRBgQEhEAy0AgsgBEEBaiEEQYIBIRAMswILAkAgBCACRw0AQZgBIRAMzAILIAIgBGsgACgCACIBaiEUIAQgAWtBBGohEAJAA0AgBC0AACABQanPgIAAai0AAEcNtAEgAUEERg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZgBIRAMzAILIABBADYCACAQQQFqIQFBGSEQDLEBCwJAIAQgAkcNAEGZASEQDMsCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUGuz4CAAGotAABHDbMBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGZASEQDMsCCyAAQQA2AgAgEEEBaiEBQQYhEAywAQsCQCAEIAJHDQBBmgEhEAzKAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBtM+AgABqLQAARw2yASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmgEhEAzKAgsgAEEANgIAIBBBAWohAUEcIRAMrwELAkAgBCACRw0AQZsBIRAMyQILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQbbPgIAAai0AAEcNsQEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZsBIRAMyQILIABBADYCACAQQQFqIQFBJyEQDK4BCwJAIAQgAkcNAEGcASEQDMgCCwJAAkAgBC0AAEGsf2oOAgABsQELIARBAWohBEGGASEQDK8CCyAEQQFqIQRBhwEhEAyuAgsCQCAEIAJHDQBBnQEhEAzHAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBuM+AgABqLQAARw2vASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBnQEhEAzHAgsgAEEANgIAIBBBAWohAUEmIRAMrAELAkAgBCACRw0AQZ4BIRAMxgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQbrPgIAAai0AAEcNrgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZ4BIRAMxgILIABBADYCACAQQQFqIQFBAyEQDKsBCwJAIAQgAkcNAEGfASEQDMUCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDa0BIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGfASEQDMUCCyAAQQA2AgAgEEEBaiEBQQwhEAyqAQsCQCAEIAJHDQBBoAEhEAzEAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFBvM+AgABqLQAARw2sASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBoAEhEAzEAgsgAEEANgIAIBBBAWohAUENIRAMqQELAkAgBCACRw0AQaEBIRAMwwILAkACQCAELQAAQbp/ag4LAKwBrAGsAawBrAGsAawBrAGsAQGsAQsgBEEBaiEEQYsBIRAMqgILIARBAWohBEGMASEQDKkCCwJAIAQgAkcNAEGiASEQDMICCyAELQAAQdAARw2pASAEQQFqIQQM6QELAkAgBCACRw0AQaMBIRAMwQILAkACQCAELQAAQbd/ag4HAaoBqgGqAaoBqgEAqgELIARBAWohBEGOASEQDKgCCyAEQQFqIQFBIiEQDKYBCwJAIAQgAkcNAEGkASEQDMACCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUHAz4CAAGotAABHDagBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGkASEQDMACCyAAQQA2AgAgEEEBaiEBQR0hEAylAQsCQCAEIAJHDQBBpQEhEAy/AgsCQAJAIAQtAABBrn9qDgMAqAEBqAELIARBAWohBEGQASEQDKYCCyAEQQFqIQFBBCEQDKQBCwJAIAQgAkcNAEGmASEQDL4CCwJAAkACQAJAAkAgBC0AAEG/f2oOFQCqAaoBqgGqAaoBqgGqAaoBqgGqAQGqAaoBAqoBqgEDqgGqAQSqAQsgBEEBaiEEQYgBIRAMqAILIARBAWohBEGJASEQDKcCCyAEQQFqIQRBigEhEAymAgsgBEEBaiEEQY8BIRAMpQILIARBAWohBEGRASEQDKQCCwJAIAQgAkcNAEGnASEQDL0CCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDaUBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGnASEQDL0CCyAAQQA2AgAgEEEBaiEBQREhEAyiAQsCQCAEIAJHDQBBqAEhEAy8AgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFBws+AgABqLQAARw2kASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBqAEhEAy8AgsgAEEANgIAIBBBAWohAUEsIRAMoQELAkAgBCACRw0AQakBIRAMuwILIAIgBGsgACgCACIBaiEUIAQgAWtBBGohEAJAA0AgBC0AACABQcXPgIAAai0AAEcNowEgAUEERg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQakBIRAMuwILIABBADYCACAQQQFqIQFBKyEQDKABCwJAIAQgAkcNAEGqASEQDLoCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHKz4CAAGotAABHDaIBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGqASEQDLoCCyAAQQA2AgAgEEEBaiEBQRQhEAyfAQsCQCAEIAJHDQBBqwEhEAy5AgsCQAJAAkACQCAELQAAQb5/ag4PAAECpAGkAaQBpAGkAaQBpAGkAaQBpAGkAQOkAQsgBEEBaiEEQZMBIRAMogILIARBAWohBEGUASEQDKECCyAEQQFqIQRBlQEhEAygAgsgBEEBaiEEQZYBIRAMnwILAkAgBCACRw0AQawBIRAMuAILIAQtAABBxQBHDZ8BIARBAWohBAzgAQsCQCAEIAJHDQBBrQEhEAy3AgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFBzc+AgABqLQAARw2fASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBrQEhEAy3AgsgAEEANgIAIBBBAWohAUEOIRAMnAELAkAgBCACRw0AQa4BIRAMtgILIAQtAABB0ABHDZ0BIARBAWohAUElIRAMmwELAkAgBCACRw0AQa8BIRAMtQILIAIgBGsgACgCACIBaiEUIAQgAWtBCGohEAJAA0AgBC0AACABQdDPgIAAai0AAEcNnQEgAUEIRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQa8BIRAMtQILIABBADYCACAQQQFqIQFBKiEQDJoBCwJAIAQgAkcNAEGwASEQDLQCCwJAAkAgBC0AAEGrf2oOCwCdAZ0BnQGdAZ0BnQGdAZ0BnQEBnQELIARBAWohBEGaASEQDJsCCyAEQQFqIQRBmwEhEAyaAgsCQCAEIAJHDQBBsQEhEAyzAgsCQAJAIAQtAABBv39qDhQAnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBAZwBCyAEQQFqIQRBmQEhEAyaAgsgBEEBaiEEQZwBIRAMmQILAkAgBCACRw0AQbIBIRAMsgILIAIgBGsgACgCACIBaiEUIAQgAWtBA2ohEAJAA0AgBC0AACABQdnPgIAAai0AAEcNmgEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbIBIRAMsgILIABBADYCACAQQQFqIQFBISEQDJcBCwJAIAQgAkcNAEGzASEQDLECCyACIARrIAAoAgAiAWohFCAEIAFrQQZqIRACQANAIAQtAAAgAUHdz4CAAGotAABHDZkBIAFBBkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGzASEQDLECCyAAQQA2AgAgEEEBaiEBQRohEAyWAQsCQCAEIAJHDQBBtAEhEAywAgsCQAJAAkAgBC0AAEG7f2oOEQCaAZoBmgGaAZoBmgGaAZoBmgEBmgGaAZoBmgGaAQKaAQsgBEEBaiEEQZ0BIRAMmAILIARBAWohBEGeASEQDJcCCyAEQQFqIQRBnwEhEAyWAgsCQCAEIAJHDQBBtQEhEAyvAgsgAiAEayAAKAIAIgFqIRQgBCABa0EFaiEQAkADQCAELQAAIAFB5M+AgABqLQAARw2XASABQQVGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBtQEhEAyvAgsgAEEANgIAIBBBAWohAUEoIRAMlAELAkAgBCACRw0AQbYBIRAMrgILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQerPgIAAai0AAEcNlgEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbYBIRAMrgILIABBADYCACAQQQFqIQFBByEQDJMBCwJAIAQgAkcNAEG3ASEQDK0CCwJAAkAgBC0AAEG7f2oODgCWAZYBlgGWAZYBlgGWAZYBlgGWAZYBlgEBlgELIARBAWohBEGhASEQDJQCCyAEQQFqIQRBogEhEAyTAgsCQCAEIAJHDQBBuAEhEAysAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFB7c+AgABqLQAARw2UASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBuAEhEAysAgsgAEEANgIAIBBBAWohAUESIRAMkQELAkAgBCACRw0AQbkBIRAMqwILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfDPgIAAai0AAEcNkwEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbkBIRAMqwILIABBADYCACAQQQFqIQFBICEQDJABCwJAIAQgAkcNAEG6ASEQDKoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUHyz4CAAGotAABHDZIBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG6ASEQDKoCCyAAQQA2AgAgEEEBaiEBQQ8hEAyPAQsCQCAEIAJHDQBBuwEhEAypAgsCQAJAIAQtAABBt39qDgcAkgGSAZIBkgGSAQGSAQsgBEEBaiEEQaUBIRAMkAILIARBAWohBEGmASEQDI8CCwJAIAQgAkcNAEG8ASEQDKgCCyACIARrIAAoAgAiAWohFCAEIAFrQQdqIRACQANAIAQtAAAgAUH0z4CAAGotAABHDZABIAFBB0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG8ASEQDKgCCyAAQQA2AgAgEEEBaiEBQRshEAyNAQsCQCAEIAJHDQBBvQEhEAynAgsCQAJAAkAgBC0AAEG+f2oOEgCRAZEBkQGRAZEBkQGRAZEBkQEBkQGRAZEBkQGRAZEBApEBCyAEQQFqIQRBpAEhEAyPAgsgBEEBaiEEQacBIRAMjgILIARBAWohBEGoASEQDI0CCwJAIAQgAkcNAEG+ASEQDKYCCyAELQAAQc4ARw2NASAEQQFqIQQMzwELAkAgBCACRw0AQb8BIRAMpQILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBC0AAEG/f2oOFQABAgOcAQQFBpwBnAGcAQcICQoLnAEMDQ4PnAELIARBAWohAUHoACEQDJoCCyAEQQFqIQFB6QAhEAyZAgsgBEEBaiEBQe4AIRAMmAILIARBAWohAUHyACEQDJcCCyAEQQFqIQFB8wAhEAyWAgsgBEEBaiEBQfYAIRAMlQILIARBAWohAUH3ACEQDJQCCyAEQQFqIQFB+gAhEAyTAgsgBEEBaiEEQYMBIRAMkgILIARBAWohBEGEASEQDJECCyAEQQFqIQRBhQEhEAyQAgsgBEEBaiEEQZIBIRAMjwILIARBAWohBEGYASEQDI4CCyAEQQFqIQRBoAEhEAyNAgsgBEEBaiEEQaMBIRAMjAILIARBAWohBEGqASEQDIsCCwJAIAQgAkYNACAAQZCAgIAANgIIIAAgBDYCBEGrASEQDIsCC0HAASEQDKMCCyAAIAUgAhCqgICAACIBDYsBIAUhAQxcCwJAIAYgAkYNACAGQQFqIQUMjQELQcIBIRAMoQILA0ACQCAQLQAAQXZqDgSMAQAAjwEACyAQQQFqIhAgAkcNAAtBwwEhEAygAgsCQCAHIAJGDQAgAEGRgICAADYCCCAAIAc2AgQgByEBQQEhEAyHAgtBxAEhEAyfAgsCQCAHIAJHDQBBxQEhEAyfAgsCQAJAIActAABBdmoOBAHOAc4BAM4BCyAHQQFqIQYMjQELIAdBAWohBQyJAQsCQCAHIAJHDQBBxgEhEAyeAgsCQAJAIActAABBdmoOFwGPAY8BAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAQCPAQsgB0EBaiEHC0GwASEQDIQCCwJAIAggAkcNAEHIASEQDJ0CCyAILQAAQSBHDY0BIABBADsBMiAIQQFqIQFBswEhEAyDAgsgASEXAkADQCAXIgcgAkYNASAHLQAAQVBqQf8BcSIQQQpPDcwBAkAgAC8BMiIUQZkzSw0AIAAgFEEKbCIUOwEyIBBB//8DcyAUQf7/A3FJDQAgB0EBaiEXIAAgFCAQaiIQOwEyIBBB//8DcUHoB0kNAQsLQQAhECAAQQA2AhwgAEHBiYCAADYCECAAQQ02AgwgACAHQQFqNgIUDJwCC0HHASEQDJsCCyAAIAggAhCugICAACIQRQ3KASAQQRVHDYwBIABByAE2AhwgACAINgIUIABByZeAgAA2AhAgAEEVNgIMQQAhEAyaAgsCQCAJIAJHDQBBzAEhEAyaAgtBACEUQQEhF0EBIRZBACEQAkACQAJAAkACQAJAAkACQAJAIAktAABBUGoOCpYBlQEAAQIDBAUGCJcBC0ECIRAMBgtBAyEQDAULQQQhEAwEC0EFIRAMAwtBBiEQDAILQQchEAwBC0EIIRALQQAhF0EAIRZBACEUDI4BC0EJIRBBASEUQQAhF0EAIRYMjQELAkAgCiACRw0AQc4BIRAMmQILIAotAABBLkcNjgEgCkEBaiEJDMoBCyALIAJHDY4BQdABIRAMlwILAkAgCyACRg0AIABBjoCAgAA2AgggACALNgIEQbcBIRAM/gELQdEBIRAMlgILAkAgBCACRw0AQdIBIRAMlgILIAIgBGsgACgCACIQaiEUIAQgEGtBBGohCwNAIAQtAAAgEEH8z4CAAGotAABHDY4BIBBBBEYN6QEgEEEBaiEQIARBAWoiBCACRw0ACyAAIBQ2AgBB0gEhEAyVAgsgACAMIAIQrICAgAAiAQ2NASAMIQEMuAELAkAgBCACRw0AQdQBIRAMlAILIAIgBGsgACgCACIQaiEUIAQgEGtBAWohDANAIAQtAAAgEEGB0ICAAGotAABHDY8BIBBBAUYNjgEgEEEBaiEQIARBAWoiBCACRw0ACyAAIBQ2AgBB1AEhEAyTAgsCQCAEIAJHDQBB1gEhEAyTAgsgAiAEayAAKAIAIhBqIRQgBCAQa0ECaiELA0AgBC0AACAQQYPQgIAAai0AAEcNjgEgEEECRg2QASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHWASEQDJICCwJAIAQgAkcNAEHXASEQDJICCwJAAkAgBC0AAEG7f2oOEACPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BAY8BCyAEQQFqIQRBuwEhEAz5AQsgBEEBaiEEQbwBIRAM+AELAkAgBCACRw0AQdgBIRAMkQILIAQtAABByABHDYwBIARBAWohBAzEAQsCQCAEIAJGDQAgAEGQgICAADYCCCAAIAQ2AgRBvgEhEAz3AQtB2QEhEAyPAgsCQCAEIAJHDQBB2gEhEAyPAgsgBC0AAEHIAEYNwwEgAEEBOgAoDLkBCyAAQQI6AC8gACAEIAIQpoCAgAAiEA2NAUHCASEQDPQBCyAALQAoQX9qDgK3AbkBuAELA0ACQCAELQAAQXZqDgQAjgGOAQCOAQsgBEEBaiIEIAJHDQALQd0BIRAMiwILIABBADoALyAALQAtQQRxRQ2EAgsgAEEAOgAvIABBAToANCABIQEMjAELIBBBFUYN2gEgAEEANgIcIAAgATYCFCAAQaeOgIAANgIQIABBEjYCDEEAIRAMiAILAkAgACAQIAIQtICAgAAiBA0AIBAhAQyBAgsCQCAEQRVHDQAgAEEDNgIcIAAgEDYCFCAAQbCYgIAANgIQIABBFTYCDEEAIRAMiAILIABBADYCHCAAIBA2AhQgAEGnjoCAADYCECAAQRI2AgxBACEQDIcCCyAQQRVGDdYBIABBADYCHCAAIAE2AhQgAEHajYCAADYCECAAQRQ2AgxBACEQDIYCCyAAKAIEIRcgAEEANgIEIBAgEadqIhYhASAAIBcgECAWIBQbIhAQtYCAgAAiFEUNjQEgAEEHNgIcIAAgEDYCFCAAIBQ2AgxBACEQDIUCCyAAIAAvATBBgAFyOwEwIAEhAQtBKiEQDOoBCyAQQRVGDdEBIABBADYCHCAAIAE2AhQgAEGDjICAADYCECAAQRM2AgxBACEQDIICCyAQQRVGDc8BIABBADYCHCAAIAE2AhQgAEGaj4CAADYCECAAQSI2AgxBACEQDIECCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQt4CAgAAiEA0AIAFBAWohAQyNAQsgAEEMNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDIACCyAQQRVGDcwBIABBADYCHCAAIAE2AhQgAEGaj4CAADYCECAAQSI2AgxBACEQDP8BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQt4CAgAAiEA0AIAFBAWohAQyMAQsgAEENNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDP4BCyAQQRVGDckBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAAQSM2AgxBACEQDP0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQuYCAgAAiEA0AIAFBAWohAQyLAQsgAEEONgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDPwBCyAAQQA2AhwgACABNgIUIABBwJWAgAA2AhAgAEECNgIMQQAhEAz7AQsgEEEVRg3FASAAQQA2AhwgACABNgIUIABBxoyAgAA2AhAgAEEjNgIMQQAhEAz6AQsgAEEQNgIcIAAgATYCFCAAIBA2AgxBACEQDPkBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQuYCAgAAiBA0AIAFBAWohAQzxAQsgAEERNgIcIAAgBDYCDCAAIAFBAWo2AhRBACEQDPgBCyAQQRVGDcEBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAAQSM2AgxBACEQDPcBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQuYCAgAAiEA0AIAFBAWohAQyIAQsgAEETNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDPYBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQuYCAgAAiBA0AIAFBAWohAQztAQsgAEEUNgIcIAAgBDYCDCAAIAFBAWo2AhRBACEQDPUBCyAQQRVGDb0BIABBADYCHCAAIAE2AhQgAEGaj4CAADYCECAAQSI2AgxBACEQDPQBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQt4CAgAAiEA0AIAFBAWohAQyGAQsgAEEWNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDPMBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQt4CAgAAiBA0AIAFBAWohAQzpAQsgAEEXNgIcIAAgBDYCDCAAIAFBAWo2AhRBACEQDPIBCyAAQQA2AhwgACABNgIUIABBzZOAgAA2AhAgAEEMNgIMQQAhEAzxAQtCASERCyAQQQFqIQECQCAAKQMgIhJC//////////8PVg0AIAAgEkIEhiARhDcDICABIQEMhAELIABBADYCHCAAIAE2AhQgAEGtiYCAADYCECAAQQw2AgxBACEQDO8BCyAAQQA2AhwgACAQNgIUIABBzZOAgAA2AhAgAEEMNgIMQQAhEAzuAQsgACgCBCEXIABBADYCBCAQIBGnaiIWIQEgACAXIBAgFiAUGyIQELWAgIAAIhRFDXMgAEEFNgIcIAAgEDYCFCAAIBQ2AgxBACEQDO0BCyAAQQA2AhwgACAQNgIUIABBqpyAgAA2AhAgAEEPNgIMQQAhEAzsAQsgACAQIAIQtICAgAAiAQ0BIBAhAQtBDiEQDNEBCwJAIAFBFUcNACAAQQI2AhwgACAQNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAzqAQsgAEEANgIcIAAgEDYCFCAAQaeOgIAANgIQIABBEjYCDEEAIRAM6QELIAFBAWohEAJAIAAvATAiAUGAAXFFDQACQCAAIBAgAhC7gICAACIBDQAgECEBDHALIAFBFUcNugEgAEEFNgIcIAAgEDYCFCAAQfmXgIAANgIQIABBFTYCDEEAIRAM6QELAkAgAUGgBHFBoARHDQAgAC0ALUECcQ0AIABBADYCHCAAIBA2AhQgAEGWk4CAADYCECAAQQQ2AgxBACEQDOkBCyAAIBAgAhC9gICAABogECEBAkACQAJAAkACQCAAIBAgAhCzgICAAA4WAgEABAQEBAQEBAQEBAQEBAQEBAQEAwQLIABBAToALgsgACAALwEwQcAAcjsBMCAQIQELQSYhEAzRAQsgAEEjNgIcIAAgEDYCFCAAQaWWgIAANgIQIABBFTYCDEEAIRAM6QELIABBADYCHCAAIBA2AhQgAEHVi4CAADYCECAAQRE2AgxBACEQDOgBCyAALQAtQQFxRQ0BQcMBIRAMzgELAkAgDSACRg0AA0ACQCANLQAAQSBGDQAgDSEBDMQBCyANQQFqIg0gAkcNAAtBJSEQDOcBC0ElIRAM5gELIAAoAgQhBCAAQQA2AgQgACAEIA0Qr4CAgAAiBEUNrQEgAEEmNgIcIAAgBDYCDCAAIA1BAWo2AhRBACEQDOUBCyAQQRVGDasBIABBADYCHCAAIAE2AhQgAEH9jYCAADYCECAAQR02AgxBACEQDOQBCyAAQSc2AhwgACABNgIUIAAgEDYCDEEAIRAM4wELIBAhAUEBIRQCQAJAAkACQAJAAkACQCAALQAsQX5qDgcGBQUDAQIABQsgACAALwEwQQhyOwEwDAMLQQIhFAwBC0EEIRQLIABBAToALCAAIAAvATAgFHI7ATALIBAhAQtBKyEQDMoBCyAAQQA2AhwgACAQNgIUIABBq5KAgAA2AhAgAEELNgIMQQAhEAziAQsgAEEANgIcIAAgATYCFCAAQeGPgIAANgIQIABBCjYCDEEAIRAM4QELIABBADoALCAQIQEMvQELIBAhAUEBIRQCQAJAAkACQAJAIAAtACxBe2oOBAMBAgAFCyAAIAAvATBBCHI7ATAMAwtBAiEUDAELQQQhFAsgAEEBOgAsIAAgAC8BMCAUcjsBMAsgECEBC0EpIRAMxQELIABBADYCHCAAIAE2AhQgAEHwlICAADYCECAAQQM2AgxBACEQDN0BCwJAIA4tAABBDUcNACAAKAIEIQEgAEEANgIEAkAgACABIA4QsYCAgAAiAQ0AIA5BAWohAQx1CyAAQSw2AhwgACABNgIMIAAgDkEBajYCFEEAIRAM3QELIAAtAC1BAXFFDQFBxAEhEAzDAQsCQCAOIAJHDQBBLSEQDNwBCwJAAkADQAJAIA4tAABBdmoOBAIAAAMACyAOQQFqIg4gAkcNAAtBLSEQDN0BCyAAKAIEIQEgAEEANgIEAkAgACABIA4QsYCAgAAiAQ0AIA4hAQx0CyAAQSw2AhwgACAONgIUIAAgATYCDEEAIRAM3AELIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDkEBaiEBDHMLIABBLDYCHCAAIAE2AgwgACAOQQFqNgIUQQAhEAzbAQsgACgCBCEEIABBADYCBCAAIAQgDhCxgICAACIEDaABIA4hAQzOAQsgEEEsRw0BIAFBAWohEEEBIQECQAJAAkACQAJAIAAtACxBe2oOBAMBAgQACyAQIQEMBAtBAiEBDAELQQQhAQsgAEEBOgAsIAAgAC8BMCABcjsBMCAQIQEMAQsgACAALwEwQQhyOwEwIBAhAQtBOSEQDL8BCyAAQQA6ACwgASEBC0E0IRAMvQELIAAgAC8BMEEgcjsBMCABIQEMAgsgACgCBCEEIABBADYCBAJAIAAgBCABELGAgIAAIgQNACABIQEMxwELIABBNzYCHCAAIAE2AhQgACAENgIMQQAhEAzUAQsgAEEIOgAsIAEhAQtBMCEQDLkBCwJAIAAtAChBAUYNACABIQEMBAsgAC0ALUEIcUUNkwEgASEBDAMLIAAtADBBIHENlAFBxQEhEAy3AQsCQCAPIAJGDQACQANAAkAgDy0AAEFQaiIBQf8BcUEKSQ0AIA8hAUE1IRAMugELIAApAyAiEUKZs+bMmbPmzBlWDQEgACARQgp+IhE3AyAgESABrUL/AYMiEkJ/hVYNASAAIBEgEnw3AyAgD0EBaiIPIAJHDQALQTkhEAzRAQsgACgCBCECIABBADYCBCAAIAIgD0EBaiIEELGAgIAAIgINlQEgBCEBDMMBC0E5IRAMzwELAkAgAC8BMCIBQQhxRQ0AIAAtAChBAUcNACAALQAtQQhxRQ2QAQsgACABQff7A3FBgARyOwEwIA8hAQtBNyEQDLQBCyAAIAAvATBBEHI7ATAMqwELIBBBFUYNiwEgAEEANgIcIAAgATYCFCAAQfCOgIAANgIQIABBHDYCDEEAIRAMywELIABBwwA2AhwgACABNgIMIAAgDUEBajYCFEEAIRAMygELAkAgAS0AAEE6Rw0AIAAoAgQhECAAQQA2AgQCQCAAIBAgARCvgICAACIQDQAgAUEBaiEBDGMLIABBwwA2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAMygELIABBADYCHCAAIAE2AhQgAEGxkYCAADYCECAAQQo2AgxBACEQDMkBCyAAQQA2AhwgACABNgIUIABBoJmAgAA2AhAgAEEeNgIMQQAhEAzIAQsgAEEANgIACyAAQYASOwEqIAAgF0EBaiIBIAIQqICAgAAiEA0BIAEhAQtBxwAhEAysAQsgEEEVRw2DASAAQdEANgIcIAAgATYCFCAAQeOXgIAANgIQIABBFTYCDEEAIRAMxAELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDF4LIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMwwELIABBADYCHCAAIBQ2AhQgAEHBqICAADYCECAAQQc2AgwgAEEANgIAQQAhEAzCAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMXQsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAzBAQtBACEQIABBADYCHCAAIAE2AhQgAEGAkYCAADYCECAAQQk2AgwMwAELIBBBFUYNfSAAQQA2AhwgACABNgIUIABBlI2AgAA2AhAgAEEhNgIMQQAhEAy/AQtBASEWQQAhF0EAIRRBASEQCyAAIBA6ACsgAUEBaiEBAkACQCAALQAtQRBxDQACQAJAAkAgAC0AKg4DAQACBAsgFkUNAwwCCyAUDQEMAgsgF0UNAQsgACgCBCEQIABBADYCBAJAIAAgECABEK2AgIAAIhANACABIQEMXAsgAEHYADYCHCAAIAE2AhQgACAQNgIMQQAhEAy+AQsgACgCBCEEIABBADYCBAJAIAAgBCABEK2AgIAAIgQNACABIQEMrQELIABB2QA2AhwgACABNgIUIAAgBDYCDEEAIRAMvQELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKsBCyAAQdoANgIcIAAgATYCFCAAIAQ2AgxBACEQDLwBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQrYCAgAAiBA0AIAEhAQypAQsgAEHcADYCHCAAIAE2AhQgACAENgIMQQAhEAy7AQsCQCABLQAAQVBqIhBB/wFxQQpPDQAgACAQOgAqIAFBAWohAUHPACEQDKIBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQrYCAgAAiBA0AIAEhAQynAQsgAEHeADYCHCAAIAE2AhQgACAENgIMQQAhEAy6AQsgAEEANgIAIBdBAWohAQJAIAAtAClBI08NACABIQEMWQsgAEEANgIcIAAgATYCFCAAQdOJgIAANgIQIABBCDYCDEEAIRAMuQELIABBADYCAAtBACEQIABBADYCHCAAIAE2AhQgAEGQs4CAADYCECAAQQg2AgwMtwELIABBADYCACAXQQFqIQECQCAALQApQSFHDQAgASEBDFYLIABBADYCHCAAIAE2AhQgAEGbioCAADYCECAAQQg2AgxBACEQDLYBCyAAQQA2AgAgF0EBaiEBAkAgAC0AKSIQQV1qQQtPDQAgASEBDFULAkAgEEEGSw0AQQEgEHRBygBxRQ0AIAEhAQxVC0EAIRAgAEEANgIcIAAgATYCFCAAQfeJgIAANgIQIABBCDYCDAy1AQsgEEEVRg1xIABBADYCHCAAIAE2AhQgAEG5jYCAADYCECAAQRo2AgxBACEQDLQBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxUCyAAQeUANgIcIAAgATYCFCAAIBA2AgxBACEQDLMBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxNCyAAQdIANgIcIAAgATYCFCAAIBA2AgxBACEQDLIBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxNCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDLEBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxRCyAAQeUANgIcIAAgATYCFCAAIBA2AgxBACEQDLABCyAAQQA2AhwgACABNgIUIABBxoqAgAA2AhAgAEEHNgIMQQAhEAyvAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMSQsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAyuAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMSQsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAytAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMTQsgAEHlADYCHCAAIAE2AhQgACAQNgIMQQAhEAysAQsgAEEANgIcIAAgATYCFCAAQdyIgIAANgIQIABBBzYCDEEAIRAMqwELIBBBP0cNASABQQFqIQELQQUhEAyQAQtBACEQIABBADYCHCAAIAE2AhQgAEH9koCAADYCECAAQQc2AgwMqAELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDEILIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMpwELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDEILIABB0wA2AhwgACABNgIUIAAgEDYCDEEAIRAMpgELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDEYLIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMpQELIAAoAgQhASAAQQA2AgQCQCAAIAEgFBCngICAACIBDQAgFCEBDD8LIABB0gA2AhwgACAUNgIUIAAgATYCDEEAIRAMpAELIAAoAgQhASAAQQA2AgQCQCAAIAEgFBCngICAACIBDQAgFCEBDD8LIABB0wA2AhwgACAUNgIUIAAgATYCDEEAIRAMowELIAAoAgQhASAAQQA2AgQCQCAAIAEgFBCngICAACIBDQAgFCEBDEMLIABB5QA2AhwgACAUNgIUIAAgATYCDEEAIRAMogELIABBADYCHCAAIBQ2AhQgAEHDj4CAADYCECAAQQc2AgxBACEQDKEBCyAAQQA2AhwgACABNgIUIABBw4+AgAA2AhAgAEEHNgIMQQAhEAygAQtBACEQIABBADYCHCAAIBQ2AhQgAEGMnICAADYCECAAQQc2AgwMnwELIABBADYCHCAAIBQ2AhQgAEGMnICAADYCECAAQQc2AgxBACEQDJ4BCyAAQQA2AhwgACAUNgIUIABB/pGAgAA2AhAgAEEHNgIMQQAhEAydAQsgAEEANgIcIAAgATYCFCAAQY6bgIAANgIQIABBBjYCDEEAIRAMnAELIBBBFUYNVyAAQQA2AhwgACABNgIUIABBzI6AgAA2AhAgAEEgNgIMQQAhEAybAQsgAEEANgIAIBBBAWohAUEkIRALIAAgEDoAKSAAKAIEIRAgAEEANgIEIAAgECABEKuAgIAAIhANVCABIQEMPgsgAEEANgIAC0EAIRAgAEEANgIcIAAgBDYCFCAAQfGbgIAANgIQIABBBjYCDAyXAQsgAUEVRg1QIABBADYCHCAAIAU2AhQgAEHwjICAADYCECAAQRs2AgxBACEQDJYBCyAAKAIEIQUgAEEANgIEIAAgBSAQEKmAgIAAIgUNASAQQQFqIQULQa0BIRAMewsgAEHBATYCHCAAIAU2AgwgACAQQQFqNgIUQQAhEAyTAQsgACgCBCEGIABBADYCBCAAIAYgEBCpgICAACIGDQEgEEEBaiEGC0GuASEQDHgLIABBwgE2AhwgACAGNgIMIAAgEEEBajYCFEEAIRAMkAELIABBADYCHCAAIAc2AhQgAEGXi4CAADYCECAAQQ02AgxBACEQDI8BCyAAQQA2AhwgACAINgIUIABB45CAgAA2AhAgAEEJNgIMQQAhEAyOAQsgAEEANgIcIAAgCDYCFCAAQZSNgIAANgIQIABBITYCDEEAIRAMjQELQQEhFkEAIRdBACEUQQEhEAsgACAQOgArIAlBAWohCAJAAkAgAC0ALUEQcQ0AAkACQAJAIAAtACoOAwEAAgQLIBZFDQMMAgsgFA0BDAILIBdFDQELIAAoAgQhECAAQQA2AgQgACAQIAgQrYCAgAAiEEUNPSAAQckBNgIcIAAgCDYCFCAAIBA2AgxBACEQDIwBCyAAKAIEIQQgAEEANgIEIAAgBCAIEK2AgIAAIgRFDXYgAEHKATYCHCAAIAg2AhQgACAENgIMQQAhEAyLAQsgACgCBCEEIABBADYCBCAAIAQgCRCtgICAACIERQ10IABBywE2AhwgACAJNgIUIAAgBDYCDEEAIRAMigELIAAoAgQhBCAAQQA2AgQgACAEIAoQrYCAgAAiBEUNciAAQc0BNgIcIAAgCjYCFCAAIAQ2AgxBACEQDIkBCwJAIAstAABBUGoiEEH/AXFBCk8NACAAIBA6ACogC0EBaiEKQbYBIRAMcAsgACgCBCEEIABBADYCBCAAIAQgCxCtgICAACIERQ1wIABBzwE2AhwgACALNgIUIAAgBDYCDEEAIRAMiAELIABBADYCHCAAIAQ2AhQgAEGQs4CAADYCECAAQQg2AgwgAEEANgIAQQAhEAyHAQsgAUEVRg0/IABBADYCHCAAIAw2AhQgAEHMjoCAADYCECAAQSA2AgxBACEQDIYBCyAAQYEEOwEoIAAoAgQhECAAQgA3AwAgACAQIAxBAWoiDBCrgICAACIQRQ04IABB0wE2AhwgACAMNgIUIAAgEDYCDEEAIRAMhQELIABBADYCAAtBACEQIABBADYCHCAAIAQ2AhQgAEHYm4CAADYCECAAQQg2AgwMgwELIAAoAgQhECAAQgA3AwAgACAQIAtBAWoiCxCrgICAACIQDQFBxgEhEAxpCyAAQQI6ACgMVQsgAEHVATYCHCAAIAs2AhQgACAQNgIMQQAhEAyAAQsgEEEVRg03IABBADYCHCAAIAQ2AhQgAEGkjICAADYCECAAQRA2AgxBACEQDH8LIAAtADRBAUcNNCAAIAQgAhC8gICAACIQRQ00IBBBFUcNNSAAQdwBNgIcIAAgBDYCFCAAQdWWgIAANgIQIABBFTYCDEEAIRAMfgtBACEQIABBADYCHCAAQa+LgIAANgIQIABBAjYCDCAAIBRBAWo2AhQMfQtBACEQDGMLQQIhEAxiC0ENIRAMYQtBDyEQDGALQSUhEAxfC0ETIRAMXgtBFSEQDF0LQRYhEAxcC0EXIRAMWwtBGCEQDFoLQRkhEAxZC0EaIRAMWAtBGyEQDFcLQRwhEAxWC0EdIRAMVQtBHyEQDFQLQSEhEAxTC0EjIRAMUgtBxgAhEAxRC0EuIRAMUAtBLyEQDE8LQTshEAxOC0E9IRAMTQtByAAhEAxMC0HJACEQDEsLQcsAIRAMSgtBzAAhEAxJC0HOACEQDEgLQdEAIRAMRwtB1QAhEAxGC0HYACEQDEULQdkAIRAMRAtB2wAhEAxDC0HkACEQDEILQeUAIRAMQQtB8QAhEAxAC0H0ACEQDD8LQY0BIRAMPgtBlwEhEAw9C0GpASEQDDwLQawBIRAMOwtBwAEhEAw6C0G5ASEQDDkLQa8BIRAMOAtBsQEhEAw3C0GyASEQDDYLQbQBIRAMNQtBtQEhEAw0C0G6ASEQDDMLQb0BIRAMMgtBvwEhEAwxC0HBASEQDDALIABBADYCHCAAIAQ2AhQgAEHpi4CAADYCECAAQR82AgxBACEQDEgLIABB2wE2AhwgACAENgIUIABB+paAgAA2AhAgAEEVNgIMQQAhEAxHCyAAQfgANgIcIAAgDDYCFCAAQcqYgIAANgIQIABBFTYCDEEAIRAMRgsgAEHRADYCHCAAIAU2AhQgAEGwl4CAADYCECAAQRU2AgxBACEQDEULIABB+QA2AhwgACABNgIUIAAgEDYCDEEAIRAMRAsgAEH4ADYCHCAAIAE2AhQgAEHKmICAADYCECAAQRU2AgxBACEQDEMLIABB5AA2AhwgACABNgIUIABB45eAgAA2AhAgAEEVNgIMQQAhEAxCCyAAQdcANgIcIAAgATYCFCAAQcmXgIAANgIQIABBFTYCDEEAIRAMQQsgAEEANgIcIAAgATYCFCAAQbmNgIAANgIQIABBGjYCDEEAIRAMQAsgAEHCADYCHCAAIAE2AhQgAEHjmICAADYCECAAQRU2AgxBACEQDD8LIABBADYCBCAAIA8gDxCxgICAACIERQ0BIABBOjYCHCAAIAQ2AgwgACAPQQFqNgIUQQAhEAw+CyAAKAIEIQQgAEEANgIEAkAgACAEIAEQsYCAgAAiBEUNACAAQTs2AhwgACAENgIMIAAgAUEBajYCFEEAIRAMPgsgAUEBaiEBDC0LIA9BAWohAQwtCyAAQQA2AhwgACAPNgIUIABB5JKAgAA2AhAgAEEENgIMQQAhEAw7CyAAQTY2AhwgACAENgIUIAAgAjYCDEEAIRAMOgsgAEEuNgIcIAAgDjYCFCAAIAQ2AgxBACEQDDkLIABB0AA2AhwgACABNgIUIABBkZiAgAA2AhAgAEEVNgIMQQAhEAw4CyANQQFqIQEMLAsgAEEVNgIcIAAgATYCFCAAQYKZgIAANgIQIABBFTYCDEEAIRAMNgsgAEEbNgIcIAAgATYCFCAAQZGXgIAANgIQIABBFTYCDEEAIRAMNQsgAEEPNgIcIAAgATYCFCAAQZGXgIAANgIQIABBFTYCDEEAIRAMNAsgAEELNgIcIAAgATYCFCAAQZGXgIAANgIQIABBFTYCDEEAIRAMMwsgAEEaNgIcIAAgATYCFCAAQYKZgIAANgIQIABBFTYCDEEAIRAMMgsgAEELNgIcIAAgATYCFCAAQYKZgIAANgIQIABBFTYCDEEAIRAMMQsgAEEKNgIcIAAgATYCFCAAQeSWgIAANgIQIABBFTYCDEEAIRAMMAsgAEEeNgIcIAAgATYCFCAAQfmXgIAANgIQIABBFTYCDEEAIRAMLwsgAEEANgIcIAAgEDYCFCAAQdqNgIAANgIQIABBFDYCDEEAIRAMLgsgAEEENgIcIAAgATYCFCAAQbCYgIAANgIQIABBFTYCDEEAIRAMLQsgAEEANgIAIAtBAWohCwtBuAEhEAwSCyAAQQA2AgAgEEEBaiEBQfUAIRAMEQsgASEBAkAgAC0AKUEFRw0AQeMAIRAMEQtB4gAhEAwQC0EAIRAgAEEANgIcIABB5JGAgAA2AhAgAEEHNgIMIAAgFEEBajYCFAwoCyAAQQA2AgAgF0EBaiEBQcAAIRAMDgtBASEBCyAAIAE6ACwgAEEANgIAIBdBAWohAQtBKCEQDAsLIAEhAQtBOCEQDAkLAkAgASIPIAJGDQADQAJAIA8tAABBgL6AgABqLQAAIgFBAUYNACABQQJHDQMgD0EBaiEBDAQLIA9BAWoiDyACRw0AC0E+IRAMIgtBPiEQDCELIABBADoALCAPIQEMAQtBCyEQDAYLQTohEAwFCyABQQFqIQFBLSEQDAQLIAAgAToALCAAQQA2AgAgFkEBaiEBQQwhEAwDCyAAQQA2AgAgF0EBaiEBQQohEAwCCyAAQQA2AgALIABBADoALCANIQFBCSEQDAALC0EAIRAgAEEANgIcIAAgCzYCFCAAQc2QgIAANgIQIABBCTYCDAwXC0EAIRAgAEEANgIcIAAgCjYCFCAAQemKgIAANgIQIABBCTYCDAwWC0EAIRAgAEEANgIcIAAgCTYCFCAAQbeQgIAANgIQIABBCTYCDAwVC0EAIRAgAEEANgIcIAAgCDYCFCAAQZyRgIAANgIQIABBCTYCDAwUC0EAIRAgAEEANgIcIAAgATYCFCAAQc2QgIAANgIQIABBCTYCDAwTC0EAIRAgAEEANgIcIAAgATYCFCAAQemKgIAANgIQIABBCTYCDAwSC0EAIRAgAEEANgIcIAAgATYCFCAAQbeQgIAANgIQIABBCTYCDAwRC0EAIRAgAEEANgIcIAAgATYCFCAAQZyRgIAANgIQIABBCTYCDAwQC0EAIRAgAEEANgIcIAAgATYCFCAAQZeVgIAANgIQIABBDzYCDAwPC0EAIRAgAEEANgIcIAAgATYCFCAAQZeVgIAANgIQIABBDzYCDAwOC0EAIRAgAEEANgIcIAAgATYCFCAAQcCSgIAANgIQIABBCzYCDAwNC0EAIRAgAEEANgIcIAAgATYCFCAAQZWJgIAANgIQIABBCzYCDAwMC0EAIRAgAEEANgIcIAAgATYCFCAAQeGPgIAANgIQIABBCjYCDAwLC0EAIRAgAEEANgIcIAAgATYCFCAAQfuPgIAANgIQIABBCjYCDAwKC0EAIRAgAEEANgIcIAAgATYCFCAAQfGZgIAANgIQIABBAjYCDAwJC0EAIRAgAEEANgIcIAAgATYCFCAAQcSUgIAANgIQIABBAjYCDAwIC0EAIRAgAEEANgIcIAAgATYCFCAAQfKVgIAANgIQIABBAjYCDAwHCyAAQQI2AhwgACABNgIUIABBnJqAgAA2AhAgAEEWNgIMQQAhEAwGC0EBIRAMBQtB1AAhECABIgQgAkYNBCADQQhqIAAgBCACQdjCgIAAQQoQxYCAgAAgAygCDCEEIAMoAggOAwEEAgALEMqAgIAAAAsgAEEANgIcIABBtZqAgAA2AhAgAEEXNgIMIAAgBEEBajYCFEEAIRAMAgsgAEEANgIcIAAgBDYCFCAAQcqagIAANgIQIABBCTYCDEEAIRAMAQsCQCABIgQgAkcNAEEiIRAMAQsgAEGJgICAADYCCCAAIAQ2AgRBISEQCyADQRBqJICAgIAAIBALrwEBAn8gASgCACEGAkACQCACIANGDQAgBCAGaiEEIAYgA2ogAmshByACIAZBf3MgBWoiBmohBQNAAkAgAi0AACAELQAARg0AQQIhBAwDCwJAIAYNAEEAIQQgBSECDAMLIAZBf2ohBiAEQQFqIQQgAkEBaiICIANHDQALIAchBiADIQILIABBATYCACABIAY2AgAgACACNgIEDwsgAUEANgIAIAAgBDYCACAAIAI2AgQLCgAgABDHgICAAAvyNgELfyOAgICAAEEQayIBJICAgIAAAkBBACgCoNCAgAANAEEAEMuAgIAAQYDUhIAAayICQdkASQ0AQQAhAwJAQQAoAuDTgIAAIgQNAEEAQn83AuzTgIAAQQBCgICEgICAwAA3AuTTgIAAQQAgAUEIakFwcUHYqtWqBXMiBDYC4NOAgABBAEEANgL004CAAEEAQQA2AsTTgIAAC0EAIAI2AszTgIAAQQBBgNSEgAA2AsjTgIAAQQBBgNSEgAA2ApjQgIAAQQAgBDYCrNCAgABBAEF/NgKo0ICAAANAIANBxNCAgABqIANBuNCAgABqIgQ2AgAgBCADQbDQgIAAaiIFNgIAIANBvNCAgABqIAU2AgAgA0HM0ICAAGogA0HA0ICAAGoiBTYCACAFIAQ2AgAgA0HU0ICAAGogA0HI0ICAAGoiBDYCACAEIAU2AgAgA0HQ0ICAAGogBDYCACADQSBqIgNBgAJHDQALQYDUhIAAQXhBgNSEgABrQQ9xQQBBgNSEgABBCGpBD3EbIgNqIgRBBGogAkFIaiIFIANrIgNBAXI2AgBBAEEAKALw04CAADYCpNCAgABBACADNgKU0ICAAEEAIAQ2AqDQgIAAQYDUhIAAIAVqQTg2AgQLAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB7AFLDQACQEEAKAKI0ICAACIGQRAgAEETakFwcSAAQQtJGyICQQN2IgR2IgNBA3FFDQACQAJAIANBAXEgBHJBAXMiBUEDdCIEQbDQgIAAaiIDIARBuNCAgABqKAIAIgQoAggiAkcNAEEAIAZBfiAFd3E2AojQgIAADAELIAMgAjYCCCACIAM2AgwLIARBCGohAyAEIAVBA3QiBUEDcjYCBCAEIAVqIgQgBCgCBEEBcjYCBAwMCyACQQAoApDQgIAAIgdNDQECQCADRQ0AAkACQCADIAR0QQIgBHQiA0EAIANrcnEiA0EAIANrcUF/aiIDIANBDHZBEHEiA3YiBEEFdkEIcSIFIANyIAQgBXYiA0ECdkEEcSIEciADIAR2IgNBAXZBAnEiBHIgAyAEdiIDQQF2QQFxIgRyIAMgBHZqIgRBA3QiA0Gw0ICAAGoiBSADQbjQgIAAaigCACIDKAIIIgBHDQBBACAGQX4gBHdxIgY2AojQgIAADAELIAUgADYCCCAAIAU2AgwLIAMgAkEDcjYCBCADIARBA3QiBGogBCACayIFNgIAIAMgAmoiACAFQQFyNgIEAkAgB0UNACAHQXhxQbDQgIAAaiECQQAoApzQgIAAIQQCQAJAIAZBASAHQQN2dCIIcQ0AQQAgBiAIcjYCiNCAgAAgAiEIDAELIAIoAgghCAsgCCAENgIMIAIgBDYCCCAEIAI2AgwgBCAINgIICyADQQhqIQNBACAANgKc0ICAAEEAIAU2ApDQgIAADAwLQQAoAozQgIAAIglFDQEgCUEAIAlrcUF/aiIDIANBDHZBEHEiA3YiBEEFdkEIcSIFIANyIAQgBXYiA0ECdkEEcSIEciADIAR2IgNBAXZBAnEiBHIgAyAEdiIDQQF2QQFxIgRyIAMgBHZqQQJ0QbjSgIAAaigCACIAKAIEQXhxIAJrIQQgACEFAkADQAJAIAUoAhAiAw0AIAVBFGooAgAiA0UNAgsgAygCBEF4cSACayIFIAQgBSAESSIFGyEEIAMgACAFGyEAIAMhBQwACwsgACgCGCEKAkAgACgCDCIIIABGDQAgACgCCCIDQQAoApjQgIAASRogCCADNgIIIAMgCDYCDAwLCwJAIABBFGoiBSgCACIDDQAgACgCECIDRQ0DIABBEGohBQsDQCAFIQsgAyIIQRRqIgUoAgAiAw0AIAhBEGohBSAIKAIQIgMNAAsgC0EANgIADAoLQX8hAiAAQb9/Sw0AIABBE2oiA0FwcSECQQAoAozQgIAAIgdFDQBBACELAkAgAkGAAkkNAEEfIQsgAkH///8HSw0AIANBCHYiAyADQYD+P2pBEHZBCHEiA3QiBCAEQYDgH2pBEHZBBHEiBHQiBSAFQYCAD2pBEHZBAnEiBXRBD3YgAyAEciAFcmsiA0EBdCACIANBFWp2QQFxckEcaiELC0EAIAJrIQQCQAJAAkACQCALQQJ0QbjSgIAAaigCACIFDQBBACEDQQAhCAwBC0EAIQMgAkEAQRkgC0EBdmsgC0EfRht0IQBBACEIA0ACQCAFKAIEQXhxIAJrIgYgBE8NACAGIQQgBSEIIAYNAEEAIQQgBSEIIAUhAwwDCyADIAVBFGooAgAiBiAGIAUgAEEddkEEcWpBEGooAgAiBUYbIAMgBhshAyAAQQF0IQAgBQ0ACwsCQCADIAhyDQBBACEIQQIgC3QiA0EAIANrciAHcSIDRQ0DIANBACADa3FBf2oiAyADQQx2QRBxIgN2IgVBBXZBCHEiACADciAFIAB2IgNBAnZBBHEiBXIgAyAFdiIDQQF2QQJxIgVyIAMgBXYiA0EBdkEBcSIFciADIAV2akECdEG40oCAAGooAgAhAwsgA0UNAQsDQCADKAIEQXhxIAJrIgYgBEkhAAJAIAMoAhAiBQ0AIANBFGooAgAhBQsgBiAEIAAbIQQgAyAIIAAbIQggBSEDIAUNAAsLIAhFDQAgBEEAKAKQ0ICAACACa08NACAIKAIYIQsCQCAIKAIMIgAgCEYNACAIKAIIIgNBACgCmNCAgABJGiAAIAM2AgggAyAANgIMDAkLAkAgCEEUaiIFKAIAIgMNACAIKAIQIgNFDQMgCEEQaiEFCwNAIAUhBiADIgBBFGoiBSgCACIDDQAgAEEQaiEFIAAoAhAiAw0ACyAGQQA2AgAMCAsCQEEAKAKQ0ICAACIDIAJJDQBBACgCnNCAgAAhBAJAAkAgAyACayIFQRBJDQAgBCACaiIAIAVBAXI2AgRBACAFNgKQ0ICAAEEAIAA2ApzQgIAAIAQgA2ogBTYCACAEIAJBA3I2AgQMAQsgBCADQQNyNgIEIAQgA2oiAyADKAIEQQFyNgIEQQBBADYCnNCAgABBAEEANgKQ0ICAAAsgBEEIaiEDDAoLAkBBACgClNCAgAAiACACTQ0AQQAoAqDQgIAAIgMgAmoiBCAAIAJrIgVBAXI2AgRBACAFNgKU0ICAAEEAIAQ2AqDQgIAAIAMgAkEDcjYCBCADQQhqIQMMCgsCQAJAQQAoAuDTgIAARQ0AQQAoAujTgIAAIQQMAQtBAEJ/NwLs04CAAEEAQoCAhICAgMAANwLk04CAAEEAIAFBDGpBcHFB2KrVqgVzNgLg04CAAEEAQQA2AvTTgIAAQQBBADYCxNOAgABBgIAEIQQLQQAhAwJAIAQgAkHHAGoiB2oiBkEAIARrIgtxIgggAksNAEEAQTA2AvjTgIAADAoLAkBBACgCwNOAgAAiA0UNAAJAQQAoArjTgIAAIgQgCGoiBSAETQ0AIAUgA00NAQtBACEDQQBBMDYC+NOAgAAMCgtBAC0AxNOAgABBBHENBAJAAkACQEEAKAKg0ICAACIERQ0AQcjTgIAAIQMDQAJAIAMoAgAiBSAESw0AIAUgAygCBGogBEsNAwsgAygCCCIDDQALC0EAEMuAgIAAIgBBf0YNBSAIIQYCQEEAKALk04CAACIDQX9qIgQgAHFFDQAgCCAAayAEIABqQQAgA2txaiEGCyAGIAJNDQUgBkH+////B0sNBQJAQQAoAsDTgIAAIgNFDQBBACgCuNOAgAAiBCAGaiIFIARNDQYgBSADSw0GCyAGEMuAgIAAIgMgAEcNAQwHCyAGIABrIAtxIgZB/v///wdLDQQgBhDLgICAACIAIAMoAgAgAygCBGpGDQMgACEDCwJAIANBf0YNACACQcgAaiAGTQ0AAkAgByAGa0EAKALo04CAACIEakEAIARrcSIEQf7///8HTQ0AIAMhAAwHCwJAIAQQy4CAgABBf0YNACAEIAZqIQYgAyEADAcLQQAgBmsQy4CAgAAaDAQLIAMhACADQX9HDQUMAwtBACEIDAcLQQAhAAwFCyAAQX9HDQILQQBBACgCxNOAgABBBHI2AsTTgIAACyAIQf7///8HSw0BIAgQy4CAgAAhAEEAEMuAgIAAIQMgAEF/Rg0BIANBf0YNASAAIANPDQEgAyAAayIGIAJBOGpNDQELQQBBACgCuNOAgAAgBmoiAzYCuNOAgAACQCADQQAoArzTgIAATQ0AQQAgAzYCvNOAgAALAkACQAJAAkBBACgCoNCAgAAiBEUNAEHI04CAACEDA0AgACADKAIAIgUgAygCBCIIakYNAiADKAIIIgMNAAwDCwsCQAJAQQAoApjQgIAAIgNFDQAgACADTw0BC0EAIAA2ApjQgIAAC0EAIQNBACAGNgLM04CAAEEAIAA2AsjTgIAAQQBBfzYCqNCAgABBAEEAKALg04CAADYCrNCAgABBAEEANgLU04CAAANAIANBxNCAgABqIANBuNCAgABqIgQ2AgAgBCADQbDQgIAAaiIFNgIAIANBvNCAgABqIAU2AgAgA0HM0ICAAGogA0HA0ICAAGoiBTYCACAFIAQ2AgAgA0HU0ICAAGogA0HI0ICAAGoiBDYCACAEIAU2AgAgA0HQ0ICAAGogBDYCACADQSBqIgNBgAJHDQALIABBeCAAa0EPcUEAIABBCGpBD3EbIgNqIgQgBkFIaiIFIANrIgNBAXI2AgRBAEEAKALw04CAADYCpNCAgABBACADNgKU0ICAAEEAIAQ2AqDQgIAAIAAgBWpBODYCBAwCCyADLQAMQQhxDQAgBCAFSQ0AIAQgAE8NACAEQXggBGtBD3FBACAEQQhqQQ9xGyIFaiIAQQAoApTQgIAAIAZqIgsgBWsiBUEBcjYCBCADIAggBmo2AgRBAEEAKALw04CAADYCpNCAgABBACAFNgKU0ICAAEEAIAA2AqDQgIAAIAQgC2pBODYCBAwBCwJAIABBACgCmNCAgAAiCE8NAEEAIAA2ApjQgIAAIAAhCAsgACAGaiEFQcjTgIAAIQMCQAJAAkACQAJAAkACQANAIAMoAgAgBUYNASADKAIIIgMNAAwCCwsgAy0ADEEIcUUNAQtByNOAgAAhAwNAAkAgAygCACIFIARLDQAgBSADKAIEaiIFIARLDQMLIAMoAgghAwwACwsgAyAANgIAIAMgAygCBCAGajYCBCAAQXggAGtBD3FBACAAQQhqQQ9xG2oiCyACQQNyNgIEIAVBeCAFa0EPcUEAIAVBCGpBD3EbaiIGIAsgAmoiAmshAwJAIAYgBEcNAEEAIAI2AqDQgIAAQQBBACgClNCAgAAgA2oiAzYClNCAgAAgAiADQQFyNgIEDAMLAkAgBkEAKAKc0ICAAEcNAEEAIAI2ApzQgIAAQQBBACgCkNCAgAAgA2oiAzYCkNCAgAAgAiADQQFyNgIEIAIgA2ogAzYCAAwDCwJAIAYoAgQiBEEDcUEBRw0AIARBeHEhBwJAAkAgBEH/AUsNACAGKAIIIgUgBEEDdiIIQQN0QbDQgIAAaiIARhoCQCAGKAIMIgQgBUcNAEEAQQAoAojQgIAAQX4gCHdxNgKI0ICAAAwCCyAEIABGGiAEIAU2AgggBSAENgIMDAELIAYoAhghCQJAAkAgBigCDCIAIAZGDQAgBigCCCIEIAhJGiAAIAQ2AgggBCAANgIMDAELAkAgBkEUaiIEKAIAIgUNACAGQRBqIgQoAgAiBQ0AQQAhAAwBCwNAIAQhCCAFIgBBFGoiBCgCACIFDQAgAEEQaiEEIAAoAhAiBQ0ACyAIQQA2AgALIAlFDQACQAJAIAYgBigCHCIFQQJ0QbjSgIAAaiIEKAIARw0AIAQgADYCACAADQFBAEEAKAKM0ICAAEF+IAV3cTYCjNCAgAAMAgsgCUEQQRQgCSgCECAGRhtqIAA2AgAgAEUNAQsgACAJNgIYAkAgBigCECIERQ0AIAAgBDYCECAEIAA2AhgLIAYoAhQiBEUNACAAQRRqIAQ2AgAgBCAANgIYCyAHIANqIQMgBiAHaiIGKAIEIQQLIAYgBEF+cTYCBCACIANqIAM2AgAgAiADQQFyNgIEAkAgA0H/AUsNACADQXhxQbDQgIAAaiEEAkACQEEAKAKI0ICAACIFQQEgA0EDdnQiA3ENAEEAIAUgA3I2AojQgIAAIAQhAwwBCyAEKAIIIQMLIAMgAjYCDCAEIAI2AgggAiAENgIMIAIgAzYCCAwDC0EfIQQCQCADQf///wdLDQAgA0EIdiIEIARBgP4/akEQdkEIcSIEdCIFIAVBgOAfakEQdkEEcSIFdCIAIABBgIAPakEQdkECcSIAdEEPdiAEIAVyIAByayIEQQF0IAMgBEEVanZBAXFyQRxqIQQLIAIgBDYCHCACQgA3AhAgBEECdEG40oCAAGohBQJAQQAoAozQgIAAIgBBASAEdCIIcQ0AIAUgAjYCAEEAIAAgCHI2AozQgIAAIAIgBTYCGCACIAI2AgggAiACNgIMDAMLIANBAEEZIARBAXZrIARBH0YbdCEEIAUoAgAhAANAIAAiBSgCBEF4cSADRg0CIARBHXYhACAEQQF0IQQgBSAAQQRxakEQaiIIKAIAIgANAAsgCCACNgIAIAIgBTYCGCACIAI2AgwgAiACNgIIDAILIABBeCAAa0EPcUEAIABBCGpBD3EbIgNqIgsgBkFIaiIIIANrIgNBAXI2AgQgACAIakE4NgIEIAQgBUE3IAVrQQ9xQQAgBUFJakEPcRtqQUFqIgggCCAEQRBqSRsiCEEjNgIEQQBBACgC8NOAgAA2AqTQgIAAQQAgAzYClNCAgABBACALNgKg0ICAACAIQRBqQQApAtDTgIAANwIAIAhBACkCyNOAgAA3AghBACAIQQhqNgLQ04CAAEEAIAY2AszTgIAAQQAgADYCyNOAgABBAEEANgLU04CAACAIQSRqIQMDQCADQQc2AgAgA0EEaiIDIAVJDQALIAggBEYNAyAIIAgoAgRBfnE2AgQgCCAIIARrIgA2AgAgBCAAQQFyNgIEAkAgAEH/AUsNACAAQXhxQbDQgIAAaiEDAkACQEEAKAKI0ICAACIFQQEgAEEDdnQiAHENAEEAIAUgAHI2AojQgIAAIAMhBQwBCyADKAIIIQULIAUgBDYCDCADIAQ2AgggBCADNgIMIAQgBTYCCAwEC0EfIQMCQCAAQf///wdLDQAgAEEIdiIDIANBgP4/akEQdkEIcSIDdCIFIAVBgOAfakEQdkEEcSIFdCIIIAhBgIAPakEQdkECcSIIdEEPdiADIAVyIAhyayIDQQF0IAAgA0EVanZBAXFyQRxqIQMLIAQgAzYCHCAEQgA3AhAgA0ECdEG40oCAAGohBQJAQQAoAozQgIAAIghBASADdCIGcQ0AIAUgBDYCAEEAIAggBnI2AozQgIAAIAQgBTYCGCAEIAQ2AgggBCAENgIMDAQLIABBAEEZIANBAXZrIANBH0YbdCEDIAUoAgAhCANAIAgiBSgCBEF4cSAARg0DIANBHXYhCCADQQF0IQMgBSAIQQRxakEQaiIGKAIAIggNAAsgBiAENgIAIAQgBTYCGCAEIAQ2AgwgBCAENgIIDAMLIAUoAggiAyACNgIMIAUgAjYCCCACQQA2AhggAiAFNgIMIAIgAzYCCAsgC0EIaiEDDAULIAUoAggiAyAENgIMIAUgBDYCCCAEQQA2AhggBCAFNgIMIAQgAzYCCAtBACgClNCAgAAiAyACTQ0AQQAoAqDQgIAAIgQgAmoiBSADIAJrIgNBAXI2AgRBACADNgKU0ICAAEEAIAU2AqDQgIAAIAQgAkEDcjYCBCAEQQhqIQMMAwtBACEDQQBBMDYC+NOAgAAMAgsCQCALRQ0AAkACQCAIIAgoAhwiBUECdEG40oCAAGoiAygCAEcNACADIAA2AgAgAA0BQQAgB0F+IAV3cSIHNgKM0ICAAAwCCyALQRBBFCALKAIQIAhGG2ogADYCACAARQ0BCyAAIAs2AhgCQCAIKAIQIgNFDQAgACADNgIQIAMgADYCGAsgCEEUaigCACIDRQ0AIABBFGogAzYCACADIAA2AhgLAkACQCAEQQ9LDQAgCCAEIAJqIgNBA3I2AgQgCCADaiIDIAMoAgRBAXI2AgQMAQsgCCACaiIAIARBAXI2AgQgCCACQQNyNgIEIAAgBGogBDYCAAJAIARB/wFLDQAgBEF4cUGw0ICAAGohAwJAAkBBACgCiNCAgAAiBUEBIARBA3Z0IgRxDQBBACAFIARyNgKI0ICAACADIQQMAQsgAygCCCEECyAEIAA2AgwgAyAANgIIIAAgAzYCDCAAIAQ2AggMAQtBHyEDAkAgBEH///8HSw0AIARBCHYiAyADQYD+P2pBEHZBCHEiA3QiBSAFQYDgH2pBEHZBBHEiBXQiAiACQYCAD2pBEHZBAnEiAnRBD3YgAyAFciACcmsiA0EBdCAEIANBFWp2QQFxckEcaiEDCyAAIAM2AhwgAEIANwIQIANBAnRBuNKAgABqIQUCQCAHQQEgA3QiAnENACAFIAA2AgBBACAHIAJyNgKM0ICAACAAIAU2AhggACAANgIIIAAgADYCDAwBCyAEQQBBGSADQQF2ayADQR9GG3QhAyAFKAIAIQICQANAIAIiBSgCBEF4cSAERg0BIANBHXYhAiADQQF0IQMgBSACQQRxakEQaiIGKAIAIgINAAsgBiAANgIAIAAgBTYCGCAAIAA2AgwgACAANgIIDAELIAUoAggiAyAANgIMIAUgADYCCCAAQQA2AhggACAFNgIMIAAgAzYCCAsgCEEIaiEDDAELAkAgCkUNAAJAAkAgACAAKAIcIgVBAnRBuNKAgABqIgMoAgBHDQAgAyAINgIAIAgNAUEAIAlBfiAFd3E2AozQgIAADAILIApBEEEUIAooAhAgAEYbaiAINgIAIAhFDQELIAggCjYCGAJAIAAoAhAiA0UNACAIIAM2AhAgAyAINgIYCyAAQRRqKAIAIgNFDQAgCEEUaiADNgIAIAMgCDYCGAsCQAJAIARBD0sNACAAIAQgAmoiA0EDcjYCBCAAIANqIgMgAygCBEEBcjYCBAwBCyAAIAJqIgUgBEEBcjYCBCAAIAJBA3I2AgQgBSAEaiAENgIAAkAgB0UNACAHQXhxQbDQgIAAaiECQQAoApzQgIAAIQMCQAJAQQEgB0EDdnQiCCAGcQ0AQQAgCCAGcjYCiNCAgAAgAiEIDAELIAIoAgghCAsgCCADNgIMIAIgAzYCCCADIAI2AgwgAyAINgIIC0EAIAU2ApzQgIAAQQAgBDYCkNCAgAALIABBCGohAwsgAUEQaiSAgICAACADCwoAIAAQyYCAgAAL4g0BB38CQCAARQ0AIABBeGoiASAAQXxqKAIAIgJBeHEiAGohAwJAIAJBAXENACACQQNxRQ0BIAEgASgCACICayIBQQAoApjQgIAAIgRJDQEgAiAAaiEAAkAgAUEAKAKc0ICAAEYNAAJAIAJB/wFLDQAgASgCCCIEIAJBA3YiBUEDdEGw0ICAAGoiBkYaAkAgASgCDCICIARHDQBBAEEAKAKI0ICAAEF+IAV3cTYCiNCAgAAMAwsgAiAGRhogAiAENgIIIAQgAjYCDAwCCyABKAIYIQcCQAJAIAEoAgwiBiABRg0AIAEoAggiAiAESRogBiACNgIIIAIgBjYCDAwBCwJAIAFBFGoiAigCACIEDQAgAUEQaiICKAIAIgQNAEEAIQYMAQsDQCACIQUgBCIGQRRqIgIoAgAiBA0AIAZBEGohAiAGKAIQIgQNAAsgBUEANgIACyAHRQ0BAkACQCABIAEoAhwiBEECdEG40oCAAGoiAigCAEcNACACIAY2AgAgBg0BQQBBACgCjNCAgABBfiAEd3E2AozQgIAADAMLIAdBEEEUIAcoAhAgAUYbaiAGNgIAIAZFDQILIAYgBzYCGAJAIAEoAhAiAkUNACAGIAI2AhAgAiAGNgIYCyABKAIUIgJFDQEgBkEUaiACNgIAIAIgBjYCGAwBCyADKAIEIgJBA3FBA0cNACADIAJBfnE2AgRBACAANgKQ0ICAACABIABqIAA2AgAgASAAQQFyNgIEDwsgASADTw0AIAMoAgQiAkEBcUUNAAJAAkAgAkECcQ0AAkAgA0EAKAKg0ICAAEcNAEEAIAE2AqDQgIAAQQBBACgClNCAgAAgAGoiADYClNCAgAAgASAAQQFyNgIEIAFBACgCnNCAgABHDQNBAEEANgKQ0ICAAEEAQQA2ApzQgIAADwsCQCADQQAoApzQgIAARw0AQQAgATYCnNCAgABBAEEAKAKQ0ICAACAAaiIANgKQ0ICAACABIABBAXI2AgQgASAAaiAANgIADwsgAkF4cSAAaiEAAkACQCACQf8BSw0AIAMoAggiBCACQQN2IgVBA3RBsNCAgABqIgZGGgJAIAMoAgwiAiAERw0AQQBBACgCiNCAgABBfiAFd3E2AojQgIAADAILIAIgBkYaIAIgBDYCCCAEIAI2AgwMAQsgAygCGCEHAkACQCADKAIMIgYgA0YNACADKAIIIgJBACgCmNCAgABJGiAGIAI2AgggAiAGNgIMDAELAkAgA0EUaiICKAIAIgQNACADQRBqIgIoAgAiBA0AQQAhBgwBCwNAIAIhBSAEIgZBFGoiAigCACIEDQAgBkEQaiECIAYoAhAiBA0ACyAFQQA2AgALIAdFDQACQAJAIAMgAygCHCIEQQJ0QbjSgIAAaiICKAIARw0AIAIgBjYCACAGDQFBAEEAKAKM0ICAAEF+IAR3cTYCjNCAgAAMAgsgB0EQQRQgBygCECADRhtqIAY2AgAgBkUNAQsgBiAHNgIYAkAgAygCECICRQ0AIAYgAjYCECACIAY2AhgLIAMoAhQiAkUNACAGQRRqIAI2AgAgAiAGNgIYCyABIABqIAA2AgAgASAAQQFyNgIEIAFBACgCnNCAgABHDQFBACAANgKQ0ICAAA8LIAMgAkF+cTYCBCABIABqIAA2AgAgASAAQQFyNgIECwJAIABB/wFLDQAgAEF4cUGw0ICAAGohAgJAAkBBACgCiNCAgAAiBEEBIABBA3Z0IgBxDQBBACAEIAByNgKI0ICAACACIQAMAQsgAigCCCEACyAAIAE2AgwgAiABNgIIIAEgAjYCDCABIAA2AggPC0EfIQICQCAAQf///wdLDQAgAEEIdiICIAJBgP4/akEQdkEIcSICdCIEIARBgOAfakEQdkEEcSIEdCIGIAZBgIAPakEQdkECcSIGdEEPdiACIARyIAZyayICQQF0IAAgAkEVanZBAXFyQRxqIQILIAEgAjYCHCABQgA3AhAgAkECdEG40oCAAGohBAJAAkBBACgCjNCAgAAiBkEBIAJ0IgNxDQAgBCABNgIAQQAgBiADcjYCjNCAgAAgASAENgIYIAEgATYCCCABIAE2AgwMAQsgAEEAQRkgAkEBdmsgAkEfRht0IQIgBCgCACEGAkADQCAGIgQoAgRBeHEgAEYNASACQR12IQYgAkEBdCECIAQgBkEEcWpBEGoiAygCACIGDQALIAMgATYCACABIAQ2AhggASABNgIMIAEgATYCCAwBCyAEKAIIIgAgATYCDCAEIAE2AgggAUEANgIYIAEgBDYCDCABIAA2AggLQQBBACgCqNCAgABBf2oiAUF/IAEbNgKo0ICAAAsLBAAAAAtOAAJAIAANAD8AQRB0DwsCQCAAQf//A3ENACAAQX9MDQACQCAAQRB2QAAiAEF/Rw0AQQBBMDYC+NOAgABBfw8LIABBEHQPCxDKgICAAAAL8gICA38BfgJAIAJFDQAgACABOgAAIAIgAGoiA0F/aiABOgAAIAJBA0kNACAAIAE6AAIgACABOgABIANBfWogAToAACADQX5qIAE6AAAgAkEHSQ0AIAAgAToAAyADQXxqIAE6AAAgAkEJSQ0AIABBACAAa0EDcSIEaiIDIAFB/wFxQYGChAhsIgE2AgAgAyACIARrQXxxIgRqIgJBfGogATYCACAEQQlJDQAgAyABNgIIIAMgATYCBCACQXhqIAE2AgAgAkF0aiABNgIAIARBGUkNACADIAE2AhggAyABNgIUIAMgATYCECADIAE2AgwgAkFwaiABNgIAIAJBbGogATYCACACQWhqIAE2AgAgAkFkaiABNgIAIAQgA0EEcUEYciIFayICQSBJDQAgAa1CgYCAgBB+IQYgAyAFaiEBA0AgASAGNwMYIAEgBjcDECABIAY3AwggASAGNwMAIAFBIGohASACQWBqIgJBH0sNAAsLIAALC45IAQBBgAgLhkgBAAAAAgAAAAMAAAAAAAAAAAAAAAQAAAAFAAAAAAAAAAAAAAAGAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEludmFsaWQgY2hhciBpbiB1cmwgcXVlcnkAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9ib2R5AENvbnRlbnQtTGVuZ3RoIG92ZXJmbG93AENodW5rIHNpemUgb3ZlcmZsb3cAUmVzcG9uc2Ugb3ZlcmZsb3cASW52YWxpZCBtZXRob2QgZm9yIEhUVFAveC54IHJlcXVlc3QASW52YWxpZCBtZXRob2QgZm9yIFJUU1AveC54IHJlcXVlc3QARXhwZWN0ZWQgU09VUkNFIG1ldGhvZCBmb3IgSUNFL3gueCByZXF1ZXN0AEludmFsaWQgY2hhciBpbiB1cmwgZnJhZ21lbnQgc3RhcnQARXhwZWN0ZWQgZG90AFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fc3RhdHVzAEludmFsaWQgcmVzcG9uc2Ugc3RhdHVzAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMAVXNlciBjYWxsYmFjayBlcnJvcgBgb25fcmVzZXRgIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19oZWFkZXJgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2JlZ2luYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlYCBjYWxsYmFjayBlcnJvcgBgb25fc3RhdHVzX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fdmVyc2lvbl9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3VybF9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25faGVhZGVyX3ZhbHVlX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fbWVzc2FnZV9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX21ldGhvZF9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX2hlYWRlcl9maWVsZF9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lYCBjYWxsYmFjayBlcnJvcgBVbmV4cGVjdGVkIGNoYXIgaW4gdXJsIHNlcnZlcgBJbnZhbGlkIGhlYWRlciB2YWx1ZSBjaGFyAEludmFsaWQgaGVhZGVyIGZpZWxkIGNoYXIAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl92ZXJzaW9uAEludmFsaWQgbWlub3IgdmVyc2lvbgBJbnZhbGlkIG1ham9yIHZlcnNpb24ARXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgdmVyc2lvbgBFeHBlY3RlZCBDUkxGIGFmdGVyIHZlcnNpb24ASW52YWxpZCBIVFRQIHZlcnNpb24ASW52YWxpZCBoZWFkZXIgdG9rZW4AU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl91cmwASW52YWxpZCBjaGFyYWN0ZXJzIGluIHVybABVbmV4cGVjdGVkIHN0YXJ0IGNoYXIgaW4gdXJsAERvdWJsZSBAIGluIHVybABFbXB0eSBDb250ZW50LUxlbmd0aABJbnZhbGlkIGNoYXJhY3RlciBpbiBDb250ZW50LUxlbmd0aABEdXBsaWNhdGUgQ29udGVudC1MZW5ndGgASW52YWxpZCBjaGFyIGluIHVybCBwYXRoAENvbnRlbnQtTGVuZ3RoIGNhbid0IGJlIHByZXNlbnQgd2l0aCBUcmFuc2Zlci1FbmNvZGluZwBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBzaXplAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25faGVhZGVyX3ZhbHVlAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgdmFsdWUATWlzc2luZyBleHBlY3RlZCBMRiBhZnRlciBoZWFkZXIgdmFsdWUASW52YWxpZCBgVHJhbnNmZXItRW5jb2RpbmdgIGhlYWRlciB2YWx1ZQBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIHF1b3RlIHZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGVkIHZhbHVlAFBhdXNlZCBieSBvbl9oZWFkZXJzX2NvbXBsZXRlAEludmFsaWQgRU9GIHN0YXRlAG9uX3Jlc2V0IHBhdXNlAG9uX2NodW5rX2hlYWRlciBwYXVzZQBvbl9tZXNzYWdlX2JlZ2luIHBhdXNlAG9uX2NodW5rX2V4dGVuc2lvbl92YWx1ZSBwYXVzZQBvbl9zdGF0dXNfY29tcGxldGUgcGF1c2UAb25fdmVyc2lvbl9jb21wbGV0ZSBwYXVzZQBvbl91cmxfY29tcGxldGUgcGF1c2UAb25fY2h1bmtfY29tcGxldGUgcGF1c2UAb25faGVhZGVyX3ZhbHVlX2NvbXBsZXRlIHBhdXNlAG9uX21lc3NhZ2VfY29tcGxldGUgcGF1c2UAb25fbWV0aG9kX2NvbXBsZXRlIHBhdXNlAG9uX2hlYWRlcl9maWVsZF9jb21wbGV0ZSBwYXVzZQBvbl9jaHVua19leHRlbnNpb25fbmFtZSBwYXVzZQBVbmV4cGVjdGVkIHNwYWNlIGFmdGVyIHN0YXJ0IGxpbmUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9jaHVua19leHRlbnNpb25fbmFtZQBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIG5hbWUAUGF1c2Ugb24gQ09OTkVDVC9VcGdyYWRlAFBhdXNlIG9uIFBSSS9VcGdyYWRlAEV4cGVjdGVkIEhUVFAvMiBDb25uZWN0aW9uIFByZWZhY2UAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9tZXRob2QARXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgbWV0aG9kAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25faGVhZGVyX2ZpZWxkAFBhdXNlZABJbnZhbGlkIHdvcmQgZW5jb3VudGVyZWQASW52YWxpZCBtZXRob2QgZW5jb3VudGVyZWQAVW5leHBlY3RlZCBjaGFyIGluIHVybCBzY2hlbWEAUmVxdWVzdCBoYXMgaW52YWxpZCBgVHJhbnNmZXItRW5jb2RpbmdgAFNXSVRDSF9QUk9YWQBVU0VfUFJPWFkATUtBQ1RJVklUWQBVTlBST0NFU1NBQkxFX0VOVElUWQBDT1BZAE1PVkVEX1BFUk1BTkVOVExZAFRPT19FQVJMWQBOT1RJRlkARkFJTEVEX0RFUEVOREVOQ1kAQkFEX0dBVEVXQVkAUExBWQBQVVQAQ0hFQ0tPVVQAR0FURVdBWV9USU1FT1VUAFJFUVVFU1RfVElNRU9VVABORVRXT1JLX0NPTk5FQ1RfVElNRU9VVABDT05ORUNUSU9OX1RJTUVPVVQATE9HSU5fVElNRU9VVABORVRXT1JLX1JFQURfVElNRU9VVABQT1NUAE1JU0RJUkVDVEVEX1JFUVVFU1QAQ0xJRU5UX0NMT1NFRF9SRVFVRVNUAENMSUVOVF9DTE9TRURfTE9BRF9CQUxBTkNFRF9SRVFVRVNUAEJBRF9SRVFVRVNUAEhUVFBfUkVRVUVTVF9TRU5UX1RPX0hUVFBTX1BPUlQAUkVQT1JUAElNX0FfVEVBUE9UAFJFU0VUX0NPTlRFTlQATk9fQ09OVEVOVABQQVJUSUFMX0NPTlRFTlQASFBFX0lOVkFMSURfQ09OU1RBTlQASFBFX0NCX1JFU0VUAEdFVABIUEVfU1RSSUNUAENPTkZMSUNUAFRFTVBPUkFSWV9SRURJUkVDVABQRVJNQU5FTlRfUkVESVJFQ1QAQ09OTkVDVABNVUxUSV9TVEFUVVMASFBFX0lOVkFMSURfU1RBVFVTAFRPT19NQU5ZX1JFUVVFU1RTAEVBUkxZX0hJTlRTAFVOQVZBSUxBQkxFX0ZPUl9MRUdBTF9SRUFTT05TAE9QVElPTlMAU1dJVENISU5HX1BST1RPQ09MUwBWQVJJQU5UX0FMU09fTkVHT1RJQVRFUwBNVUxUSVBMRV9DSE9JQ0VTAElOVEVSTkFMX1NFUlZFUl9FUlJPUgBXRUJfU0VSVkVSX1VOS05PV05fRVJST1IAUkFJTEdVTl9FUlJPUgBJREVOVElUWV9QUk9WSURFUl9BVVRIRU5USUNBVElPTl9FUlJPUgBTU0xfQ0VSVElGSUNBVEVfRVJST1IASU5WQUxJRF9YX0ZPUldBUkRFRF9GT1IAU0VUX1BBUkFNRVRFUgBHRVRfUEFSQU1FVEVSAEhQRV9VU0VSAFNFRV9PVEhFUgBIUEVfQ0JfQ0hVTktfSEVBREVSAE1LQ0FMRU5EQVIAU0VUVVAAV0VCX1NFUlZFUl9JU19ET1dOAFRFQVJET1dOAEhQRV9DTE9TRURfQ09OTkVDVElPTgBIRVVSSVNUSUNfRVhQSVJBVElPTgBESVNDT05ORUNURURfT1BFUkFUSU9OAE5PTl9BVVRIT1JJVEFUSVZFX0lORk9STUFUSU9OAEhQRV9JTlZBTElEX1ZFUlNJT04ASFBFX0NCX01FU1NBR0VfQkVHSU4AU0lURV9JU19GUk9aRU4ASFBFX0lOVkFMSURfSEVBREVSX1RPS0VOAElOVkFMSURfVE9LRU4ARk9SQklEREVOAEVOSEFOQ0VfWU9VUl9DQUxNAEhQRV9JTlZBTElEX1VSTABCTE9DS0VEX0JZX1BBUkVOVEFMX0NPTlRST0wATUtDT0wAQUNMAEhQRV9JTlRFUk5BTABSRVFVRVNUX0hFQURFUl9GSUVMRFNfVE9PX0xBUkdFX1VOT0ZGSUNJQUwASFBFX09LAFVOTElOSwBVTkxPQ0sAUFJJAFJFVFJZX1dJVEgASFBFX0lOVkFMSURfQ09OVEVOVF9MRU5HVEgASFBFX1VORVhQRUNURURfQ09OVEVOVF9MRU5HVEgARkxVU0gAUFJPUFBBVENIAE0tU0VBUkNIAFVSSV9UT09fTE9ORwBQUk9DRVNTSU5HAE1JU0NFTExBTkVPVVNfUEVSU0lTVEVOVF9XQVJOSU5HAE1JU0NFTExBTkVPVVNfV0FSTklORwBIUEVfSU5WQUxJRF9UUkFOU0ZFUl9FTkNPRElORwBFeHBlY3RlZCBDUkxGAEhQRV9JTlZBTElEX0NIVU5LX1NJWkUATU9WRQBDT05USU5VRQBIUEVfQ0JfU1RBVFVTX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJTX0NPTVBMRVRFAEhQRV9DQl9WRVJTSU9OX0NPTVBMRVRFAEhQRV9DQl9VUkxfQ09NUExFVEUASFBFX0NCX0NIVU5LX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJfVkFMVUVfQ09NUExFVEUASFBFX0NCX0NIVU5LX0VYVEVOU0lPTl9WQUxVRV9DT01QTEVURQBIUEVfQ0JfQ0hVTktfRVhURU5TSU9OX05BTUVfQ09NUExFVEUASFBFX0NCX01FU1NBR0VfQ09NUExFVEUASFBFX0NCX01FVEhPRF9DT01QTEVURQBIUEVfQ0JfSEVBREVSX0ZJRUxEX0NPTVBMRVRFAERFTEVURQBIUEVfSU5WQUxJRF9FT0ZfU1RBVEUASU5WQUxJRF9TU0xfQ0VSVElGSUNBVEUAUEFVU0UATk9fUkVTUE9OU0UAVU5TVVBQT1JURURfTUVESUFfVFlQRQBHT05FAE5PVF9BQ0NFUFRBQkxFAFNFUlZJQ0VfVU5BVkFJTEFCTEUAUkFOR0VfTk9UX1NBVElTRklBQkxFAE9SSUdJTl9JU19VTlJFQUNIQUJMRQBSRVNQT05TRV9JU19TVEFMRQBQVVJHRQBNRVJHRQBSRVFVRVNUX0hFQURFUl9GSUVMRFNfVE9PX0xBUkdFAFJFUVVFU1RfSEVBREVSX1RPT19MQVJHRQBQQVlMT0FEX1RPT19MQVJHRQBJTlNVRkZJQ0lFTlRfU1RPUkFHRQBIUEVfUEFVU0VEX1VQR1JBREUASFBFX1BBVVNFRF9IMl9VUEdSQURFAFNPVVJDRQBBTk5PVU5DRQBUUkFDRQBIUEVfVU5FWFBFQ1RFRF9TUEFDRQBERVNDUklCRQBVTlNVQlNDUklCRQBSRUNPUkQASFBFX0lOVkFMSURfTUVUSE9EAE5PVF9GT1VORABQUk9QRklORABVTkJJTkQAUkVCSU5EAFVOQVVUSE9SSVpFRABNRVRIT0RfTk9UX0FMTE9XRUQASFRUUF9WRVJTSU9OX05PVF9TVVBQT1JURUQAQUxSRUFEWV9SRVBPUlRFRABBQ0NFUFRFRABOT1RfSU1QTEVNRU5URUQATE9PUF9ERVRFQ1RFRABIUEVfQ1JfRVhQRUNURUQASFBFX0xGX0VYUEVDVEVEAENSRUFURUQASU1fVVNFRABIUEVfUEFVU0VEAFRJTUVPVVRfT0NDVVJFRABQQVlNRU5UX1JFUVVJUkVEAFBSRUNPTkRJVElPTl9SRVFVSVJFRABQUk9YWV9BVVRIRU5USUNBVElPTl9SRVFVSVJFRABORVRXT1JLX0FVVEhFTlRJQ0FUSU9OX1JFUVVJUkVEAExFTkdUSF9SRVFVSVJFRABTU0xfQ0VSVElGSUNBVEVfUkVRVUlSRUQAVVBHUkFERV9SRVFVSVJFRABQQUdFX0VYUElSRUQAUFJFQ09ORElUSU9OX0ZBSUxFRABFWFBFQ1RBVElPTl9GQUlMRUQAUkVWQUxJREFUSU9OX0ZBSUxFRABTU0xfSEFORFNIQUtFX0ZBSUxFRABMT0NLRUQAVFJBTlNGT1JNQVRJT05fQVBQTElFRABOT1RfTU9ESUZJRUQATk9UX0VYVEVOREVEAEJBTkRXSURUSF9MSU1JVF9FWENFRURFRABTSVRFX0lTX09WRVJMT0FERUQASEVBRABFeHBlY3RlZCBIVFRQLwAAXhMAACYTAAAwEAAA8BcAAJ0TAAAVEgAAORcAAPASAAAKEAAAdRIAAK0SAACCEwAATxQAAH8QAACgFQAAIxQAAIkSAACLFAAATRUAANQRAADPFAAAEBgAAMkWAADcFgAAwREAAOAXAAC7FAAAdBQAAHwVAADlFAAACBcAAB8QAABlFQAAoxQAACgVAAACFQAAmRUAACwQAACLGQAATw8AANQOAABqEAAAzhAAAAIXAACJDgAAbhMAABwTAABmFAAAVhcAAMETAADNEwAAbBMAAGgXAABmFwAAXxcAACITAADODwAAaQ4AANgOAABjFgAAyxMAAKoOAAAoFwAAJhcAAMUTAABdFgAA6BEAAGcTAABlEwAA8hYAAHMTAAAdFwAA+RYAAPMRAADPDgAAzhUAAAwSAACzEQAApREAAGEQAAAyFwAAuxMAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIDAgICAgIAAAICAAICAAICAgICAgICAgIABAAAAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgACAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAICAgICAAACAgACAgACAgICAgICAgICAAMABAAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAAgACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG9zZWVlcC1hbGl2ZQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAQEBAQIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBY2h1bmtlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAQEBAQEAAAEBAAEBAAEBAQEBAQEBAQEAAAAAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlY3Rpb25lbnQtbGVuZ3Rob25yb3h5LWNvbm5lY3Rpb24AAAAAAAAAAAAAAAAAAAByYW5zZmVyLWVuY29kaW5ncGdyYWRlDQoNCg0KU00NCg0KVFRQL0NFL1RTUC8AAAAAAAAAAAAAAAABAgABAwAAAAAAAAAAAAAAAAAAAAAAAAQBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAQIAAQMAAAAAAAAAAAAAAAAAAAAAAAAEAQEFAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAEAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAQAAAgAAAAAAAAAAAAAAAAAAAAAAAAMEAAAEBAQEBAQEBAQEBAUEBAQEBAQEBAQEBAQABAAGBwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAEAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAABAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAIAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOT1VOQ0VFQ0tPVVRORUNURVRFQ1JJQkVMVVNIRVRFQURTRUFSQ0hSR0VDVElWSVRZTEVOREFSVkVPVElGWVBUSU9OU0NIU0VBWVNUQVRDSEdFT1JESVJFQ1RPUlRSQ0hQQVJBTUVURVJVUkNFQlNDUklCRUFSRE9XTkFDRUlORE5LQ0tVQlNDUklCRUhUVFAvQURUUC8=' - - -/***/ }), - -/***/ 3434: -/***/ ((module) => { - -module.exports = 'AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGADf39/AGABfwBgAn9/AGAGf39/f39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQACA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAA0ZFAwMEAAAFAAAAAAAABQEFAAUFBQAABgAAAAAGBgYGAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAAABAQcAAAUFAwABBAUBcAESEgUDAQACBggBfwFBgNQECwfRBSIGbWVtb3J5AgALX2luaXRpYWxpemUACRlfX2luZGlyZWN0X2Z1bmN0aW9uX3RhYmxlAQALbGxodHRwX2luaXQAChhsbGh0dHBfc2hvdWxkX2tlZXBfYWxpdmUAQQxsbGh0dHBfYWxsb2MADAZtYWxsb2MARgtsbGh0dHBfZnJlZQANBGZyZWUASA9sbGh0dHBfZ2V0X3R5cGUADhVsbGh0dHBfZ2V0X2h0dHBfbWFqb3IADxVsbGh0dHBfZ2V0X2h0dHBfbWlub3IAEBFsbGh0dHBfZ2V0X21ldGhvZAARFmxsaHR0cF9nZXRfc3RhdHVzX2NvZGUAEhJsbGh0dHBfZ2V0X3VwZ3JhZGUAEwxsbGh0dHBfcmVzZXQAFA5sbGh0dHBfZXhlY3V0ZQAVFGxsaHR0cF9zZXR0aW5nc19pbml0ABYNbGxodHRwX2ZpbmlzaAAXDGxsaHR0cF9wYXVzZQAYDWxsaHR0cF9yZXN1bWUAGRtsbGh0dHBfcmVzdW1lX2FmdGVyX3VwZ3JhZGUAGhBsbGh0dHBfZ2V0X2Vycm5vABsXbGxodHRwX2dldF9lcnJvcl9yZWFzb24AHBdsbGh0dHBfc2V0X2Vycm9yX3JlYXNvbgAdFGxsaHR0cF9nZXRfZXJyb3JfcG9zAB4RbGxodHRwX2Vycm5vX25hbWUAHxJsbGh0dHBfbWV0aG9kX25hbWUAIBJsbGh0dHBfc3RhdHVzX25hbWUAIRpsbGh0dHBfc2V0X2xlbmllbnRfaGVhZGVycwAiIWxsaHR0cF9zZXRfbGVuaWVudF9jaHVua2VkX2xlbmd0aAAjHWxsaHR0cF9zZXRfbGVuaWVudF9rZWVwX2FsaXZlACQkbGxodHRwX3NldF9sZW5pZW50X3RyYW5zZmVyX2VuY29kaW5nACUYbGxodHRwX21lc3NhZ2VfbmVlZHNfZW9mAD8JFwEAQQELEQECAwQFCwYHNTk3MS8tJyspCrLgAkUCAAsIABCIgICAAAsZACAAEMKAgIAAGiAAIAI2AjggACABOgAoCxwAIAAgAC8BMiAALQAuIAAQwYCAgAAQgICAgAALKgEBf0HAABDGgICAACIBEMKAgIAAGiABQYCIgIAANgI4IAEgADoAKCABCwoAIAAQyICAgAALBwAgAC0AKAsHACAALQAqCwcAIAAtACsLBwAgAC0AKQsHACAALwEyCwcAIAAtAC4LRQEEfyAAKAIYIQEgAC0ALSECIAAtACghAyAAKAI4IQQgABDCgICAABogACAENgI4IAAgAzoAKCAAIAI6AC0gACABNgIYCxEAIAAgASABIAJqEMOAgIAACxAAIABBAEHcABDMgICAABoLZwEBf0EAIQECQCAAKAIMDQACQAJAAkACQCAALQAvDgMBAAMCCyAAKAI4IgFFDQAgASgCLCIBRQ0AIAAgARGAgICAAAAiAQ0DC0EADwsQyoCAgAAACyAAQcOWgIAANgIQQQ4hAQsgAQseAAJAIAAoAgwNACAAQdGbgIAANgIQIABBFTYCDAsLFgACQCAAKAIMQRVHDQAgAEEANgIMCwsWAAJAIAAoAgxBFkcNACAAQQA2AgwLCwcAIAAoAgwLBwAgACgCEAsJACAAIAE2AhALBwAgACgCFAsiAAJAIABBJEkNABDKgICAAAALIABBAnRBoLOAgABqKAIACyIAAkAgAEEuSQ0AEMqAgIAAAAsgAEECdEGwtICAAGooAgAL7gsBAX9B66iAgAAhAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABBnH9qDvQDY2IAAWFhYWFhYQIDBAVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhBgcICQoLDA0OD2FhYWFhEGFhYWFhYWFhYWFhEWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRITFBUWFxgZGhthYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2YTc4OTphYWFhYWFhYTthYWE8YWFhYT0+P2FhYWFhYWFhQGFhQWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYUJDREVGR0hJSktMTU5PUFFSU2FhYWFhYWFhVFVWV1hZWlthXF1hYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFeYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhX2BhC0Hhp4CAAA8LQaShgIAADwtBy6yAgAAPC0H+sYCAAA8LQcCkgIAADwtBq6SAgAAPC0GNqICAAA8LQeKmgIAADwtBgLCAgAAPC0G5r4CAAA8LQdekgIAADwtB75+AgAAPC0Hhn4CAAA8LQfqfgIAADwtB8qCAgAAPC0Gor4CAAA8LQa6ygIAADwtBiLCAgAAPC0Hsp4CAAA8LQYKigIAADwtBjp2AgAAPC0HQroCAAA8LQcqjgIAADwtBxbKAgAAPC0HfnICAAA8LQdKcgIAADwtBxKCAgAAPC0HXoICAAA8LQaKfgIAADwtB7a6AgAAPC0GrsICAAA8LQdSlgIAADwtBzK6AgAAPC0H6roCAAA8LQfyrgIAADwtB0rCAgAAPC0HxnYCAAA8LQbuggIAADwtB96uAgAAPC0GQsYCAAA8LQdexgIAADwtBoq2AgAAPC0HUp4CAAA8LQeCrgIAADwtBn6yAgAAPC0HrsYCAAA8LQdWfgIAADwtByrGAgAAPC0HepYCAAA8LQdSegIAADwtB9JyAgAAPC0GnsoCAAA8LQbGdgIAADwtBoJ2AgAAPC0G5sYCAAA8LQbywgIAADwtBkqGAgAAPC0GzpoCAAA8LQemsgIAADwtBrJ6AgAAPC0HUq4CAAA8LQfemgIAADwtBgKaAgAAPC0GwoYCAAA8LQf6egIAADwtBjaOAgAAPC0GJrYCAAA8LQfeigIAADwtBoLGAgAAPC0Gun4CAAA8LQcalgIAADwtB6J6AgAAPC0GTooCAAA8LQcKvgIAADwtBw52AgAAPC0GLrICAAA8LQeGdgIAADwtBja+AgAAPC0HqoYCAAA8LQbStgIAADwtB0q+AgAAPC0HfsoCAAA8LQdKygIAADwtB8LCAgAAPC0GpooCAAA8LQfmjgIAADwtBmZ6AgAAPC0G1rICAAA8LQZuwgIAADwtBkrKAgAAPC0G2q4CAAA8LQcKigIAADwtB+LKAgAAPC0GepYCAAA8LQdCigIAADwtBup6AgAAPC0GBnoCAAA8LEMqAgIAAAAtB1qGAgAAhAQsgAQsWACAAIAAtAC1B/gFxIAFBAEdyOgAtCxkAIAAgAC0ALUH9AXEgAUEAR0EBdHI6AC0LGQAgACAALQAtQfsBcSABQQBHQQJ0cjoALQsZACAAIAAtAC1B9wFxIAFBAEdBA3RyOgAtCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAgAiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCBCIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQcaRgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIwIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAggiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2ioCAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCNCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIMIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZqAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAjgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCECIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZWQgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAI8IgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAhQiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEGqm4CAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCQCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIYIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZOAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCJCIERQ0AIAAgBBGAgICAAAAhAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIsIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAigiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2iICAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCUCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIcIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABBwpmAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCICIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZSUgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAJMIgRFDQAgACAEEYCAgIAAACEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAlQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCWCIERQ0AIAAgBBGAgICAAAAhAwsgAwtFAQF/AkACQCAALwEwQRRxQRRHDQBBASEDIAAtAChBAUYNASAALwEyQeUARiEDDAELIAAtAClBBUYhAwsgACADOgAuQQAL/gEBA39BASEDAkAgAC8BMCIEQQhxDQAgACkDIEIAUiEDCwJAAkAgAC0ALkUNAEEBIQUgAC0AKUEFRg0BQQEhBSAEQcAAcUUgA3FBAUcNAQtBACEFIARBwABxDQBBAiEFIARB//8DcSIDQQhxDQACQCADQYAEcUUNAAJAIAAtAChBAUcNACAALQAtQQpxDQBBBQ8LQQQPCwJAIANBIHENAAJAIAAtAChBAUYNACAALwEyQf//A3EiAEGcf2pB5ABJDQAgAEHMAUYNACAAQbACRg0AQQQhBSAEQShxRQ0CIANBiARxQYAERg0CC0EADwtBAEEDIAApAyBQGyEFCyAFC2IBAn9BACEBAkAgAC0AKEEBRg0AIAAvATJB//8DcSICQZx/akHkAEkNACACQcwBRg0AIAJBsAJGDQAgAC8BMCIAQcAAcQ0AQQEhASAAQYgEcUGABEYNACAAQShxRSEBCyABC6cBAQN/AkACQAJAIAAtACpFDQAgAC0AK0UNAEEAIQMgAC8BMCIEQQJxRQ0BDAILQQAhAyAALwEwIgRBAXFFDQELQQEhAyAALQAoQQFGDQAgAC8BMkH//wNxIgVBnH9qQeQASQ0AIAVBzAFGDQAgBUGwAkYNACAEQcAAcQ0AQQAhAyAEQYgEcUGABEYNACAEQShxQQBHIQMLIABBADsBMCAAQQA6AC8gAwuZAQECfwJAAkACQCAALQAqRQ0AIAAtACtFDQBBACEBIAAvATAiAkECcUUNAQwCC0EAIQEgAC8BMCICQQFxRQ0BC0EBIQEgAC0AKEEBRg0AIAAvATJB//8DcSIAQZx/akHkAEkNACAAQcwBRg0AIABBsAJGDQAgAkHAAHENAEEAIQEgAkGIBHFBgARGDQAgAkEocUEARyEBCyABC0kBAXsgAEEQav0MAAAAAAAAAAAAAAAAAAAAACIB/QsDACAAIAH9CwMAIABBMGogAf0LAwAgAEEgaiAB/QsDACAAQd0BNgIcQQALewEBfwJAIAAoAgwiAw0AAkAgACgCBEUNACAAIAE2AgQLAkAgACABIAIQxICAgAAiAw0AIAAoAgwPCyAAIAM2AhxBACEDIAAoAgQiAUUNACAAIAEgAiAAKAIIEYGAgIAAACIBRQ0AIAAgAjYCFCAAIAE2AgwgASEDCyADC+TzAQMOfwN+BH8jgICAgABBEGsiAySAgICAACABIQQgASEFIAEhBiABIQcgASEIIAEhCSABIQogASELIAEhDCABIQ0gASEOIAEhDwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIcIhBBf2oO3QHaAQHZAQIDBAUGBwgJCgsMDQ7YAQ8Q1wEREtYBExQVFhcYGRob4AHfARwdHtUBHyAhIiMkJdQBJicoKSorLNMB0gEtLtEB0AEvMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUbbAUdISUrPAc4BS80BTMwBTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gAGBAYIBgwGEAYUBhgGHAYgBiQGKAYsBjAGNAY4BjwGQAZEBkgGTAZQBlQGWAZcBmAGZAZoBmwGcAZ0BngGfAaABoQGiAaMBpAGlAaYBpwGoAakBqgGrAawBrQGuAa8BsAGxAbIBswG0AbUBtgG3AcsBygG4AckBuQHIAboBuwG8Ab0BvgG/AcABwQHCAcMBxAHFAcYBANwBC0EAIRAMxgELQQ4hEAzFAQtBDSEQDMQBC0EPIRAMwwELQRAhEAzCAQtBEyEQDMEBC0EUIRAMwAELQRUhEAy/AQtBFiEQDL4BC0EXIRAMvQELQRghEAy8AQtBGSEQDLsBC0EaIRAMugELQRshEAy5AQtBHCEQDLgBC0EIIRAMtwELQR0hEAy2AQtBICEQDLUBC0EfIRAMtAELQQchEAyzAQtBISEQDLIBC0EiIRAMsQELQR4hEAywAQtBIyEQDK8BC0ESIRAMrgELQREhEAytAQtBJCEQDKwBC0ElIRAMqwELQSYhEAyqAQtBJyEQDKkBC0HDASEQDKgBC0EpIRAMpwELQSshEAymAQtBLCEQDKUBC0EtIRAMpAELQS4hEAyjAQtBLyEQDKIBC0HEASEQDKEBC0EwIRAMoAELQTQhEAyfAQtBDCEQDJ4BC0ExIRAMnQELQTIhEAycAQtBMyEQDJsBC0E5IRAMmgELQTUhEAyZAQtBxQEhEAyYAQtBCyEQDJcBC0E6IRAMlgELQTYhEAyVAQtBCiEQDJQBC0E3IRAMkwELQTghEAySAQtBPCEQDJEBC0E7IRAMkAELQT0hEAyPAQtBCSEQDI4BC0EoIRAMjQELQT4hEAyMAQtBPyEQDIsBC0HAACEQDIoBC0HBACEQDIkBC0HCACEQDIgBC0HDACEQDIcBC0HEACEQDIYBC0HFACEQDIUBC0HGACEQDIQBC0EqIRAMgwELQccAIRAMggELQcgAIRAMgQELQckAIRAMgAELQcoAIRAMfwtBywAhEAx+C0HNACEQDH0LQcwAIRAMfAtBzgAhEAx7C0HPACEQDHoLQdAAIRAMeQtB0QAhEAx4C0HSACEQDHcLQdMAIRAMdgtB1AAhEAx1C0HWACEQDHQLQdUAIRAMcwtBBiEQDHILQdcAIRAMcQtBBSEQDHALQdgAIRAMbwtBBCEQDG4LQdkAIRAMbQtB2gAhEAxsC0HbACEQDGsLQdwAIRAMagtBAyEQDGkLQd0AIRAMaAtB3gAhEAxnC0HfACEQDGYLQeEAIRAMZQtB4AAhEAxkC0HiACEQDGMLQeMAIRAMYgtBAiEQDGELQeQAIRAMYAtB5QAhEAxfC0HmACEQDF4LQecAIRAMXQtB6AAhEAxcC0HpACEQDFsLQeoAIRAMWgtB6wAhEAxZC0HsACEQDFgLQe0AIRAMVwtB7gAhEAxWC0HvACEQDFULQfAAIRAMVAtB8QAhEAxTC0HyACEQDFILQfMAIRAMUQtB9AAhEAxQC0H1ACEQDE8LQfYAIRAMTgtB9wAhEAxNC0H4ACEQDEwLQfkAIRAMSwtB+gAhEAxKC0H7ACEQDEkLQfwAIRAMSAtB/QAhEAxHC0H+ACEQDEYLQf8AIRAMRQtBgAEhEAxEC0GBASEQDEMLQYIBIRAMQgtBgwEhEAxBC0GEASEQDEALQYUBIRAMPwtBhgEhEAw+C0GHASEQDD0LQYgBIRAMPAtBiQEhEAw7C0GKASEQDDoLQYsBIRAMOQtBjAEhEAw4C0GNASEQDDcLQY4BIRAMNgtBjwEhEAw1C0GQASEQDDQLQZEBIRAMMwtBkgEhEAwyC0GTASEQDDELQZQBIRAMMAtBlQEhEAwvC0GWASEQDC4LQZcBIRAMLQtBmAEhEAwsC0GZASEQDCsLQZoBIRAMKgtBmwEhEAwpC0GcASEQDCgLQZ0BIRAMJwtBngEhEAwmC0GfASEQDCULQaABIRAMJAtBoQEhEAwjC0GiASEQDCILQaMBIRAMIQtBpAEhEAwgC0GlASEQDB8LQaYBIRAMHgtBpwEhEAwdC0GoASEQDBwLQakBIRAMGwtBqgEhEAwaC0GrASEQDBkLQawBIRAMGAtBrQEhEAwXC0GuASEQDBYLQQEhEAwVC0GvASEQDBQLQbABIRAMEwtBsQEhEAwSC0GzASEQDBELQbIBIRAMEAtBtAEhEAwPC0G1ASEQDA4LQbYBIRAMDQtBtwEhEAwMC0G4ASEQDAsLQbkBIRAMCgtBugEhEAwJC0G7ASEQDAgLQcYBIRAMBwtBvAEhEAwGC0G9ASEQDAULQb4BIRAMBAtBvwEhEAwDC0HAASEQDAILQcIBIRAMAQtBwQEhEAsDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBAOxwEAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB4fICEjJSg/QEFERUZHSElKS0xNT1BRUlPeA1dZW1xdYGJlZmdoaWprbG1vcHFyc3R1dnd4eXp7fH1+gAGCAYUBhgGHAYkBiwGMAY0BjgGPAZABkQGUAZUBlgGXAZgBmQGaAZsBnAGdAZ4BnwGgAaEBogGjAaQBpQGmAacBqAGpAaoBqwGsAa0BrgGvAbABsQGyAbMBtAG1AbYBtwG4AbkBugG7AbwBvQG+Ab8BwAHBAcIBwwHEAcUBxgHHAcgByQHKAcsBzAHNAc4BzwHQAdEB0gHTAdQB1QHWAdcB2AHZAdoB2wHcAd0B3gHgAeEB4gHjAeQB5QHmAecB6AHpAeoB6wHsAe0B7gHvAfAB8QHyAfMBmQKkArAC/gL+AgsgASIEIAJHDfMBQd0BIRAM/wMLIAEiECACRw3dAUHDASEQDP4DCyABIgEgAkcNkAFB9wAhEAz9AwsgASIBIAJHDYYBQe8AIRAM/AMLIAEiASACRw1/QeoAIRAM+wMLIAEiASACRw17QegAIRAM+gMLIAEiASACRw14QeYAIRAM+QMLIAEiASACRw0aQRghEAz4AwsgASIBIAJHDRRBEiEQDPcDCyABIgEgAkcNWUHFACEQDPYDCyABIgEgAkcNSkE/IRAM9QMLIAEiASACRw1IQTwhEAz0AwsgASIBIAJHDUFBMSEQDPMDCyAALQAuQQFGDesDDIcCCyAAIAEiASACEMCAgIAAQQFHDeYBIABCADcDIAznAQsgACABIgEgAhC0gICAACIQDecBIAEhAQz1AgsCQCABIgEgAkcNAEEGIRAM8AMLIAAgAUEBaiIBIAIQu4CAgAAiEA3oASABIQEMMQsgAEIANwMgQRIhEAzVAwsgASIQIAJHDStBHSEQDO0DCwJAIAEiASACRg0AIAFBAWohAUEQIRAM1AMLQQchEAzsAwsgAEIAIAApAyAiESACIAEiEGutIhJ9IhMgEyARVhs3AyAgESASViIURQ3lAUEIIRAM6wMLAkAgASIBIAJGDQAgAEGJgICAADYCCCAAIAE2AgQgASEBQRQhEAzSAwtBCSEQDOoDCyABIQEgACkDIFAN5AEgASEBDPICCwJAIAEiASACRw0AQQshEAzpAwsgACABQQFqIgEgAhC2gICAACIQDeUBIAEhAQzyAgsgACABIgEgAhC4gICAACIQDeUBIAEhAQzyAgsgACABIgEgAhC4gICAACIQDeYBIAEhAQwNCyAAIAEiASACELqAgIAAIhAN5wEgASEBDPACCwJAIAEiASACRw0AQQ8hEAzlAwsgAS0AACIQQTtGDQggEEENRw3oASABQQFqIQEM7wILIAAgASIBIAIQuoCAgAAiEA3oASABIQEM8gILA0ACQCABLQAAQfC1gIAAai0AACIQQQFGDQAgEEECRw3rASAAKAIEIRAgAEEANgIEIAAgECABQQFqIgEQuYCAgAAiEA3qASABIQEM9AILIAFBAWoiASACRw0AC0ESIRAM4gMLIAAgASIBIAIQuoCAgAAiEA3pASABIQEMCgsgASIBIAJHDQZBGyEQDOADCwJAIAEiASACRw0AQRYhEAzgAwsgAEGKgICAADYCCCAAIAE2AgQgACABIAIQuICAgAAiEA3qASABIQFBICEQDMYDCwJAIAEiASACRg0AA0ACQCABLQAAQfC3gIAAai0AACIQQQJGDQACQCAQQX9qDgTlAewBAOsB7AELIAFBAWohAUEIIRAMyAMLIAFBAWoiASACRw0AC0EVIRAM3wMLQRUhEAzeAwsDQAJAIAEtAABB8LmAgABqLQAAIhBBAkYNACAQQX9qDgTeAewB4AHrAewBCyABQQFqIgEgAkcNAAtBGCEQDN0DCwJAIAEiASACRg0AIABBi4CAgAA2AgggACABNgIEIAEhAUEHIRAMxAMLQRkhEAzcAwsgAUEBaiEBDAILAkAgASIUIAJHDQBBGiEQDNsDCyAUIQECQCAULQAAQXNqDhTdAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAgDuAgtBACEQIABBADYCHCAAQa+LgIAANgIQIABBAjYCDCAAIBRBAWo2AhQM2gMLAkAgAS0AACIQQTtGDQAgEEENRw3oASABQQFqIQEM5QILIAFBAWohAQtBIiEQDL8DCwJAIAEiECACRw0AQRwhEAzYAwtCACERIBAhASAQLQAAQVBqDjfnAeYBAQIDBAUGBwgAAAAAAAAACQoLDA0OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPEBESExQAC0EeIRAMvQMLQgIhEQzlAQtCAyERDOQBC0IEIREM4wELQgUhEQziAQtCBiERDOEBC0IHIREM4AELQgghEQzfAQtCCSERDN4BC0IKIREM3QELQgshEQzcAQtCDCERDNsBC0INIREM2gELQg4hEQzZAQtCDyERDNgBC0IKIREM1wELQgshEQzWAQtCDCERDNUBC0INIREM1AELQg4hEQzTAQtCDyERDNIBC0IAIRECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBAtAABBUGoON+UB5AEAAQIDBAUGB+YB5gHmAeYB5gHmAeYBCAkKCwwN5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAQ4PEBESE+YBC0ICIREM5AELQgMhEQzjAQtCBCERDOIBC0IFIREM4QELQgYhEQzgAQtCByERDN8BC0IIIREM3gELQgkhEQzdAQtCCiERDNwBC0ILIREM2wELQgwhEQzaAQtCDSERDNkBC0IOIREM2AELQg8hEQzXAQtCCiERDNYBC0ILIREM1QELQgwhEQzUAQtCDSERDNMBC0IOIREM0gELQg8hEQzRAQsgAEIAIAApAyAiESACIAEiEGutIhJ9IhMgEyARVhs3AyAgESASViIURQ3SAUEfIRAMwAMLAkAgASIBIAJGDQAgAEGJgICAADYCCCAAIAE2AgQgASEBQSQhEAynAwtBICEQDL8DCyAAIAEiECACEL6AgIAAQX9qDgW2AQDFAgHRAdIBC0ERIRAMpAMLIABBAToALyAQIQEMuwMLIAEiASACRw3SAUEkIRAMuwMLIAEiDSACRw0eQcYAIRAMugMLIAAgASIBIAIQsoCAgAAiEA3UASABIQEMtQELIAEiECACRw0mQdAAIRAMuAMLAkAgASIBIAJHDQBBKCEQDLgDCyAAQQA2AgQgAEGMgICAADYCCCAAIAEgARCxgICAACIQDdMBIAEhAQzYAQsCQCABIhAgAkcNAEEpIRAMtwMLIBAtAAAiAUEgRg0UIAFBCUcN0wEgEEEBaiEBDBULAkAgASIBIAJGDQAgAUEBaiEBDBcLQSohEAy1AwsCQCABIhAgAkcNAEErIRAMtQMLAkAgEC0AACIBQQlGDQAgAUEgRw3VAQsgAC0ALEEIRg3TASAQIQEMkQMLAkAgASIBIAJHDQBBLCEQDLQDCyABLQAAQQpHDdUBIAFBAWohAQzJAgsgASIOIAJHDdUBQS8hEAyyAwsDQAJAIAEtAAAiEEEgRg0AAkAgEEF2ag4EANwB3AEA2gELIAEhAQzgAQsgAUEBaiIBIAJHDQALQTEhEAyxAwtBMiEQIAEiFCACRg2wAyACIBRrIAAoAgAiAWohFSAUIAFrQQNqIRYCQANAIBQtAAAiF0EgciAXIBdBv39qQf8BcUEaSRtB/wFxIAFB8LuAgABqLQAARw0BAkAgAUEDRw0AQQYhAQyWAwsgAUEBaiEBIBRBAWoiFCACRw0ACyAAIBU2AgAMsQMLIABBADYCACAUIQEM2QELQTMhECABIhQgAkYNrwMgAiAUayAAKAIAIgFqIRUgFCABa0EIaiEWAkADQCAULQAAIhdBIHIgFyAXQb9/akH/AXFBGkkbQf8BcSABQfS7gIAAai0AAEcNAQJAIAFBCEcNAEEFIQEMlQMLIAFBAWohASAUQQFqIhQgAkcNAAsgACAVNgIADLADCyAAQQA2AgAgFCEBDNgBC0E0IRAgASIUIAJGDa4DIAIgFGsgACgCACIBaiEVIBQgAWtBBWohFgJAA0AgFC0AACIXQSByIBcgF0G/f2pB/wFxQRpJG0H/AXEgAUHQwoCAAGotAABHDQECQCABQQVHDQBBByEBDJQDCyABQQFqIQEgFEEBaiIUIAJHDQALIAAgFTYCAAyvAwsgAEEANgIAIBQhAQzXAQsCQCABIgEgAkYNAANAAkAgAS0AAEGAvoCAAGotAAAiEEEBRg0AIBBBAkYNCiABIQEM3QELIAFBAWoiASACRw0AC0EwIRAMrgMLQTAhEAytAwsCQCABIgEgAkYNAANAAkAgAS0AACIQQSBGDQAgEEF2ag4E2QHaAdoB2QHaAQsgAUEBaiIBIAJHDQALQTghEAytAwtBOCEQDKwDCwNAAkAgAS0AACIQQSBGDQAgEEEJRw0DCyABQQFqIgEgAkcNAAtBPCEQDKsDCwNAAkAgAS0AACIQQSBGDQACQAJAIBBBdmoOBNoBAQHaAQALIBBBLEYN2wELIAEhAQwECyABQQFqIgEgAkcNAAtBPyEQDKoDCyABIQEM2wELQcAAIRAgASIUIAJGDagDIAIgFGsgACgCACIBaiEWIBQgAWtBBmohFwJAA0AgFC0AAEEgciABQYDAgIAAai0AAEcNASABQQZGDY4DIAFBAWohASAUQQFqIhQgAkcNAAsgACAWNgIADKkDCyAAQQA2AgAgFCEBC0E2IRAMjgMLAkAgASIPIAJHDQBBwQAhEAynAwsgAEGMgICAADYCCCAAIA82AgQgDyEBIAAtACxBf2oOBM0B1QHXAdkBhwMLIAFBAWohAQzMAQsCQCABIgEgAkYNAANAAkAgAS0AACIQQSByIBAgEEG/f2pB/wFxQRpJG0H/AXEiEEEJRg0AIBBBIEYNAAJAAkACQAJAIBBBnX9qDhMAAwMDAwMDAwEDAwMDAwMDAwMCAwsgAUEBaiEBQTEhEAyRAwsgAUEBaiEBQTIhEAyQAwsgAUEBaiEBQTMhEAyPAwsgASEBDNABCyABQQFqIgEgAkcNAAtBNSEQDKUDC0E1IRAMpAMLAkAgASIBIAJGDQADQAJAIAEtAABBgLyAgABqLQAAQQFGDQAgASEBDNMBCyABQQFqIgEgAkcNAAtBPSEQDKQDC0E9IRAMowMLIAAgASIBIAIQsICAgAAiEA3WASABIQEMAQsgEEEBaiEBC0E8IRAMhwMLAkAgASIBIAJHDQBBwgAhEAygAwsCQANAAkAgAS0AAEF3ag4YAAL+Av4ChAP+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gIA/gILIAFBAWoiASACRw0AC0HCACEQDKADCyABQQFqIQEgAC0ALUEBcUUNvQEgASEBC0EsIRAMhQMLIAEiASACRw3TAUHEACEQDJ0DCwNAAkAgAS0AAEGQwICAAGotAABBAUYNACABIQEMtwILIAFBAWoiASACRw0AC0HFACEQDJwDCyANLQAAIhBBIEYNswEgEEE6Rw2BAyAAKAIEIQEgAEEANgIEIAAgASANEK+AgIAAIgEN0AEgDUEBaiEBDLMCC0HHACEQIAEiDSACRg2aAyACIA1rIAAoAgAiAWohFiANIAFrQQVqIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQZDCgIAAai0AAEcNgAMgAUEFRg30AiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyaAwtByAAhECABIg0gAkYNmQMgAiANayAAKAIAIgFqIRYgDSABa0EJaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUGWwoCAAGotAABHDf8CAkAgAUEJRw0AQQIhAQz1AgsgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMmQMLAkAgASINIAJHDQBByQAhEAyZAwsCQAJAIA0tAAAiAUEgciABIAFBv39qQf8BcUEaSRtB/wFxQZJ/ag4HAIADgAOAA4ADgAMBgAMLIA1BAWohAUE+IRAMgAMLIA1BAWohAUE/IRAM/wILQcoAIRAgASINIAJGDZcDIAIgDWsgACgCACIBaiEWIA0gAWtBAWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFBoMKAgABqLQAARw39AiABQQFGDfACIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJcDC0HLACEQIAEiDSACRg2WAyACIA1rIAAoAgAiAWohFiANIAFrQQ5qIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQaLCgIAAai0AAEcN/AIgAUEORg3wAiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyWAwtBzAAhECABIg0gAkYNlQMgAiANayAAKAIAIgFqIRYgDSABa0EPaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUHAwoCAAGotAABHDfsCAkAgAUEPRw0AQQMhAQzxAgsgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMlQMLQc0AIRAgASINIAJGDZQDIAIgDWsgACgCACIBaiEWIA0gAWtBBWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFB0MKAgABqLQAARw36AgJAIAFBBUcNAEEEIQEM8AILIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJQDCwJAIAEiDSACRw0AQc4AIRAMlAMLAkACQAJAAkAgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJG0H/AXFBnX9qDhMA/QL9Av0C/QL9Av0C/QL9Av0C/QL9Av0CAf0C/QL9AgID/QILIA1BAWohAUHBACEQDP0CCyANQQFqIQFBwgAhEAz8AgsgDUEBaiEBQcMAIRAM+wILIA1BAWohAUHEACEQDPoCCwJAIAEiASACRg0AIABBjYCAgAA2AgggACABNgIEIAEhAUHFACEQDPoCC0HPACEQDJIDCyAQIQECQAJAIBAtAABBdmoOBAGoAqgCAKgCCyAQQQFqIQELQSchEAz4AgsCQCABIgEgAkcNAEHRACEQDJEDCwJAIAEtAABBIEYNACABIQEMjQELIAFBAWohASAALQAtQQFxRQ3HASABIQEMjAELIAEiFyACRw3IAUHSACEQDI8DC0HTACEQIAEiFCACRg2OAyACIBRrIAAoAgAiAWohFiAUIAFrQQFqIRcDQCAULQAAIAFB1sKAgABqLQAARw3MASABQQFGDccBIAFBAWohASAUQQFqIhQgAkcNAAsgACAWNgIADI4DCwJAIAEiASACRw0AQdUAIRAMjgMLIAEtAABBCkcNzAEgAUEBaiEBDMcBCwJAIAEiASACRw0AQdYAIRAMjQMLAkACQCABLQAAQXZqDgQAzQHNAQHNAQsgAUEBaiEBDMcBCyABQQFqIQFBygAhEAzzAgsgACABIgEgAhCugICAACIQDcsBIAEhAUHNACEQDPICCyAALQApQSJGDYUDDKYCCwJAIAEiASACRw0AQdsAIRAMigMLQQAhFEEBIRdBASEWQQAhEAJAAkACQAJAAkACQAJAAkACQCABLQAAQVBqDgrUAdMBAAECAwQFBgjVAQtBAiEQDAYLQQMhEAwFC0EEIRAMBAtBBSEQDAMLQQYhEAwCC0EHIRAMAQtBCCEQC0EAIRdBACEWQQAhFAzMAQtBCSEQQQEhFEEAIRdBACEWDMsBCwJAIAEiASACRw0AQd0AIRAMiQMLIAEtAABBLkcNzAEgAUEBaiEBDKYCCyABIgEgAkcNzAFB3wAhEAyHAwsCQCABIgEgAkYNACAAQY6AgIAANgIIIAAgATYCBCABIQFB0AAhEAzuAgtB4AAhEAyGAwtB4QAhECABIgEgAkYNhQMgAiABayAAKAIAIhRqIRYgASAUa0EDaiEXA0AgAS0AACAUQeLCgIAAai0AAEcNzQEgFEEDRg3MASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyFAwtB4gAhECABIgEgAkYNhAMgAiABayAAKAIAIhRqIRYgASAUa0ECaiEXA0AgAS0AACAUQebCgIAAai0AAEcNzAEgFEECRg3OASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyEAwtB4wAhECABIgEgAkYNgwMgAiABayAAKAIAIhRqIRYgASAUa0EDaiEXA0AgAS0AACAUQenCgIAAai0AAEcNywEgFEEDRg3OASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyDAwsCQCABIgEgAkcNAEHlACEQDIMDCyAAIAFBAWoiASACEKiAgIAAIhANzQEgASEBQdYAIRAM6QILAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgRg0AAkACQAJAIBBBuH9qDgsAAc8BzwHPAc8BzwHPAc8BzwECzwELIAFBAWohAUHSACEQDO0CCyABQQFqIQFB0wAhEAzsAgsgAUEBaiEBQdQAIRAM6wILIAFBAWoiASACRw0AC0HkACEQDIIDC0HkACEQDIEDCwNAAkAgAS0AAEHwwoCAAGotAAAiEEEBRg0AIBBBfmoOA88B0AHRAdIBCyABQQFqIgEgAkcNAAtB5gAhEAyAAwsCQCABIgEgAkYNACABQQFqIQEMAwtB5wAhEAz/AgsDQAJAIAEtAABB8MSAgABqLQAAIhBBAUYNAAJAIBBBfmoOBNIB0wHUAQDVAQsgASEBQdcAIRAM5wILIAFBAWoiASACRw0AC0HoACEQDP4CCwJAIAEiASACRw0AQekAIRAM/gILAkAgAS0AACIQQXZqDhq6AdUB1QG8AdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAcoB1QHVAQDTAQsgAUEBaiEBC0EGIRAM4wILA0ACQCABLQAAQfDGgIAAai0AAEEBRg0AIAEhAQyeAgsgAUEBaiIBIAJHDQALQeoAIRAM+wILAkAgASIBIAJGDQAgAUEBaiEBDAMLQesAIRAM+gILAkAgASIBIAJHDQBB7AAhEAz6AgsgAUEBaiEBDAELAkAgASIBIAJHDQBB7QAhEAz5AgsgAUEBaiEBC0EEIRAM3gILAkAgASIUIAJHDQBB7gAhEAz3AgsgFCEBAkACQAJAIBQtAABB8MiAgABqLQAAQX9qDgfUAdUB1gEAnAIBAtcBCyAUQQFqIQEMCgsgFEEBaiEBDM0BC0EAIRAgAEEANgIcIABBm5KAgAA2AhAgAEEHNgIMIAAgFEEBajYCFAz2AgsCQANAAkAgAS0AAEHwyICAAGotAAAiEEEERg0AAkACQCAQQX9qDgfSAdMB1AHZAQAEAdkBCyABIQFB2gAhEAzgAgsgAUEBaiEBQdwAIRAM3wILIAFBAWoiASACRw0AC0HvACEQDPYCCyABQQFqIQEMywELAkAgASIUIAJHDQBB8AAhEAz1AgsgFC0AAEEvRw3UASAUQQFqIQEMBgsCQCABIhQgAkcNAEHxACEQDPQCCwJAIBQtAAAiAUEvRw0AIBRBAWohAUHdACEQDNsCCyABQXZqIgRBFksN0wFBASAEdEGJgIACcUUN0wEMygILAkAgASIBIAJGDQAgAUEBaiEBQd4AIRAM2gILQfIAIRAM8gILAkAgASIUIAJHDQBB9AAhEAzyAgsgFCEBAkAgFC0AAEHwzICAAGotAABBf2oOA8kClAIA1AELQeEAIRAM2AILAkAgASIUIAJGDQADQAJAIBQtAABB8MqAgABqLQAAIgFBA0YNAAJAIAFBf2oOAssCANUBCyAUIQFB3wAhEAzaAgsgFEEBaiIUIAJHDQALQfMAIRAM8QILQfMAIRAM8AILAkAgASIBIAJGDQAgAEGPgICAADYCCCAAIAE2AgQgASEBQeAAIRAM1wILQfUAIRAM7wILAkAgASIBIAJHDQBB9gAhEAzvAgsgAEGPgICAADYCCCAAIAE2AgQgASEBC0EDIRAM1AILA0AgAS0AAEEgRw3DAiABQQFqIgEgAkcNAAtB9wAhEAzsAgsCQCABIgEgAkcNAEH4ACEQDOwCCyABLQAAQSBHDc4BIAFBAWohAQzvAQsgACABIgEgAhCsgICAACIQDc4BIAEhAQyOAgsCQCABIgQgAkcNAEH6ACEQDOoCCyAELQAAQcwARw3RASAEQQFqIQFBEyEQDM8BCwJAIAEiBCACRw0AQfsAIRAM6QILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEANAIAQtAAAgAUHwzoCAAGotAABHDdABIAFBBUYNzgEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBB+wAhEAzoAgsCQCABIgQgAkcNAEH8ACEQDOgCCwJAAkAgBC0AAEG9f2oODADRAdEB0QHRAdEB0QHRAdEB0QHRAQHRAQsgBEEBaiEBQeYAIRAMzwILIARBAWohAUHnACEQDM4CCwJAIAEiBCACRw0AQf0AIRAM5wILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNzwEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf0AIRAM5wILIABBADYCACAQQQFqIQFBECEQDMwBCwJAIAEiBCACRw0AQf4AIRAM5gILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQfbOgIAAai0AAEcNzgEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf4AIRAM5gILIABBADYCACAQQQFqIQFBFiEQDMsBCwJAIAEiBCACRw0AQf8AIRAM5QILIAIgBGsgACgCACIBaiEUIAQgAWtBA2ohEAJAA0AgBC0AACABQfzOgIAAai0AAEcNzQEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf8AIRAM5QILIABBADYCACAQQQFqIQFBBSEQDMoBCwJAIAEiBCACRw0AQYABIRAM5AILIAQtAABB2QBHDcsBIARBAWohAUEIIRAMyQELAkAgASIEIAJHDQBBgQEhEAzjAgsCQAJAIAQtAABBsn9qDgMAzAEBzAELIARBAWohAUHrACEQDMoCCyAEQQFqIQFB7AAhEAzJAgsCQCABIgQgAkcNAEGCASEQDOICCwJAAkAgBC0AAEG4f2oOCADLAcsBywHLAcsBywEBywELIARBAWohAUHqACEQDMkCCyAEQQFqIQFB7QAhEAzIAgsCQCABIgQgAkcNAEGDASEQDOECCyACIARrIAAoAgAiAWohECAEIAFrQQJqIRQCQANAIAQtAAAgAUGAz4CAAGotAABHDckBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgEDYCAEGDASEQDOECC0EAIRAgAEEANgIAIBRBAWohAQzGAQsCQCABIgQgAkcNAEGEASEQDOACCyACIARrIAAoAgAiAWohFCAEIAFrQQRqIRACQANAIAQtAAAgAUGDz4CAAGotAABHDcgBIAFBBEYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGEASEQDOACCyAAQQA2AgAgEEEBaiEBQSMhEAzFAQsCQCABIgQgAkcNAEGFASEQDN8CCwJAAkAgBC0AAEG0f2oOCADIAcgByAHIAcgByAEByAELIARBAWohAUHvACEQDMYCCyAEQQFqIQFB8AAhEAzFAgsCQCABIgQgAkcNAEGGASEQDN4CCyAELQAAQcUARw3FASAEQQFqIQEMgwILAkAgASIEIAJHDQBBhwEhEAzdAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFBiM+AgABqLQAARw3FASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBhwEhEAzdAgsgAEEANgIAIBBBAWohAUEtIRAMwgELAkAgASIEIAJHDQBBiAEhEAzcAgsgAiAEayAAKAIAIgFqIRQgBCABa0EIaiEQAkADQCAELQAAIAFB0M+AgABqLQAARw3EASABQQhGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBiAEhEAzcAgsgAEEANgIAIBBBAWohAUEpIRAMwQELAkAgASIBIAJHDQBBiQEhEAzbAgtBASEQIAEtAABB3wBHDcABIAFBAWohAQyBAgsCQCABIgQgAkcNAEGKASEQDNoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRADQCAELQAAIAFBjM+AgABqLQAARw3BASABQQFGDa8CIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYoBIRAM2QILAkAgASIEIAJHDQBBiwEhEAzZAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFBjs+AgABqLQAARw3BASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBiwEhEAzZAgsgAEEANgIAIBBBAWohAUECIRAMvgELAkAgASIEIAJHDQBBjAEhEAzYAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8M+AgABqLQAARw3AASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBjAEhEAzYAgsgAEEANgIAIBBBAWohAUEfIRAMvQELAkAgASIEIAJHDQBBjQEhEAzXAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8s+AgABqLQAARw2/ASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBjQEhEAzXAgsgAEEANgIAIBBBAWohAUEJIRAMvAELAkAgASIEIAJHDQBBjgEhEAzWAgsCQAJAIAQtAABBt39qDgcAvwG/Ab8BvwG/AQG/AQsgBEEBaiEBQfgAIRAMvQILIARBAWohAUH5ACEQDLwCCwJAIAEiBCACRw0AQY8BIRAM1QILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQZHPgIAAai0AAEcNvQEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQY8BIRAM1QILIABBADYCACAQQQFqIQFBGCEQDLoBCwJAIAEiBCACRw0AQZABIRAM1AILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQZfPgIAAai0AAEcNvAEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZABIRAM1AILIABBADYCACAQQQFqIQFBFyEQDLkBCwJAIAEiBCACRw0AQZEBIRAM0wILIAIgBGsgACgCACIBaiEUIAQgAWtBBmohEAJAA0AgBC0AACABQZrPgIAAai0AAEcNuwEgAUEGRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZEBIRAM0wILIABBADYCACAQQQFqIQFBFSEQDLgBCwJAIAEiBCACRw0AQZIBIRAM0gILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQaHPgIAAai0AAEcNugEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZIBIRAM0gILIABBADYCACAQQQFqIQFBHiEQDLcBCwJAIAEiBCACRw0AQZMBIRAM0QILIAQtAABBzABHDbgBIARBAWohAUEKIRAMtgELAkAgBCACRw0AQZQBIRAM0AILAkACQCAELQAAQb9/ag4PALkBuQG5AbkBuQG5AbkBuQG5AbkBuQG5AbkBAbkBCyAEQQFqIQFB/gAhEAy3AgsgBEEBaiEBQf8AIRAMtgILAkAgBCACRw0AQZUBIRAMzwILAkACQCAELQAAQb9/ag4DALgBAbgBCyAEQQFqIQFB/QAhEAy2AgsgBEEBaiEEQYABIRAMtQILAkAgBCACRw0AQZYBIRAMzgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQafPgIAAai0AAEcNtgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZYBIRAMzgILIABBADYCACAQQQFqIQFBCyEQDLMBCwJAIAQgAkcNAEGXASEQDM0CCwJAAkACQAJAIAQtAABBU2oOIwC4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBAbgBuAG4AbgBuAECuAG4AbgBA7gBCyAEQQFqIQFB+wAhEAy2AgsgBEEBaiEBQfwAIRAMtQILIARBAWohBEGBASEQDLQCCyAEQQFqIQRBggEhEAyzAgsCQCAEIAJHDQBBmAEhEAzMAgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBqc+AgABqLQAARw20ASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmAEhEAzMAgsgAEEANgIAIBBBAWohAUEZIRAMsQELAkAgBCACRw0AQZkBIRAMywILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQa7PgIAAai0AAEcNswEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZkBIRAMywILIABBADYCACAQQQFqIQFBBiEQDLABCwJAIAQgAkcNAEGaASEQDMoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUG0z4CAAGotAABHDbIBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGaASEQDMoCCyAAQQA2AgAgEEEBaiEBQRwhEAyvAQsCQCAEIAJHDQBBmwEhEAzJAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBts+AgABqLQAARw2xASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmwEhEAzJAgsgAEEANgIAIBBBAWohAUEnIRAMrgELAkAgBCACRw0AQZwBIRAMyAILAkACQCAELQAAQax/ag4CAAGxAQsgBEEBaiEEQYYBIRAMrwILIARBAWohBEGHASEQDK4CCwJAIAQgAkcNAEGdASEQDMcCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUG4z4CAAGotAABHDa8BIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGdASEQDMcCCyAAQQA2AgAgEEEBaiEBQSYhEAysAQsCQCAEIAJHDQBBngEhEAzGAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBus+AgABqLQAARw2uASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBngEhEAzGAgsgAEEANgIAIBBBAWohAUEDIRAMqwELAkAgBCACRw0AQZ8BIRAMxQILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNrQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZ8BIRAMxQILIABBADYCACAQQQFqIQFBDCEQDKoBCwJAIAQgAkcNAEGgASEQDMQCCyACIARrIAAoAgAiAWohFCAEIAFrQQNqIRACQANAIAQtAAAgAUG8z4CAAGotAABHDawBIAFBA0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGgASEQDMQCCyAAQQA2AgAgEEEBaiEBQQ0hEAypAQsCQCAEIAJHDQBBoQEhEAzDAgsCQAJAIAQtAABBun9qDgsArAGsAawBrAGsAawBrAGsAawBAawBCyAEQQFqIQRBiwEhEAyqAgsgBEEBaiEEQYwBIRAMqQILAkAgBCACRw0AQaIBIRAMwgILIAQtAABB0ABHDakBIARBAWohBAzpAQsCQCAEIAJHDQBBowEhEAzBAgsCQAJAIAQtAABBt39qDgcBqgGqAaoBqgGqAQCqAQsgBEEBaiEEQY4BIRAMqAILIARBAWohAUEiIRAMpgELAkAgBCACRw0AQaQBIRAMwAILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQcDPgIAAai0AAEcNqAEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQaQBIRAMwAILIABBADYCACAQQQFqIQFBHSEQDKUBCwJAIAQgAkcNAEGlASEQDL8CCwJAAkAgBC0AAEGuf2oOAwCoAQGoAQsgBEEBaiEEQZABIRAMpgILIARBAWohAUEEIRAMpAELAkAgBCACRw0AQaYBIRAMvgILAkACQAJAAkACQCAELQAAQb9/ag4VAKoBqgGqAaoBqgGqAaoBqgGqAaoBAaoBqgECqgGqAQOqAaoBBKoBCyAEQQFqIQRBiAEhEAyoAgsgBEEBaiEEQYkBIRAMpwILIARBAWohBEGKASEQDKYCCyAEQQFqIQRBjwEhEAylAgsgBEEBaiEEQZEBIRAMpAILAkAgBCACRw0AQacBIRAMvQILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNpQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQacBIRAMvQILIABBADYCACAQQQFqIQFBESEQDKIBCwJAIAQgAkcNAEGoASEQDLwCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHCz4CAAGotAABHDaQBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGoASEQDLwCCyAAQQA2AgAgEEEBaiEBQSwhEAyhAQsCQCAEIAJHDQBBqQEhEAy7AgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBxc+AgABqLQAARw2jASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBqQEhEAy7AgsgAEEANgIAIBBBAWohAUErIRAMoAELAkAgBCACRw0AQaoBIRAMugILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQcrPgIAAai0AAEcNogEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQaoBIRAMugILIABBADYCACAQQQFqIQFBFCEQDJ8BCwJAIAQgAkcNAEGrASEQDLkCCwJAAkACQAJAIAQtAABBvn9qDg8AAQKkAaQBpAGkAaQBpAGkAaQBpAGkAaQBA6QBCyAEQQFqIQRBkwEhEAyiAgsgBEEBaiEEQZQBIRAMoQILIARBAWohBEGVASEQDKACCyAEQQFqIQRBlgEhEAyfAgsCQCAEIAJHDQBBrAEhEAy4AgsgBC0AAEHFAEcNnwEgBEEBaiEEDOABCwJAIAQgAkcNAEGtASEQDLcCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHNz4CAAGotAABHDZ8BIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGtASEQDLcCCyAAQQA2AgAgEEEBaiEBQQ4hEAycAQsCQCAEIAJHDQBBrgEhEAy2AgsgBC0AAEHQAEcNnQEgBEEBaiEBQSUhEAybAQsCQCAEIAJHDQBBrwEhEAy1AgsgAiAEayAAKAIAIgFqIRQgBCABa0EIaiEQAkADQCAELQAAIAFB0M+AgABqLQAARw2dASABQQhGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBrwEhEAy1AgsgAEEANgIAIBBBAWohAUEqIRAMmgELAkAgBCACRw0AQbABIRAMtAILAkACQCAELQAAQat/ag4LAJ0BnQGdAZ0BnQGdAZ0BnQGdAQGdAQsgBEEBaiEEQZoBIRAMmwILIARBAWohBEGbASEQDJoCCwJAIAQgAkcNAEGxASEQDLMCCwJAAkAgBC0AAEG/f2oOFACcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAEBnAELIARBAWohBEGZASEQDJoCCyAEQQFqIQRBnAEhEAyZAgsCQCAEIAJHDQBBsgEhEAyyAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFB2c+AgABqLQAARw2aASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBsgEhEAyyAgsgAEEANgIAIBBBAWohAUEhIRAMlwELAkAgBCACRw0AQbMBIRAMsQILIAIgBGsgACgCACIBaiEUIAQgAWtBBmohEAJAA0AgBC0AACABQd3PgIAAai0AAEcNmQEgAUEGRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbMBIRAMsQILIABBADYCACAQQQFqIQFBGiEQDJYBCwJAIAQgAkcNAEG0ASEQDLACCwJAAkACQCAELQAAQbt/ag4RAJoBmgGaAZoBmgGaAZoBmgGaAQGaAZoBmgGaAZoBApoBCyAEQQFqIQRBnQEhEAyYAgsgBEEBaiEEQZ4BIRAMlwILIARBAWohBEGfASEQDJYCCwJAIAQgAkcNAEG1ASEQDK8CCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUHkz4CAAGotAABHDZcBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG1ASEQDK8CCyAAQQA2AgAgEEEBaiEBQSghEAyUAQsCQCAEIAJHDQBBtgEhEAyuAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFB6s+AgABqLQAARw2WASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBtgEhEAyuAgsgAEEANgIAIBBBAWohAUEHIRAMkwELAkAgBCACRw0AQbcBIRAMrQILAkACQCAELQAAQbt/ag4OAJYBlgGWAZYBlgGWAZYBlgGWAZYBlgGWAQGWAQsgBEEBaiEEQaEBIRAMlAILIARBAWohBEGiASEQDJMCCwJAIAQgAkcNAEG4ASEQDKwCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDZQBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG4ASEQDKwCCyAAQQA2AgAgEEEBaiEBQRIhEAyRAQsCQCAEIAJHDQBBuQEhEAyrAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8M+AgABqLQAARw2TASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBuQEhEAyrAgsgAEEANgIAIBBBAWohAUEgIRAMkAELAkAgBCACRw0AQboBIRAMqgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfLPgIAAai0AAEcNkgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQboBIRAMqgILIABBADYCACAQQQFqIQFBDyEQDI8BCwJAIAQgAkcNAEG7ASEQDKkCCwJAAkAgBC0AAEG3f2oOBwCSAZIBkgGSAZIBAZIBCyAEQQFqIQRBpQEhEAyQAgsgBEEBaiEEQaYBIRAMjwILAkAgBCACRw0AQbwBIRAMqAILIAIgBGsgACgCACIBaiEUIAQgAWtBB2ohEAJAA0AgBC0AACABQfTPgIAAai0AAEcNkAEgAUEHRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbwBIRAMqAILIABBADYCACAQQQFqIQFBGyEQDI0BCwJAIAQgAkcNAEG9ASEQDKcCCwJAAkACQCAELQAAQb5/ag4SAJEBkQGRAZEBkQGRAZEBkQGRAQGRAZEBkQGRAZEBkQECkQELIARBAWohBEGkASEQDI8CCyAEQQFqIQRBpwEhEAyOAgsgBEEBaiEEQagBIRAMjQILAkAgBCACRw0AQb4BIRAMpgILIAQtAABBzgBHDY0BIARBAWohBAzPAQsCQCAEIAJHDQBBvwEhEAylAgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAELQAAQb9/ag4VAAECA5wBBAUGnAGcAZwBBwgJCgucAQwNDg+cAQsgBEEBaiEBQegAIRAMmgILIARBAWohAUHpACEQDJkCCyAEQQFqIQFB7gAhEAyYAgsgBEEBaiEBQfIAIRAMlwILIARBAWohAUHzACEQDJYCCyAEQQFqIQFB9gAhEAyVAgsgBEEBaiEBQfcAIRAMlAILIARBAWohAUH6ACEQDJMCCyAEQQFqIQRBgwEhEAySAgsgBEEBaiEEQYQBIRAMkQILIARBAWohBEGFASEQDJACCyAEQQFqIQRBkgEhEAyPAgsgBEEBaiEEQZgBIRAMjgILIARBAWohBEGgASEQDI0CCyAEQQFqIQRBowEhEAyMAgsgBEEBaiEEQaoBIRAMiwILAkAgBCACRg0AIABBkICAgAA2AgggACAENgIEQasBIRAMiwILQcABIRAMowILIAAgBSACEKqAgIAAIgENiwEgBSEBDFwLAkAgBiACRg0AIAZBAWohBQyNAQtBwgEhEAyhAgsDQAJAIBAtAABBdmoOBIwBAACPAQALIBBBAWoiECACRw0AC0HDASEQDKACCwJAIAcgAkYNACAAQZGAgIAANgIIIAAgBzYCBCAHIQFBASEQDIcCC0HEASEQDJ8CCwJAIAcgAkcNAEHFASEQDJ8CCwJAAkAgBy0AAEF2ag4EAc4BzgEAzgELIAdBAWohBgyNAQsgB0EBaiEFDIkBCwJAIAcgAkcNAEHGASEQDJ4CCwJAAkAgBy0AAEF2ag4XAY8BjwEBjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BAI8BCyAHQQFqIQcLQbABIRAMhAILAkAgCCACRw0AQcgBIRAMnQILIAgtAABBIEcNjQEgAEEAOwEyIAhBAWohAUGzASEQDIMCCyABIRcCQANAIBciByACRg0BIActAABBUGpB/wFxIhBBCk8NzAECQCAALwEyIhRBmTNLDQAgACAUQQpsIhQ7ATIgEEH//wNzIBRB/v8DcUkNACAHQQFqIRcgACAUIBBqIhA7ATIgEEH//wNxQegHSQ0BCwtBACEQIABBADYCHCAAQcGJgIAANgIQIABBDTYCDCAAIAdBAWo2AhQMnAILQccBIRAMmwILIAAgCCACEK6AgIAAIhBFDcoBIBBBFUcNjAEgAEHIATYCHCAAIAg2AhQgAEHJl4CAADYCECAAQRU2AgxBACEQDJoCCwJAIAkgAkcNAEHMASEQDJoCC0EAIRRBASEXQQEhFkEAIRACQAJAAkACQAJAAkACQAJAAkAgCS0AAEFQag4KlgGVAQABAgMEBQYIlwELQQIhEAwGC0EDIRAMBQtBBCEQDAQLQQUhEAwDC0EGIRAMAgtBByEQDAELQQghEAtBACEXQQAhFkEAIRQMjgELQQkhEEEBIRRBACEXQQAhFgyNAQsCQCAKIAJHDQBBzgEhEAyZAgsgCi0AAEEuRw2OASAKQQFqIQkMygELIAsgAkcNjgFB0AEhEAyXAgsCQCALIAJGDQAgAEGOgICAADYCCCAAIAs2AgRBtwEhEAz+AQtB0QEhEAyWAgsCQCAEIAJHDQBB0gEhEAyWAgsgAiAEayAAKAIAIhBqIRQgBCAQa0EEaiELA0AgBC0AACAQQfzPgIAAai0AAEcNjgEgEEEERg3pASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHSASEQDJUCCyAAIAwgAhCsgICAACIBDY0BIAwhAQy4AQsCQCAEIAJHDQBB1AEhEAyUAgsgAiAEayAAKAIAIhBqIRQgBCAQa0EBaiEMA0AgBC0AACAQQYHQgIAAai0AAEcNjwEgEEEBRg2OASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHUASEQDJMCCwJAIAQgAkcNAEHWASEQDJMCCyACIARrIAAoAgAiEGohFCAEIBBrQQJqIQsDQCAELQAAIBBBg9CAgABqLQAARw2OASAQQQJGDZABIBBBAWohECAEQQFqIgQgAkcNAAsgACAUNgIAQdYBIRAMkgILAkAgBCACRw0AQdcBIRAMkgILAkACQCAELQAAQbt/ag4QAI8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwEBjwELIARBAWohBEG7ASEQDPkBCyAEQQFqIQRBvAEhEAz4AQsCQCAEIAJHDQBB2AEhEAyRAgsgBC0AAEHIAEcNjAEgBEEBaiEEDMQBCwJAIAQgAkYNACAAQZCAgIAANgIIIAAgBDYCBEG+ASEQDPcBC0HZASEQDI8CCwJAIAQgAkcNAEHaASEQDI8CCyAELQAAQcgARg3DASAAQQE6ACgMuQELIABBAjoALyAAIAQgAhCmgICAACIQDY0BQcIBIRAM9AELIAAtAChBf2oOArcBuQG4AQsDQAJAIAQtAABBdmoOBACOAY4BAI4BCyAEQQFqIgQgAkcNAAtB3QEhEAyLAgsgAEEAOgAvIAAtAC1BBHFFDYQCCyAAQQA6AC8gAEEBOgA0IAEhAQyMAQsgEEEVRg3aASAAQQA2AhwgACABNgIUIABBp46AgAA2AhAgAEESNgIMQQAhEAyIAgsCQCAAIBAgAhC0gICAACIEDQAgECEBDIECCwJAIARBFUcNACAAQQM2AhwgACAQNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAyIAgsgAEEANgIcIAAgEDYCFCAAQaeOgIAANgIQIABBEjYCDEEAIRAMhwILIBBBFUYN1gEgAEEANgIcIAAgATYCFCAAQdqNgIAANgIQIABBFDYCDEEAIRAMhgILIAAoAgQhFyAAQQA2AgQgECARp2oiFiEBIAAgFyAQIBYgFBsiEBC1gICAACIURQ2NASAAQQc2AhwgACAQNgIUIAAgFDYCDEEAIRAMhQILIAAgAC8BMEGAAXI7ATAgASEBC0EqIRAM6gELIBBBFUYN0QEgAEEANgIcIAAgATYCFCAAQYOMgIAANgIQIABBEzYCDEEAIRAMggILIBBBFUYNzwEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAMgQILIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDI0BCyAAQQw2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAMgAILIBBBFUYNzAEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAM/wELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDIwBCyAAQQ02AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM/gELIBBBFUYNyQEgAEEANgIcIAAgATYCFCAAQcaMgIAANgIQIABBIzYCDEEAIRAM/QELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC5gICAACIQDQAgAUEBaiEBDIsBCyAAQQ42AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM/AELIABBADYCHCAAIAE2AhQgAEHAlYCAADYCECAAQQI2AgxBACEQDPsBCyAQQRVGDcUBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAAQSM2AgxBACEQDPoBCyAAQRA2AhwgACABNgIUIAAgEDYCDEEAIRAM+QELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC5gICAACIEDQAgAUEBaiEBDPEBCyAAQRE2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM+AELIBBBFUYNwQEgAEEANgIcIAAgATYCFCAAQcaMgIAANgIQIABBIzYCDEEAIRAM9wELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC5gICAACIQDQAgAUEBaiEBDIgBCyAAQRM2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM9gELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC5gICAACIEDQAgAUEBaiEBDO0BCyAAQRQ2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM9QELIBBBFUYNvQEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAM9AELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDIYBCyAAQRY2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM8wELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC3gICAACIEDQAgAUEBaiEBDOkBCyAAQRc2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM8gELIABBADYCHCAAIAE2AhQgAEHNk4CAADYCECAAQQw2AgxBACEQDPEBC0IBIRELIBBBAWohAQJAIAApAyAiEkL//////////w9WDQAgACASQgSGIBGENwMgIAEhAQyEAQsgAEEANgIcIAAgATYCFCAAQa2JgIAANgIQIABBDDYCDEEAIRAM7wELIABBADYCHCAAIBA2AhQgAEHNk4CAADYCECAAQQw2AgxBACEQDO4BCyAAKAIEIRcgAEEANgIEIBAgEadqIhYhASAAIBcgECAWIBQbIhAQtYCAgAAiFEUNcyAAQQU2AhwgACAQNgIUIAAgFDYCDEEAIRAM7QELIABBADYCHCAAIBA2AhQgAEGqnICAADYCECAAQQ82AgxBACEQDOwBCyAAIBAgAhC0gICAACIBDQEgECEBC0EOIRAM0QELAkAgAUEVRw0AIABBAjYCHCAAIBA2AhQgAEGwmICAADYCECAAQRU2AgxBACEQDOoBCyAAQQA2AhwgACAQNgIUIABBp46AgAA2AhAgAEESNgIMQQAhEAzpAQsgAUEBaiEQAkAgAC8BMCIBQYABcUUNAAJAIAAgECACELuAgIAAIgENACAQIQEMcAsgAUEVRw26ASAAQQU2AhwgACAQNgIUIABB+ZeAgAA2AhAgAEEVNgIMQQAhEAzpAQsCQCABQaAEcUGgBEcNACAALQAtQQJxDQAgAEEANgIcIAAgEDYCFCAAQZaTgIAANgIQIABBBDYCDEEAIRAM6QELIAAgECACEL2AgIAAGiAQIQECQAJAAkACQAJAIAAgECACELOAgIAADhYCAQAEBAQEBAQEBAQEBAQEBAQEBAQDBAsgAEEBOgAuCyAAIAAvATBBwAByOwEwIBAhAQtBJiEQDNEBCyAAQSM2AhwgACAQNgIUIABBpZaAgAA2AhAgAEEVNgIMQQAhEAzpAQsgAEEANgIcIAAgEDYCFCAAQdWLgIAANgIQIABBETYCDEEAIRAM6AELIAAtAC1BAXFFDQFBwwEhEAzOAQsCQCANIAJGDQADQAJAIA0tAABBIEYNACANIQEMxAELIA1BAWoiDSACRw0AC0ElIRAM5wELQSUhEAzmAQsgACgCBCEEIABBADYCBCAAIAQgDRCvgICAACIERQ2tASAAQSY2AhwgACAENgIMIAAgDUEBajYCFEEAIRAM5QELIBBBFUYNqwEgAEEANgIcIAAgATYCFCAAQf2NgIAANgIQIABBHTYCDEEAIRAM5AELIABBJzYCHCAAIAE2AhQgACAQNgIMQQAhEAzjAQsgECEBQQEhFAJAAkACQAJAAkACQAJAIAAtACxBfmoOBwYFBQMBAgAFCyAAIAAvATBBCHI7ATAMAwtBAiEUDAELQQQhFAsgAEEBOgAsIAAgAC8BMCAUcjsBMAsgECEBC0ErIRAMygELIABBADYCHCAAIBA2AhQgAEGrkoCAADYCECAAQQs2AgxBACEQDOIBCyAAQQA2AhwgACABNgIUIABB4Y+AgAA2AhAgAEEKNgIMQQAhEAzhAQsgAEEAOgAsIBAhAQy9AQsgECEBQQEhFAJAAkACQAJAAkAgAC0ALEF7ag4EAwECAAULIAAgAC8BMEEIcjsBMAwDC0ECIRQMAQtBBCEUCyAAQQE6ACwgACAALwEwIBRyOwEwCyAQIQELQSkhEAzFAQsgAEEANgIcIAAgATYCFCAAQfCUgIAANgIQIABBAzYCDEEAIRAM3QELAkAgDi0AAEENRw0AIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDkEBaiEBDHULIABBLDYCHCAAIAE2AgwgACAOQQFqNgIUQQAhEAzdAQsgAC0ALUEBcUUNAUHEASEQDMMBCwJAIA4gAkcNAEEtIRAM3AELAkACQANAAkAgDi0AAEF2ag4EAgAAAwALIA5BAWoiDiACRw0AC0EtIRAM3QELIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDiEBDHQLIABBLDYCHCAAIA42AhQgACABNgIMQQAhEAzcAQsgACgCBCEBIABBADYCBAJAIAAgASAOELGAgIAAIgENACAOQQFqIQEMcwsgAEEsNgIcIAAgATYCDCAAIA5BAWo2AhRBACEQDNsBCyAAKAIEIQQgAEEANgIEIAAgBCAOELGAgIAAIgQNoAEgDiEBDM4BCyAQQSxHDQEgAUEBaiEQQQEhAQJAAkACQAJAAkAgAC0ALEF7ag4EAwECBAALIBAhAQwEC0ECIQEMAQtBBCEBCyAAQQE6ACwgACAALwEwIAFyOwEwIBAhAQwBCyAAIAAvATBBCHI7ATAgECEBC0E5IRAMvwELIABBADoALCABIQELQTQhEAy9AQsgACAALwEwQSByOwEwIAEhAQwCCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQsYCAgAAiBA0AIAEhAQzHAQsgAEE3NgIcIAAgATYCFCAAIAQ2AgxBACEQDNQBCyAAQQg6ACwgASEBC0EwIRAMuQELAkAgAC0AKEEBRg0AIAEhAQwECyAALQAtQQhxRQ2TASABIQEMAwsgAC0AMEEgcQ2UAUHFASEQDLcBCwJAIA8gAkYNAAJAA0ACQCAPLQAAQVBqIgFB/wFxQQpJDQAgDyEBQTUhEAy6AQsgACkDICIRQpmz5syZs+bMGVYNASAAIBFCCn4iETcDICARIAGtQv8BgyISQn+FVg0BIAAgESASfDcDICAPQQFqIg8gAkcNAAtBOSEQDNEBCyAAKAIEIQIgAEEANgIEIAAgAiAPQQFqIgQQsYCAgAAiAg2VASAEIQEMwwELQTkhEAzPAQsCQCAALwEwIgFBCHFFDQAgAC0AKEEBRw0AIAAtAC1BCHFFDZABCyAAIAFB9/sDcUGABHI7ATAgDyEBC0E3IRAMtAELIAAgAC8BMEEQcjsBMAyrAQsgEEEVRg2LASAAQQA2AhwgACABNgIUIABB8I6AgAA2AhAgAEEcNgIMQQAhEAzLAQsgAEHDADYCHCAAIAE2AgwgACANQQFqNgIUQQAhEAzKAQsCQCABLQAAQTpHDQAgACgCBCEQIABBADYCBAJAIAAgECABEK+AgIAAIhANACABQQFqIQEMYwsgAEHDADYCHCAAIBA2AgwgACABQQFqNgIUQQAhEAzKAQsgAEEANgIcIAAgATYCFCAAQbGRgIAANgIQIABBCjYCDEEAIRAMyQELIABBADYCHCAAIAE2AhQgAEGgmYCAADYCECAAQR42AgxBACEQDMgBCyAAQQA2AgALIABBgBI7ASogACAXQQFqIgEgAhCogICAACIQDQEgASEBC0HHACEQDKwBCyAQQRVHDYMBIABB0QA2AhwgACABNgIUIABB45eAgAA2AhAgAEEVNgIMQQAhEAzEAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMXgsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAzDAQsgAEEANgIcIAAgFDYCFCAAQcGogIAANgIQIABBBzYCDCAAQQA2AgBBACEQDMIBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxdCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDMEBC0EAIRAgAEEANgIcIAAgATYCFCAAQYCRgIAANgIQIABBCTYCDAzAAQsgEEEVRg19IABBADYCHCAAIAE2AhQgAEGUjYCAADYCECAAQSE2AgxBACEQDL8BC0EBIRZBACEXQQAhFEEBIRALIAAgEDoAKyABQQFqIQECQAJAIAAtAC1BEHENAAJAAkACQCAALQAqDgMBAAIECyAWRQ0DDAILIBQNAQwCCyAXRQ0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQrYCAgAAiEA0AIAEhAQxcCyAAQdgANgIcIAAgATYCFCAAIBA2AgxBACEQDL4BCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQrYCAgAAiBA0AIAEhAQytAQsgAEHZADYCHCAAIAE2AhQgACAENgIMQQAhEAy9AQsgACgCBCEEIABBADYCBAJAIAAgBCABEK2AgIAAIgQNACABIQEMqwELIABB2gA2AhwgACABNgIUIAAgBDYCDEEAIRAMvAELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKkBCyAAQdwANgIcIAAgATYCFCAAIAQ2AgxBACEQDLsBCwJAIAEtAABBUGoiEEH/AXFBCk8NACAAIBA6ACogAUEBaiEBQc8AIRAMogELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKcBCyAAQd4ANgIcIAAgATYCFCAAIAQ2AgxBACEQDLoBCyAAQQA2AgAgF0EBaiEBAkAgAC0AKUEjTw0AIAEhAQxZCyAAQQA2AhwgACABNgIUIABB04mAgAA2AhAgAEEINgIMQQAhEAy5AQsgAEEANgIAC0EAIRAgAEEANgIcIAAgATYCFCAAQZCzgIAANgIQIABBCDYCDAy3AQsgAEEANgIAIBdBAWohAQJAIAAtAClBIUcNACABIQEMVgsgAEEANgIcIAAgATYCFCAAQZuKgIAANgIQIABBCDYCDEEAIRAMtgELIABBADYCACAXQQFqIQECQCAALQApIhBBXWpBC08NACABIQEMVQsCQCAQQQZLDQBBASAQdEHKAHFFDQAgASEBDFULQQAhECAAQQA2AhwgACABNgIUIABB94mAgAA2AhAgAEEINgIMDLUBCyAQQRVGDXEgAEEANgIcIAAgATYCFCAAQbmNgIAANgIQIABBGjYCDEEAIRAMtAELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDFQLIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMswELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDE0LIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMsgELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDE0LIABB0wA2AhwgACABNgIUIAAgEDYCDEEAIRAMsQELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDFELIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMsAELIABBADYCHCAAIAE2AhQgAEHGioCAADYCECAAQQc2AgxBACEQDK8BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxJCyAAQdIANgIcIAAgATYCFCAAIBA2AgxBACEQDK4BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxJCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDK0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxNCyAAQeUANgIcIAAgATYCFCAAIBA2AgxBACEQDKwBCyAAQQA2AhwgACABNgIUIABB3IiAgAA2AhAgAEEHNgIMQQAhEAyrAQsgEEE/Rw0BIAFBAWohAQtBBSEQDJABC0EAIRAgAEEANgIcIAAgATYCFCAAQf2SgIAANgIQIABBBzYCDAyoAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMQgsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAynAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMQgsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAymAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMRgsgAEHlADYCHCAAIAE2AhQgACAQNgIMQQAhEAylAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMPwsgAEHSADYCHCAAIBQ2AhQgACABNgIMQQAhEAykAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMPwsgAEHTADYCHCAAIBQ2AhQgACABNgIMQQAhEAyjAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMQwsgAEHlADYCHCAAIBQ2AhQgACABNgIMQQAhEAyiAQsgAEEANgIcIAAgFDYCFCAAQcOPgIAANgIQIABBBzYCDEEAIRAMoQELIABBADYCHCAAIAE2AhQgAEHDj4CAADYCECAAQQc2AgxBACEQDKABC0EAIRAgAEEANgIcIAAgFDYCFCAAQYycgIAANgIQIABBBzYCDAyfAQsgAEEANgIcIAAgFDYCFCAAQYycgIAANgIQIABBBzYCDEEAIRAMngELIABBADYCHCAAIBQ2AhQgAEH+kYCAADYCECAAQQc2AgxBACEQDJ0BCyAAQQA2AhwgACABNgIUIABBjpuAgAA2AhAgAEEGNgIMQQAhEAycAQsgEEEVRg1XIABBADYCHCAAIAE2AhQgAEHMjoCAADYCECAAQSA2AgxBACEQDJsBCyAAQQA2AgAgEEEBaiEBQSQhEAsgACAQOgApIAAoAgQhECAAQQA2AgQgACAQIAEQq4CAgAAiEA1UIAEhAQw+CyAAQQA2AgALQQAhECAAQQA2AhwgACAENgIUIABB8ZuAgAA2AhAgAEEGNgIMDJcBCyABQRVGDVAgAEEANgIcIAAgBTYCFCAAQfCMgIAANgIQIABBGzYCDEEAIRAMlgELIAAoAgQhBSAAQQA2AgQgACAFIBAQqYCAgAAiBQ0BIBBBAWohBQtBrQEhEAx7CyAAQcEBNgIcIAAgBTYCDCAAIBBBAWo2AhRBACEQDJMBCyAAKAIEIQYgAEEANgIEIAAgBiAQEKmAgIAAIgYNASAQQQFqIQYLQa4BIRAMeAsgAEHCATYCHCAAIAY2AgwgACAQQQFqNgIUQQAhEAyQAQsgAEEANgIcIAAgBzYCFCAAQZeLgIAANgIQIABBDTYCDEEAIRAMjwELIABBADYCHCAAIAg2AhQgAEHjkICAADYCECAAQQk2AgxBACEQDI4BCyAAQQA2AhwgACAINgIUIABBlI2AgAA2AhAgAEEhNgIMQQAhEAyNAQtBASEWQQAhF0EAIRRBASEQCyAAIBA6ACsgCUEBaiEIAkACQCAALQAtQRBxDQACQAJAAkAgAC0AKg4DAQACBAsgFkUNAwwCCyAUDQEMAgsgF0UNAQsgACgCBCEQIABBADYCBCAAIBAgCBCtgICAACIQRQ09IABByQE2AhwgACAINgIUIAAgEDYCDEEAIRAMjAELIAAoAgQhBCAAQQA2AgQgACAEIAgQrYCAgAAiBEUNdiAAQcoBNgIcIAAgCDYCFCAAIAQ2AgxBACEQDIsBCyAAKAIEIQQgAEEANgIEIAAgBCAJEK2AgIAAIgRFDXQgAEHLATYCHCAAIAk2AhQgACAENgIMQQAhEAyKAQsgACgCBCEEIABBADYCBCAAIAQgChCtgICAACIERQ1yIABBzQE2AhwgACAKNgIUIAAgBDYCDEEAIRAMiQELAkAgCy0AAEFQaiIQQf8BcUEKTw0AIAAgEDoAKiALQQFqIQpBtgEhEAxwCyAAKAIEIQQgAEEANgIEIAAgBCALEK2AgIAAIgRFDXAgAEHPATYCHCAAIAs2AhQgACAENgIMQQAhEAyIAQsgAEEANgIcIAAgBDYCFCAAQZCzgIAANgIQIABBCDYCDCAAQQA2AgBBACEQDIcBCyABQRVGDT8gAEEANgIcIAAgDDYCFCAAQcyOgIAANgIQIABBIDYCDEEAIRAMhgELIABBgQQ7ASggACgCBCEQIABCADcDACAAIBAgDEEBaiIMEKuAgIAAIhBFDTggAEHTATYCHCAAIAw2AhQgACAQNgIMQQAhEAyFAQsgAEEANgIAC0EAIRAgAEEANgIcIAAgBDYCFCAAQdibgIAANgIQIABBCDYCDAyDAQsgACgCBCEQIABCADcDACAAIBAgC0EBaiILEKuAgIAAIhANAUHGASEQDGkLIABBAjoAKAxVCyAAQdUBNgIcIAAgCzYCFCAAIBA2AgxBACEQDIABCyAQQRVGDTcgAEEANgIcIAAgBDYCFCAAQaSMgIAANgIQIABBEDYCDEEAIRAMfwsgAC0ANEEBRw00IAAgBCACELyAgIAAIhBFDTQgEEEVRw01IABB3AE2AhwgACAENgIUIABB1ZaAgAA2AhAgAEEVNgIMQQAhEAx+C0EAIRAgAEEANgIcIABBr4uAgAA2AhAgAEECNgIMIAAgFEEBajYCFAx9C0EAIRAMYwtBAiEQDGILQQ0hEAxhC0EPIRAMYAtBJSEQDF8LQRMhEAxeC0EVIRAMXQtBFiEQDFwLQRchEAxbC0EYIRAMWgtBGSEQDFkLQRohEAxYC0EbIRAMVwtBHCEQDFYLQR0hEAxVC0EfIRAMVAtBISEQDFMLQSMhEAxSC0HGACEQDFELQS4hEAxQC0EvIRAMTwtBOyEQDE4LQT0hEAxNC0HIACEQDEwLQckAIRAMSwtBywAhEAxKC0HMACEQDEkLQc4AIRAMSAtB0QAhEAxHC0HVACEQDEYLQdgAIRAMRQtB2QAhEAxEC0HbACEQDEMLQeQAIRAMQgtB5QAhEAxBC0HxACEQDEALQfQAIRAMPwtBjQEhEAw+C0GXASEQDD0LQakBIRAMPAtBrAEhEAw7C0HAASEQDDoLQbkBIRAMOQtBrwEhEAw4C0GxASEQDDcLQbIBIRAMNgtBtAEhEAw1C0G1ASEQDDQLQboBIRAMMwtBvQEhEAwyC0G/ASEQDDELQcEBIRAMMAsgAEEANgIcIAAgBDYCFCAAQemLgIAANgIQIABBHzYCDEEAIRAMSAsgAEHbATYCHCAAIAQ2AhQgAEH6loCAADYCECAAQRU2AgxBACEQDEcLIABB+AA2AhwgACAMNgIUIABBypiAgAA2AhAgAEEVNgIMQQAhEAxGCyAAQdEANgIcIAAgBTYCFCAAQbCXgIAANgIQIABBFTYCDEEAIRAMRQsgAEH5ADYCHCAAIAE2AhQgACAQNgIMQQAhEAxECyAAQfgANgIcIAAgATYCFCAAQcqYgIAANgIQIABBFTYCDEEAIRAMQwsgAEHkADYCHCAAIAE2AhQgAEHjl4CAADYCECAAQRU2AgxBACEQDEILIABB1wA2AhwgACABNgIUIABByZeAgAA2AhAgAEEVNgIMQQAhEAxBCyAAQQA2AhwgACABNgIUIABBuY2AgAA2AhAgAEEaNgIMQQAhEAxACyAAQcIANgIcIAAgATYCFCAAQeOYgIAANgIQIABBFTYCDEEAIRAMPwsgAEEANgIEIAAgDyAPELGAgIAAIgRFDQEgAEE6NgIcIAAgBDYCDCAAIA9BAWo2AhRBACEQDD4LIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCxgICAACIERQ0AIABBOzYCHCAAIAQ2AgwgACABQQFqNgIUQQAhEAw+CyABQQFqIQEMLQsgD0EBaiEBDC0LIABBADYCHCAAIA82AhQgAEHkkoCAADYCECAAQQQ2AgxBACEQDDsLIABBNjYCHCAAIAQ2AhQgACACNgIMQQAhEAw6CyAAQS42AhwgACAONgIUIAAgBDYCDEEAIRAMOQsgAEHQADYCHCAAIAE2AhQgAEGRmICAADYCECAAQRU2AgxBACEQDDgLIA1BAWohAQwsCyAAQRU2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAw2CyAAQRs2AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAw1CyAAQQ82AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAw0CyAAQQs2AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAwzCyAAQRo2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAwyCyAAQQs2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAwxCyAAQQo2AhwgACABNgIUIABB5JaAgAA2AhAgAEEVNgIMQQAhEAwwCyAAQR42AhwgACABNgIUIABB+ZeAgAA2AhAgAEEVNgIMQQAhEAwvCyAAQQA2AhwgACAQNgIUIABB2o2AgAA2AhAgAEEUNgIMQQAhEAwuCyAAQQQ2AhwgACABNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAwtCyAAQQA2AgAgC0EBaiELC0G4ASEQDBILIABBADYCACAQQQFqIQFB9QAhEAwRCyABIQECQCAALQApQQVHDQBB4wAhEAwRC0HiACEQDBALQQAhECAAQQA2AhwgAEHkkYCAADYCECAAQQc2AgwgACAUQQFqNgIUDCgLIABBADYCACAXQQFqIQFBwAAhEAwOC0EBIQELIAAgAToALCAAQQA2AgAgF0EBaiEBC0EoIRAMCwsgASEBC0E4IRAMCQsCQCABIg8gAkYNAANAAkAgDy0AAEGAvoCAAGotAAAiAUEBRg0AIAFBAkcNAyAPQQFqIQEMBAsgD0EBaiIPIAJHDQALQT4hEAwiC0E+IRAMIQsgAEEAOgAsIA8hAQwBC0ELIRAMBgtBOiEQDAULIAFBAWohAUEtIRAMBAsgACABOgAsIABBADYCACAWQQFqIQFBDCEQDAMLIABBADYCACAXQQFqIQFBCiEQDAILIABBADYCAAsgAEEAOgAsIA0hAUEJIRAMAAsLQQAhECAAQQA2AhwgACALNgIUIABBzZCAgAA2AhAgAEEJNgIMDBcLQQAhECAAQQA2AhwgACAKNgIUIABB6YqAgAA2AhAgAEEJNgIMDBYLQQAhECAAQQA2AhwgACAJNgIUIABBt5CAgAA2AhAgAEEJNgIMDBULQQAhECAAQQA2AhwgACAINgIUIABBnJGAgAA2AhAgAEEJNgIMDBQLQQAhECAAQQA2AhwgACABNgIUIABBzZCAgAA2AhAgAEEJNgIMDBMLQQAhECAAQQA2AhwgACABNgIUIABB6YqAgAA2AhAgAEEJNgIMDBILQQAhECAAQQA2AhwgACABNgIUIABBt5CAgAA2AhAgAEEJNgIMDBELQQAhECAAQQA2AhwgACABNgIUIABBnJGAgAA2AhAgAEEJNgIMDBALQQAhECAAQQA2AhwgACABNgIUIABBl5WAgAA2AhAgAEEPNgIMDA8LQQAhECAAQQA2AhwgACABNgIUIABBl5WAgAA2AhAgAEEPNgIMDA4LQQAhECAAQQA2AhwgACABNgIUIABBwJKAgAA2AhAgAEELNgIMDA0LQQAhECAAQQA2AhwgACABNgIUIABBlYmAgAA2AhAgAEELNgIMDAwLQQAhECAAQQA2AhwgACABNgIUIABB4Y+AgAA2AhAgAEEKNgIMDAsLQQAhECAAQQA2AhwgACABNgIUIABB+4+AgAA2AhAgAEEKNgIMDAoLQQAhECAAQQA2AhwgACABNgIUIABB8ZmAgAA2AhAgAEECNgIMDAkLQQAhECAAQQA2AhwgACABNgIUIABBxJSAgAA2AhAgAEECNgIMDAgLQQAhECAAQQA2AhwgACABNgIUIABB8pWAgAA2AhAgAEECNgIMDAcLIABBAjYCHCAAIAE2AhQgAEGcmoCAADYCECAAQRY2AgxBACEQDAYLQQEhEAwFC0HUACEQIAEiBCACRg0EIANBCGogACAEIAJB2MKAgABBChDFgICAACADKAIMIQQgAygCCA4DAQQCAAsQyoCAgAAACyAAQQA2AhwgAEG1moCAADYCECAAQRc2AgwgACAEQQFqNgIUQQAhEAwCCyAAQQA2AhwgACAENgIUIABBypqAgAA2AhAgAEEJNgIMQQAhEAwBCwJAIAEiBCACRw0AQSIhEAwBCyAAQYmAgIAANgIIIAAgBDYCBEEhIRALIANBEGokgICAgAAgEAuvAQECfyABKAIAIQYCQAJAIAIgA0YNACAEIAZqIQQgBiADaiACayEHIAIgBkF/cyAFaiIGaiEFA0ACQCACLQAAIAQtAABGDQBBAiEEDAMLAkAgBg0AQQAhBCAFIQIMAwsgBkF/aiEGIARBAWohBCACQQFqIgIgA0cNAAsgByEGIAMhAgsgAEEBNgIAIAEgBjYCACAAIAI2AgQPCyABQQA2AgAgACAENgIAIAAgAjYCBAsKACAAEMeAgIAAC/I2AQt/I4CAgIAAQRBrIgEkgICAgAACQEEAKAKg0ICAAA0AQQAQy4CAgABBgNSEgABrIgJB2QBJDQBBACEDAkBBACgC4NOAgAAiBA0AQQBCfzcC7NOAgABBAEKAgISAgIDAADcC5NOAgABBACABQQhqQXBxQdiq1aoFcyIENgLg04CAAEEAQQA2AvTTgIAAQQBBADYCxNOAgAALQQAgAjYCzNOAgABBAEGA1ISAADYCyNOAgABBAEGA1ISAADYCmNCAgABBACAENgKs0ICAAEEAQX82AqjQgIAAA0AgA0HE0ICAAGogA0G40ICAAGoiBDYCACAEIANBsNCAgABqIgU2AgAgA0G80ICAAGogBTYCACADQczQgIAAaiADQcDQgIAAaiIFNgIAIAUgBDYCACADQdTQgIAAaiADQcjQgIAAaiIENgIAIAQgBTYCACADQdDQgIAAaiAENgIAIANBIGoiA0GAAkcNAAtBgNSEgABBeEGA1ISAAGtBD3FBAEGA1ISAAEEIakEPcRsiA2oiBEEEaiACQUhqIgUgA2siA0EBcjYCAEEAQQAoAvDTgIAANgKk0ICAAEEAIAM2ApTQgIAAQQAgBDYCoNCAgABBgNSEgAAgBWpBODYCBAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEHsAUsNAAJAQQAoAojQgIAAIgZBECAAQRNqQXBxIABBC0kbIgJBA3YiBHYiA0EDcUUNAAJAAkAgA0EBcSAEckEBcyIFQQN0IgRBsNCAgABqIgMgBEG40ICAAGooAgAiBCgCCCICRw0AQQAgBkF+IAV3cTYCiNCAgAAMAQsgAyACNgIIIAIgAzYCDAsgBEEIaiEDIAQgBUEDdCIFQQNyNgIEIAQgBWoiBCAEKAIEQQFyNgIEDAwLIAJBACgCkNCAgAAiB00NAQJAIANFDQACQAJAIAMgBHRBAiAEdCIDQQAgA2tycSIDQQAgA2txQX9qIgMgA0EMdkEQcSIDdiIEQQV2QQhxIgUgA3IgBCAFdiIDQQJ2QQRxIgRyIAMgBHYiA0EBdkECcSIEciADIAR2IgNBAXZBAXEiBHIgAyAEdmoiBEEDdCIDQbDQgIAAaiIFIANBuNCAgABqKAIAIgMoAggiAEcNAEEAIAZBfiAEd3EiBjYCiNCAgAAMAQsgBSAANgIIIAAgBTYCDAsgAyACQQNyNgIEIAMgBEEDdCIEaiAEIAJrIgU2AgAgAyACaiIAIAVBAXI2AgQCQCAHRQ0AIAdBeHFBsNCAgABqIQJBACgCnNCAgAAhBAJAAkAgBkEBIAdBA3Z0IghxDQBBACAGIAhyNgKI0ICAACACIQgMAQsgAigCCCEICyAIIAQ2AgwgAiAENgIIIAQgAjYCDCAEIAg2AggLIANBCGohA0EAIAA2ApzQgIAAQQAgBTYCkNCAgAAMDAtBACgCjNCAgAAiCUUNASAJQQAgCWtxQX9qIgMgA0EMdkEQcSIDdiIEQQV2QQhxIgUgA3IgBCAFdiIDQQJ2QQRxIgRyIAMgBHYiA0EBdkECcSIEciADIAR2IgNBAXZBAXEiBHIgAyAEdmpBAnRBuNKAgABqKAIAIgAoAgRBeHEgAmshBCAAIQUCQANAAkAgBSgCECIDDQAgBUEUaigCACIDRQ0CCyADKAIEQXhxIAJrIgUgBCAFIARJIgUbIQQgAyAAIAUbIQAgAyEFDAALCyAAKAIYIQoCQCAAKAIMIgggAEYNACAAKAIIIgNBACgCmNCAgABJGiAIIAM2AgggAyAINgIMDAsLAkAgAEEUaiIFKAIAIgMNACAAKAIQIgNFDQMgAEEQaiEFCwNAIAUhCyADIghBFGoiBSgCACIDDQAgCEEQaiEFIAgoAhAiAw0ACyALQQA2AgAMCgtBfyECIABBv39LDQAgAEETaiIDQXBxIQJBACgCjNCAgAAiB0UNAEEAIQsCQCACQYACSQ0AQR8hCyACQf///wdLDQAgA0EIdiIDIANBgP4/akEQdkEIcSIDdCIEIARBgOAfakEQdkEEcSIEdCIFIAVBgIAPakEQdkECcSIFdEEPdiADIARyIAVyayIDQQF0IAIgA0EVanZBAXFyQRxqIQsLQQAgAmshBAJAAkACQAJAIAtBAnRBuNKAgABqKAIAIgUNAEEAIQNBACEIDAELQQAhAyACQQBBGSALQQF2ayALQR9GG3QhAEEAIQgDQAJAIAUoAgRBeHEgAmsiBiAETw0AIAYhBCAFIQggBg0AQQAhBCAFIQggBSEDDAMLIAMgBUEUaigCACIGIAYgBSAAQR12QQRxakEQaigCACIFRhsgAyAGGyEDIABBAXQhACAFDQALCwJAIAMgCHINAEEAIQhBAiALdCIDQQAgA2tyIAdxIgNFDQMgA0EAIANrcUF/aiIDIANBDHZBEHEiA3YiBUEFdkEIcSIAIANyIAUgAHYiA0ECdkEEcSIFciADIAV2IgNBAXZBAnEiBXIgAyAFdiIDQQF2QQFxIgVyIAMgBXZqQQJ0QbjSgIAAaigCACEDCyADRQ0BCwNAIAMoAgRBeHEgAmsiBiAESSEAAkAgAygCECIFDQAgA0EUaigCACEFCyAGIAQgABshBCADIAggABshCCAFIQMgBQ0ACwsgCEUNACAEQQAoApDQgIAAIAJrTw0AIAgoAhghCwJAIAgoAgwiACAIRg0AIAgoAggiA0EAKAKY0ICAAEkaIAAgAzYCCCADIAA2AgwMCQsCQCAIQRRqIgUoAgAiAw0AIAgoAhAiA0UNAyAIQRBqIQULA0AgBSEGIAMiAEEUaiIFKAIAIgMNACAAQRBqIQUgACgCECIDDQALIAZBADYCAAwICwJAQQAoApDQgIAAIgMgAkkNAEEAKAKc0ICAACEEAkACQCADIAJrIgVBEEkNACAEIAJqIgAgBUEBcjYCBEEAIAU2ApDQgIAAQQAgADYCnNCAgAAgBCADaiAFNgIAIAQgAkEDcjYCBAwBCyAEIANBA3I2AgQgBCADaiIDIAMoAgRBAXI2AgRBAEEANgKc0ICAAEEAQQA2ApDQgIAACyAEQQhqIQMMCgsCQEEAKAKU0ICAACIAIAJNDQBBACgCoNCAgAAiAyACaiIEIAAgAmsiBUEBcjYCBEEAIAU2ApTQgIAAQQAgBDYCoNCAgAAgAyACQQNyNgIEIANBCGohAwwKCwJAAkBBACgC4NOAgABFDQBBACgC6NOAgAAhBAwBC0EAQn83AuzTgIAAQQBCgICEgICAwAA3AuTTgIAAQQAgAUEMakFwcUHYqtWqBXM2AuDTgIAAQQBBADYC9NOAgABBAEEANgLE04CAAEGAgAQhBAtBACEDAkAgBCACQccAaiIHaiIGQQAgBGsiC3EiCCACSw0AQQBBMDYC+NOAgAAMCgsCQEEAKALA04CAACIDRQ0AAkBBACgCuNOAgAAiBCAIaiIFIARNDQAgBSADTQ0BC0EAIQNBAEEwNgL404CAAAwKC0EALQDE04CAAEEEcQ0EAkACQAJAQQAoAqDQgIAAIgRFDQBByNOAgAAhAwNAAkAgAygCACIFIARLDQAgBSADKAIEaiAESw0DCyADKAIIIgMNAAsLQQAQy4CAgAAiAEF/Rg0FIAghBgJAQQAoAuTTgIAAIgNBf2oiBCAAcUUNACAIIABrIAQgAGpBACADa3FqIQYLIAYgAk0NBSAGQf7///8HSw0FAkBBACgCwNOAgAAiA0UNAEEAKAK404CAACIEIAZqIgUgBE0NBiAFIANLDQYLIAYQy4CAgAAiAyAARw0BDAcLIAYgAGsgC3EiBkH+////B0sNBCAGEMuAgIAAIgAgAygCACADKAIEakYNAyAAIQMLAkAgA0F/Rg0AIAJByABqIAZNDQACQCAHIAZrQQAoAujTgIAAIgRqQQAgBGtxIgRB/v///wdNDQAgAyEADAcLAkAgBBDLgICAAEF/Rg0AIAQgBmohBiADIQAMBwtBACAGaxDLgICAABoMBAsgAyEAIANBf0cNBQwDC0EAIQgMBwtBACEADAULIABBf0cNAgtBAEEAKALE04CAAEEEcjYCxNOAgAALIAhB/v///wdLDQEgCBDLgICAACEAQQAQy4CAgAAhAyAAQX9GDQEgA0F/Rg0BIAAgA08NASADIABrIgYgAkE4ak0NAQtBAEEAKAK404CAACAGaiIDNgK404CAAAJAIANBACgCvNOAgABNDQBBACADNgK804CAAAsCQAJAAkACQEEAKAKg0ICAACIERQ0AQcjTgIAAIQMDQCAAIAMoAgAiBSADKAIEIghqRg0CIAMoAggiAw0ADAMLCwJAAkBBACgCmNCAgAAiA0UNACAAIANPDQELQQAgADYCmNCAgAALQQAhA0EAIAY2AszTgIAAQQAgADYCyNOAgABBAEF/NgKo0ICAAEEAQQAoAuDTgIAANgKs0ICAAEEAQQA2AtTTgIAAA0AgA0HE0ICAAGogA0G40ICAAGoiBDYCACAEIANBsNCAgABqIgU2AgAgA0G80ICAAGogBTYCACADQczQgIAAaiADQcDQgIAAaiIFNgIAIAUgBDYCACADQdTQgIAAaiADQcjQgIAAaiIENgIAIAQgBTYCACADQdDQgIAAaiAENgIAIANBIGoiA0GAAkcNAAsgAEF4IABrQQ9xQQAgAEEIakEPcRsiA2oiBCAGQUhqIgUgA2siA0EBcjYCBEEAQQAoAvDTgIAANgKk0ICAAEEAIAM2ApTQgIAAQQAgBDYCoNCAgAAgACAFakE4NgIEDAILIAMtAAxBCHENACAEIAVJDQAgBCAATw0AIARBeCAEa0EPcUEAIARBCGpBD3EbIgVqIgBBACgClNCAgAAgBmoiCyAFayIFQQFyNgIEIAMgCCAGajYCBEEAQQAoAvDTgIAANgKk0ICAAEEAIAU2ApTQgIAAQQAgADYCoNCAgAAgBCALakE4NgIEDAELAkAgAEEAKAKY0ICAACIITw0AQQAgADYCmNCAgAAgACEICyAAIAZqIQVByNOAgAAhAwJAAkACQAJAAkACQAJAA0AgAygCACAFRg0BIAMoAggiAw0ADAILCyADLQAMQQhxRQ0BC0HI04CAACEDA0ACQCADKAIAIgUgBEsNACAFIAMoAgRqIgUgBEsNAwsgAygCCCEDDAALCyADIAA2AgAgAyADKAIEIAZqNgIEIABBeCAAa0EPcUEAIABBCGpBD3EbaiILIAJBA3I2AgQgBUF4IAVrQQ9xQQAgBUEIakEPcRtqIgYgCyACaiICayEDAkAgBiAERw0AQQAgAjYCoNCAgABBAEEAKAKU0ICAACADaiIDNgKU0ICAACACIANBAXI2AgQMAwsCQCAGQQAoApzQgIAARw0AQQAgAjYCnNCAgABBAEEAKAKQ0ICAACADaiIDNgKQ0ICAACACIANBAXI2AgQgAiADaiADNgIADAMLAkAgBigCBCIEQQNxQQFHDQAgBEF4cSEHAkACQCAEQf8BSw0AIAYoAggiBSAEQQN2IghBA3RBsNCAgABqIgBGGgJAIAYoAgwiBCAFRw0AQQBBACgCiNCAgABBfiAId3E2AojQgIAADAILIAQgAEYaIAQgBTYCCCAFIAQ2AgwMAQsgBigCGCEJAkACQCAGKAIMIgAgBkYNACAGKAIIIgQgCEkaIAAgBDYCCCAEIAA2AgwMAQsCQCAGQRRqIgQoAgAiBQ0AIAZBEGoiBCgCACIFDQBBACEADAELA0AgBCEIIAUiAEEUaiIEKAIAIgUNACAAQRBqIQQgACgCECIFDQALIAhBADYCAAsgCUUNAAJAAkAgBiAGKAIcIgVBAnRBuNKAgABqIgQoAgBHDQAgBCAANgIAIAANAUEAQQAoAozQgIAAQX4gBXdxNgKM0ICAAAwCCyAJQRBBFCAJKAIQIAZGG2ogADYCACAARQ0BCyAAIAk2AhgCQCAGKAIQIgRFDQAgACAENgIQIAQgADYCGAsgBigCFCIERQ0AIABBFGogBDYCACAEIAA2AhgLIAcgA2ohAyAGIAdqIgYoAgQhBAsgBiAEQX5xNgIEIAIgA2ogAzYCACACIANBAXI2AgQCQCADQf8BSw0AIANBeHFBsNCAgABqIQQCQAJAQQAoAojQgIAAIgVBASADQQN2dCIDcQ0AQQAgBSADcjYCiNCAgAAgBCEDDAELIAQoAgghAwsgAyACNgIMIAQgAjYCCCACIAQ2AgwgAiADNgIIDAMLQR8hBAJAIANB////B0sNACADQQh2IgQgBEGA/j9qQRB2QQhxIgR0IgUgBUGA4B9qQRB2QQRxIgV0IgAgAEGAgA9qQRB2QQJxIgB0QQ92IAQgBXIgAHJrIgRBAXQgAyAEQRVqdkEBcXJBHGohBAsgAiAENgIcIAJCADcCECAEQQJ0QbjSgIAAaiEFAkBBACgCjNCAgAAiAEEBIAR0IghxDQAgBSACNgIAQQAgACAIcjYCjNCAgAAgAiAFNgIYIAIgAjYCCCACIAI2AgwMAwsgA0EAQRkgBEEBdmsgBEEfRht0IQQgBSgCACEAA0AgACIFKAIEQXhxIANGDQIgBEEddiEAIARBAXQhBCAFIABBBHFqQRBqIggoAgAiAA0ACyAIIAI2AgAgAiAFNgIYIAIgAjYCDCACIAI2AggMAgsgAEF4IABrQQ9xQQAgAEEIakEPcRsiA2oiCyAGQUhqIgggA2siA0EBcjYCBCAAIAhqQTg2AgQgBCAFQTcgBWtBD3FBACAFQUlqQQ9xG2pBQWoiCCAIIARBEGpJGyIIQSM2AgRBAEEAKALw04CAADYCpNCAgABBACADNgKU0ICAAEEAIAs2AqDQgIAAIAhBEGpBACkC0NOAgAA3AgAgCEEAKQLI04CAADcCCEEAIAhBCGo2AtDTgIAAQQAgBjYCzNOAgABBACAANgLI04CAAEEAQQA2AtTTgIAAIAhBJGohAwNAIANBBzYCACADQQRqIgMgBUkNAAsgCCAERg0DIAggCCgCBEF+cTYCBCAIIAggBGsiADYCACAEIABBAXI2AgQCQCAAQf8BSw0AIABBeHFBsNCAgABqIQMCQAJAQQAoAojQgIAAIgVBASAAQQN2dCIAcQ0AQQAgBSAAcjYCiNCAgAAgAyEFDAELIAMoAgghBQsgBSAENgIMIAMgBDYCCCAEIAM2AgwgBCAFNgIIDAQLQR8hAwJAIABB////B0sNACAAQQh2IgMgA0GA/j9qQRB2QQhxIgN0IgUgBUGA4B9qQRB2QQRxIgV0IgggCEGAgA9qQRB2QQJxIgh0QQ92IAMgBXIgCHJrIgNBAXQgACADQRVqdkEBcXJBHGohAwsgBCADNgIcIARCADcCECADQQJ0QbjSgIAAaiEFAkBBACgCjNCAgAAiCEEBIAN0IgZxDQAgBSAENgIAQQAgCCAGcjYCjNCAgAAgBCAFNgIYIAQgBDYCCCAEIAQ2AgwMBAsgAEEAQRkgA0EBdmsgA0EfRht0IQMgBSgCACEIA0AgCCIFKAIEQXhxIABGDQMgA0EddiEIIANBAXQhAyAFIAhBBHFqQRBqIgYoAgAiCA0ACyAGIAQ2AgAgBCAFNgIYIAQgBDYCDCAEIAQ2AggMAwsgBSgCCCIDIAI2AgwgBSACNgIIIAJBADYCGCACIAU2AgwgAiADNgIICyALQQhqIQMMBQsgBSgCCCIDIAQ2AgwgBSAENgIIIARBADYCGCAEIAU2AgwgBCADNgIIC0EAKAKU0ICAACIDIAJNDQBBACgCoNCAgAAiBCACaiIFIAMgAmsiA0EBcjYCBEEAIAM2ApTQgIAAQQAgBTYCoNCAgAAgBCACQQNyNgIEIARBCGohAwwDC0EAIQNBAEEwNgL404CAAAwCCwJAIAtFDQACQAJAIAggCCgCHCIFQQJ0QbjSgIAAaiIDKAIARw0AIAMgADYCACAADQFBACAHQX4gBXdxIgc2AozQgIAADAILIAtBEEEUIAsoAhAgCEYbaiAANgIAIABFDQELIAAgCzYCGAJAIAgoAhAiA0UNACAAIAM2AhAgAyAANgIYCyAIQRRqKAIAIgNFDQAgAEEUaiADNgIAIAMgADYCGAsCQAJAIARBD0sNACAIIAQgAmoiA0EDcjYCBCAIIANqIgMgAygCBEEBcjYCBAwBCyAIIAJqIgAgBEEBcjYCBCAIIAJBA3I2AgQgACAEaiAENgIAAkAgBEH/AUsNACAEQXhxQbDQgIAAaiEDAkACQEEAKAKI0ICAACIFQQEgBEEDdnQiBHENAEEAIAUgBHI2AojQgIAAIAMhBAwBCyADKAIIIQQLIAQgADYCDCADIAA2AgggACADNgIMIAAgBDYCCAwBC0EfIQMCQCAEQf///wdLDQAgBEEIdiIDIANBgP4/akEQdkEIcSIDdCIFIAVBgOAfakEQdkEEcSIFdCICIAJBgIAPakEQdkECcSICdEEPdiADIAVyIAJyayIDQQF0IAQgA0EVanZBAXFyQRxqIQMLIAAgAzYCHCAAQgA3AhAgA0ECdEG40oCAAGohBQJAIAdBASADdCICcQ0AIAUgADYCAEEAIAcgAnI2AozQgIAAIAAgBTYCGCAAIAA2AgggACAANgIMDAELIARBAEEZIANBAXZrIANBH0YbdCEDIAUoAgAhAgJAA0AgAiIFKAIEQXhxIARGDQEgA0EddiECIANBAXQhAyAFIAJBBHFqQRBqIgYoAgAiAg0ACyAGIAA2AgAgACAFNgIYIAAgADYCDCAAIAA2AggMAQsgBSgCCCIDIAA2AgwgBSAANgIIIABBADYCGCAAIAU2AgwgACADNgIICyAIQQhqIQMMAQsCQCAKRQ0AAkACQCAAIAAoAhwiBUECdEG40oCAAGoiAygCAEcNACADIAg2AgAgCA0BQQAgCUF+IAV3cTYCjNCAgAAMAgsgCkEQQRQgCigCECAARhtqIAg2AgAgCEUNAQsgCCAKNgIYAkAgACgCECIDRQ0AIAggAzYCECADIAg2AhgLIABBFGooAgAiA0UNACAIQRRqIAM2AgAgAyAINgIYCwJAAkAgBEEPSw0AIAAgBCACaiIDQQNyNgIEIAAgA2oiAyADKAIEQQFyNgIEDAELIAAgAmoiBSAEQQFyNgIEIAAgAkEDcjYCBCAFIARqIAQ2AgACQCAHRQ0AIAdBeHFBsNCAgABqIQJBACgCnNCAgAAhAwJAAkBBASAHQQN2dCIIIAZxDQBBACAIIAZyNgKI0ICAACACIQgMAQsgAigCCCEICyAIIAM2AgwgAiADNgIIIAMgAjYCDCADIAg2AggLQQAgBTYCnNCAgABBACAENgKQ0ICAAAsgAEEIaiEDCyABQRBqJICAgIAAIAMLCgAgABDJgICAAAviDQEHfwJAIABFDQAgAEF4aiIBIABBfGooAgAiAkF4cSIAaiEDAkAgAkEBcQ0AIAJBA3FFDQEgASABKAIAIgJrIgFBACgCmNCAgAAiBEkNASACIABqIQACQCABQQAoApzQgIAARg0AAkAgAkH/AUsNACABKAIIIgQgAkEDdiIFQQN0QbDQgIAAaiIGRhoCQCABKAIMIgIgBEcNAEEAQQAoAojQgIAAQX4gBXdxNgKI0ICAAAwDCyACIAZGGiACIAQ2AgggBCACNgIMDAILIAEoAhghBwJAAkAgASgCDCIGIAFGDQAgASgCCCICIARJGiAGIAI2AgggAiAGNgIMDAELAkAgAUEUaiICKAIAIgQNACABQRBqIgIoAgAiBA0AQQAhBgwBCwNAIAIhBSAEIgZBFGoiAigCACIEDQAgBkEQaiECIAYoAhAiBA0ACyAFQQA2AgALIAdFDQECQAJAIAEgASgCHCIEQQJ0QbjSgIAAaiICKAIARw0AIAIgBjYCACAGDQFBAEEAKAKM0ICAAEF+IAR3cTYCjNCAgAAMAwsgB0EQQRQgBygCECABRhtqIAY2AgAgBkUNAgsgBiAHNgIYAkAgASgCECICRQ0AIAYgAjYCECACIAY2AhgLIAEoAhQiAkUNASAGQRRqIAI2AgAgAiAGNgIYDAELIAMoAgQiAkEDcUEDRw0AIAMgAkF+cTYCBEEAIAA2ApDQgIAAIAEgAGogADYCACABIABBAXI2AgQPCyABIANPDQAgAygCBCICQQFxRQ0AAkACQCACQQJxDQACQCADQQAoAqDQgIAARw0AQQAgATYCoNCAgABBAEEAKAKU0ICAACAAaiIANgKU0ICAACABIABBAXI2AgQgAUEAKAKc0ICAAEcNA0EAQQA2ApDQgIAAQQBBADYCnNCAgAAPCwJAIANBACgCnNCAgABHDQBBACABNgKc0ICAAEEAQQAoApDQgIAAIABqIgA2ApDQgIAAIAEgAEEBcjYCBCABIABqIAA2AgAPCyACQXhxIABqIQACQAJAIAJB/wFLDQAgAygCCCIEIAJBA3YiBUEDdEGw0ICAAGoiBkYaAkAgAygCDCICIARHDQBBAEEAKAKI0ICAAEF+IAV3cTYCiNCAgAAMAgsgAiAGRhogAiAENgIIIAQgAjYCDAwBCyADKAIYIQcCQAJAIAMoAgwiBiADRg0AIAMoAggiAkEAKAKY0ICAAEkaIAYgAjYCCCACIAY2AgwMAQsCQCADQRRqIgIoAgAiBA0AIANBEGoiAigCACIEDQBBACEGDAELA0AgAiEFIAQiBkEUaiICKAIAIgQNACAGQRBqIQIgBigCECIEDQALIAVBADYCAAsgB0UNAAJAAkAgAyADKAIcIgRBAnRBuNKAgABqIgIoAgBHDQAgAiAGNgIAIAYNAUEAQQAoAozQgIAAQX4gBHdxNgKM0ICAAAwCCyAHQRBBFCAHKAIQIANGG2ogBjYCACAGRQ0BCyAGIAc2AhgCQCADKAIQIgJFDQAgBiACNgIQIAIgBjYCGAsgAygCFCICRQ0AIAZBFGogAjYCACACIAY2AhgLIAEgAGogADYCACABIABBAXI2AgQgAUEAKAKc0ICAAEcNAUEAIAA2ApDQgIAADwsgAyACQX5xNgIEIAEgAGogADYCACABIABBAXI2AgQLAkAgAEH/AUsNACAAQXhxQbDQgIAAaiECAkACQEEAKAKI0ICAACIEQQEgAEEDdnQiAHENAEEAIAQgAHI2AojQgIAAIAIhAAwBCyACKAIIIQALIAAgATYCDCACIAE2AgggASACNgIMIAEgADYCCA8LQR8hAgJAIABB////B0sNACAAQQh2IgIgAkGA/j9qQRB2QQhxIgJ0IgQgBEGA4B9qQRB2QQRxIgR0IgYgBkGAgA9qQRB2QQJxIgZ0QQ92IAIgBHIgBnJrIgJBAXQgACACQRVqdkEBcXJBHGohAgsgASACNgIcIAFCADcCECACQQJ0QbjSgIAAaiEEAkACQEEAKAKM0ICAACIGQQEgAnQiA3ENACAEIAE2AgBBACAGIANyNgKM0ICAACABIAQ2AhggASABNgIIIAEgATYCDAwBCyAAQQBBGSACQQF2ayACQR9GG3QhAiAEKAIAIQYCQANAIAYiBCgCBEF4cSAARg0BIAJBHXYhBiACQQF0IQIgBCAGQQRxakEQaiIDKAIAIgYNAAsgAyABNgIAIAEgBDYCGCABIAE2AgwgASABNgIIDAELIAQoAggiACABNgIMIAQgATYCCCABQQA2AhggASAENgIMIAEgADYCCAtBAEEAKAKo0ICAAEF/aiIBQX8gARs2AqjQgIAACwsEAAAAC04AAkAgAA0APwBBEHQPCwJAIABB//8DcQ0AIABBf0wNAAJAIABBEHZAACIAQX9HDQBBAEEwNgL404CAAEF/DwsgAEEQdA8LEMqAgIAAAAvyAgIDfwF+AkAgAkUNACAAIAE6AAAgAiAAaiIDQX9qIAE6AAAgAkEDSQ0AIAAgAToAAiAAIAE6AAEgA0F9aiABOgAAIANBfmogAToAACACQQdJDQAgACABOgADIANBfGogAToAACACQQlJDQAgAEEAIABrQQNxIgRqIgMgAUH/AXFBgYKECGwiATYCACADIAIgBGtBfHEiBGoiAkF8aiABNgIAIARBCUkNACADIAE2AgggAyABNgIEIAJBeGogATYCACACQXRqIAE2AgAgBEEZSQ0AIAMgATYCGCADIAE2AhQgAyABNgIQIAMgATYCDCACQXBqIAE2AgAgAkFsaiABNgIAIAJBaGogATYCACACQWRqIAE2AgAgBCADQQRxQRhyIgVrIgJBIEkNACABrUKBgICAEH4hBiADIAVqIQEDQCABIAY3AxggASAGNwMQIAEgBjcDCCABIAY3AwAgAUEgaiEBIAJBYGoiAkEfSw0ACwsgAAsLjkgBAEGACAuGSAEAAAACAAAAAwAAAAAAAAAAAAAABAAAAAUAAAAAAAAAAAAAAAYAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASW52YWxpZCBjaGFyIGluIHVybCBxdWVyeQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2JvZHkAQ29udGVudC1MZW5ndGggb3ZlcmZsb3cAQ2h1bmsgc2l6ZSBvdmVyZmxvdwBSZXNwb25zZSBvdmVyZmxvdwBJbnZhbGlkIG1ldGhvZCBmb3IgSFRUUC94LnggcmVxdWVzdABJbnZhbGlkIG1ldGhvZCBmb3IgUlRTUC94LnggcmVxdWVzdABFeHBlY3RlZCBTT1VSQ0UgbWV0aG9kIGZvciBJQ0UveC54IHJlcXVlc3QASW52YWxpZCBjaGFyIGluIHVybCBmcmFnbWVudCBzdGFydABFeHBlY3RlZCBkb3QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9zdGF0dXMASW52YWxpZCByZXNwb25zZSBzdGF0dXMASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucwBVc2VyIGNhbGxiYWNrIGVycm9yAGBvbl9yZXNldGAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2hlYWRlcmAgY2FsbGJhY2sgZXJyb3IAYG9uX21lc3NhZ2VfYmVnaW5gIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19leHRlbnNpb25fdmFsdWVgIGNhbGxiYWNrIGVycm9yAGBvbl9zdGF0dXNfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl92ZXJzaW9uX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fdXJsX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fbWV0aG9kX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX25hbWVgIGNhbGxiYWNrIGVycm9yAFVuZXhwZWN0ZWQgY2hhciBpbiB1cmwgc2VydmVyAEludmFsaWQgaGVhZGVyIHZhbHVlIGNoYXIASW52YWxpZCBoZWFkZXIgZmllbGQgY2hhcgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3ZlcnNpb24ASW52YWxpZCBtaW5vciB2ZXJzaW9uAEludmFsaWQgbWFqb3IgdmVyc2lvbgBFeHBlY3RlZCBzcGFjZSBhZnRlciB2ZXJzaW9uAEV4cGVjdGVkIENSTEYgYWZ0ZXIgdmVyc2lvbgBJbnZhbGlkIEhUVFAgdmVyc2lvbgBJbnZhbGlkIGhlYWRlciB0b2tlbgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3VybABJbnZhbGlkIGNoYXJhY3RlcnMgaW4gdXJsAFVuZXhwZWN0ZWQgc3RhcnQgY2hhciBpbiB1cmwARG91YmxlIEAgaW4gdXJsAEVtcHR5IENvbnRlbnQtTGVuZ3RoAEludmFsaWQgY2hhcmFjdGVyIGluIENvbnRlbnQtTGVuZ3RoAER1cGxpY2F0ZSBDb250ZW50LUxlbmd0aABJbnZhbGlkIGNoYXIgaW4gdXJsIHBhdGgAQ29udGVudC1MZW5ndGggY2FuJ3QgYmUgcHJlc2VudCB3aXRoIFRyYW5zZmVyLUVuY29kaW5nAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIHNpemUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfdmFsdWUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9jaHVua19leHRlbnNpb25fdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyB2YWx1ZQBNaXNzaW5nIGV4cGVjdGVkIExGIGFmdGVyIGhlYWRlciB2YWx1ZQBJbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AgaGVhZGVyIHZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGUgdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBxdW90ZWQgdmFsdWUAUGF1c2VkIGJ5IG9uX2hlYWRlcnNfY29tcGxldGUASW52YWxpZCBFT0Ygc3RhdGUAb25fcmVzZXQgcGF1c2UAb25fY2h1bmtfaGVhZGVyIHBhdXNlAG9uX21lc3NhZ2VfYmVnaW4gcGF1c2UAb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlIHBhdXNlAG9uX3N0YXR1c19jb21wbGV0ZSBwYXVzZQBvbl92ZXJzaW9uX2NvbXBsZXRlIHBhdXNlAG9uX3VybF9jb21wbGV0ZSBwYXVzZQBvbl9jaHVua19jb21wbGV0ZSBwYXVzZQBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGUgcGF1c2UAb25fbWVzc2FnZV9jb21wbGV0ZSBwYXVzZQBvbl9tZXRob2RfY29tcGxldGUgcGF1c2UAb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlIHBhdXNlAG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lIHBhdXNlAFVuZXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgc3RhcnQgbGluZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgbmFtZQBQYXVzZSBvbiBDT05ORUNUL1VwZ3JhZGUAUGF1c2Ugb24gUFJJL1VwZ3JhZGUARXhwZWN0ZWQgSFRUUC8yIENvbm5lY3Rpb24gUHJlZmFjZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX21ldGhvZABFeHBlY3RlZCBzcGFjZSBhZnRlciBtZXRob2QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfZmllbGQAUGF1c2VkAEludmFsaWQgd29yZCBlbmNvdW50ZXJlZABJbnZhbGlkIG1ldGhvZCBlbmNvdW50ZXJlZABVbmV4cGVjdGVkIGNoYXIgaW4gdXJsIHNjaGVtYQBSZXF1ZXN0IGhhcyBpbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AAU1dJVENIX1BST1hZAFVTRV9QUk9YWQBNS0FDVElWSVRZAFVOUFJPQ0VTU0FCTEVfRU5USVRZAENPUFkATU9WRURfUEVSTUFORU5UTFkAVE9PX0VBUkxZAE5PVElGWQBGQUlMRURfREVQRU5ERU5DWQBCQURfR0FURVdBWQBQTEFZAFBVVABDSEVDS09VVABHQVRFV0FZX1RJTUVPVVQAUkVRVUVTVF9USU1FT1VUAE5FVFdPUktfQ09OTkVDVF9USU1FT1VUAENPTk5FQ1RJT05fVElNRU9VVABMT0dJTl9USU1FT1VUAE5FVFdPUktfUkVBRF9USU1FT1VUAFBPU1QATUlTRElSRUNURURfUkVRVUVTVABDTElFTlRfQ0xPU0VEX1JFUVVFU1QAQ0xJRU5UX0NMT1NFRF9MT0FEX0JBTEFOQ0VEX1JFUVVFU1QAQkFEX1JFUVVFU1QASFRUUF9SRVFVRVNUX1NFTlRfVE9fSFRUUFNfUE9SVABSRVBPUlQASU1fQV9URUFQT1QAUkVTRVRfQ09OVEVOVABOT19DT05URU5UAFBBUlRJQUxfQ09OVEVOVABIUEVfSU5WQUxJRF9DT05TVEFOVABIUEVfQ0JfUkVTRVQAR0VUAEhQRV9TVFJJQ1QAQ09ORkxJQ1QAVEVNUE9SQVJZX1JFRElSRUNUAFBFUk1BTkVOVF9SRURJUkVDVABDT05ORUNUAE1VTFRJX1NUQVRVUwBIUEVfSU5WQUxJRF9TVEFUVVMAVE9PX01BTllfUkVRVUVTVFMARUFSTFlfSElOVFMAVU5BVkFJTEFCTEVfRk9SX0xFR0FMX1JFQVNPTlMAT1BUSU9OUwBTV0lUQ0hJTkdfUFJPVE9DT0xTAFZBUklBTlRfQUxTT19ORUdPVElBVEVTAE1VTFRJUExFX0NIT0lDRVMASU5URVJOQUxfU0VSVkVSX0VSUk9SAFdFQl9TRVJWRVJfVU5LTk9XTl9FUlJPUgBSQUlMR1VOX0VSUk9SAElERU5USVRZX1BST1ZJREVSX0FVVEhFTlRJQ0FUSU9OX0VSUk9SAFNTTF9DRVJUSUZJQ0FURV9FUlJPUgBJTlZBTElEX1hfRk9SV0FSREVEX0ZPUgBTRVRfUEFSQU1FVEVSAEdFVF9QQVJBTUVURVIASFBFX1VTRVIAU0VFX09USEVSAEhQRV9DQl9DSFVOS19IRUFERVIATUtDQUxFTkRBUgBTRVRVUABXRUJfU0VSVkVSX0lTX0RPV04AVEVBUkRPV04ASFBFX0NMT1NFRF9DT05ORUNUSU9OAEhFVVJJU1RJQ19FWFBJUkFUSU9OAERJU0NPTk5FQ1RFRF9PUEVSQVRJT04ATk9OX0FVVEhPUklUQVRJVkVfSU5GT1JNQVRJT04ASFBFX0lOVkFMSURfVkVSU0lPTgBIUEVfQ0JfTUVTU0FHRV9CRUdJTgBTSVRFX0lTX0ZST1pFTgBIUEVfSU5WQUxJRF9IRUFERVJfVE9LRU4ASU5WQUxJRF9UT0tFTgBGT1JCSURERU4ARU5IQU5DRV9ZT1VSX0NBTE0ASFBFX0lOVkFMSURfVVJMAEJMT0NLRURfQllfUEFSRU5UQUxfQ09OVFJPTABNS0NPTABBQ0wASFBFX0lOVEVSTkFMAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0VfVU5PRkZJQ0lBTABIUEVfT0sAVU5MSU5LAFVOTE9DSwBQUkkAUkVUUllfV0lUSABIUEVfSU5WQUxJRF9DT05URU5UX0xFTkdUSABIUEVfVU5FWFBFQ1RFRF9DT05URU5UX0xFTkdUSABGTFVTSABQUk9QUEFUQ0gATS1TRUFSQ0gAVVJJX1RPT19MT05HAFBST0NFU1NJTkcATUlTQ0VMTEFORU9VU19QRVJTSVNURU5UX1dBUk5JTkcATUlTQ0VMTEFORU9VU19XQVJOSU5HAEhQRV9JTlZBTElEX1RSQU5TRkVSX0VOQ09ESU5HAEV4cGVjdGVkIENSTEYASFBFX0lOVkFMSURfQ0hVTktfU0laRQBNT1ZFAENPTlRJTlVFAEhQRV9DQl9TVEFUVVNfQ09NUExFVEUASFBFX0NCX0hFQURFUlNfQ09NUExFVEUASFBFX0NCX1ZFUlNJT05fQ09NUExFVEUASFBFX0NCX1VSTF9DT01QTEVURQBIUEVfQ0JfQ0hVTktfQ09NUExFVEUASFBFX0NCX0hFQURFUl9WQUxVRV9DT01QTEVURQBIUEVfQ0JfQ0hVTktfRVhURU5TSU9OX1ZBTFVFX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19FWFRFTlNJT05fTkFNRV9DT01QTEVURQBIUEVfQ0JfTUVTU0FHRV9DT01QTEVURQBIUEVfQ0JfTUVUSE9EX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJfRklFTERfQ09NUExFVEUAREVMRVRFAEhQRV9JTlZBTElEX0VPRl9TVEFURQBJTlZBTElEX1NTTF9DRVJUSUZJQ0FURQBQQVVTRQBOT19SRVNQT05TRQBVTlNVUFBPUlRFRF9NRURJQV9UWVBFAEdPTkUATk9UX0FDQ0VQVEFCTEUAU0VSVklDRV9VTkFWQUlMQUJMRQBSQU5HRV9OT1RfU0FUSVNGSUFCTEUAT1JJR0lOX0lTX1VOUkVBQ0hBQkxFAFJFU1BPTlNFX0lTX1NUQUxFAFBVUkdFAE1FUkdFAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0UAUkVRVUVTVF9IRUFERVJfVE9PX0xBUkdFAFBBWUxPQURfVE9PX0xBUkdFAElOU1VGRklDSUVOVF9TVE9SQUdFAEhQRV9QQVVTRURfVVBHUkFERQBIUEVfUEFVU0VEX0gyX1VQR1JBREUAU09VUkNFAEFOTk9VTkNFAFRSQUNFAEhQRV9VTkVYUEVDVEVEX1NQQUNFAERFU0NSSUJFAFVOU1VCU0NSSUJFAFJFQ09SRABIUEVfSU5WQUxJRF9NRVRIT0QATk9UX0ZPVU5EAFBST1BGSU5EAFVOQklORABSRUJJTkQAVU5BVVRIT1JJWkVEAE1FVEhPRF9OT1RfQUxMT1dFRABIVFRQX1ZFUlNJT05fTk9UX1NVUFBPUlRFRABBTFJFQURZX1JFUE9SVEVEAEFDQ0VQVEVEAE5PVF9JTVBMRU1FTlRFRABMT09QX0RFVEVDVEVEAEhQRV9DUl9FWFBFQ1RFRABIUEVfTEZfRVhQRUNURUQAQ1JFQVRFRABJTV9VU0VEAEhQRV9QQVVTRUQAVElNRU9VVF9PQ0NVUkVEAFBBWU1FTlRfUkVRVUlSRUQAUFJFQ09ORElUSU9OX1JFUVVJUkVEAFBST1hZX0FVVEhFTlRJQ0FUSU9OX1JFUVVJUkVEAE5FVFdPUktfQVVUSEVOVElDQVRJT05fUkVRVUlSRUQATEVOR1RIX1JFUVVJUkVEAFNTTF9DRVJUSUZJQ0FURV9SRVFVSVJFRABVUEdSQURFX1JFUVVJUkVEAFBBR0VfRVhQSVJFRABQUkVDT05ESVRJT05fRkFJTEVEAEVYUEVDVEFUSU9OX0ZBSUxFRABSRVZBTElEQVRJT05fRkFJTEVEAFNTTF9IQU5EU0hBS0VfRkFJTEVEAExPQ0tFRABUUkFOU0ZPUk1BVElPTl9BUFBMSUVEAE5PVF9NT0RJRklFRABOT1RfRVhURU5ERUQAQkFORFdJRFRIX0xJTUlUX0VYQ0VFREVEAFNJVEVfSVNfT1ZFUkxPQURFRABIRUFEAEV4cGVjdGVkIEhUVFAvAABeEwAAJhMAADAQAADwFwAAnRMAABUSAAA5FwAA8BIAAAoQAAB1EgAArRIAAIITAABPFAAAfxAAAKAVAAAjFAAAiRIAAIsUAABNFQAA1BEAAM8UAAAQGAAAyRYAANwWAADBEQAA4BcAALsUAAB0FAAAfBUAAOUUAAAIFwAAHxAAAGUVAACjFAAAKBUAAAIVAACZFQAALBAAAIsZAABPDwAA1A4AAGoQAADOEAAAAhcAAIkOAABuEwAAHBMAAGYUAABWFwAAwRMAAM0TAABsEwAAaBcAAGYXAABfFwAAIhMAAM4PAABpDgAA2A4AAGMWAADLEwAAqg4AACgXAAAmFwAAxRMAAF0WAADoEQAAZxMAAGUTAADyFgAAcxMAAB0XAAD5FgAA8xEAAM8OAADOFQAADBIAALMRAAClEQAAYRAAADIXAAC7EwAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgMCAgICAgAAAgIAAgIAAgICAgICAgICAgAEAAAAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAAIAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAgICAgIAAAICAAICAAICAgICAgICAgIAAwAEAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgACAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsb3NlZWVwLWFsaXZlAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEBAQEBAQEBAgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFjaHVua2VkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQABAQEBAQAAAQEAAQEAAQEBAQEBAQEBAQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGVjdGlvbmVudC1sZW5ndGhvbnJveHktY29ubmVjdGlvbgAAAAAAAAAAAAAAAAAAAHJhbnNmZXItZW5jb2RpbmdwZ3JhZGUNCg0KDQpTTQ0KDQpUVFAvQ0UvVFNQLwAAAAAAAAAAAAAAAAECAAEDAAAAAAAAAAAAAAAAAAAAAAAABAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAABAgABAwAAAAAAAAAAAAAAAAAAAAAAAAQBAQUBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAQAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAABAAACAAAAAAAAAAAAAAAAAAAAAAAAAwQAAAQEBAQEBAQEBAQEBQQEBAQEBAQEBAQEBAAEAAYHBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQABAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAEAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAgAAAAACAAAAAAAAAAAAAAAAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5PVU5DRUVDS09VVE5FQ1RFVEVDUklCRUxVU0hFVEVBRFNFQVJDSFJHRUNUSVZJVFlMRU5EQVJWRU9USUZZUFRJT05TQ0hTRUFZU1RBVENIR0VPUkRJUkVDVE9SVFJDSFBBUkFNRVRFUlVSQ0VCU0NSSUJFQVJET1dOQUNFSU5ETktDS1VCU0NSSUJFSFRUUC9BRFRQLw==' - - -/***/ }), - -/***/ 172: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.enumToMap = void 0; -function enumToMap(obj) { - const res = {}; - Object.keys(obj).forEach((key) => { - const value = obj[key]; - if (typeof value === 'number') { - res[key] = value; - } - }); - return res; -} -exports.enumToMap = enumToMap; -//# sourceMappingURL=utils.js.map - -/***/ }), - -/***/ 7501: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { kClients } = __nccwpck_require__(6443) -const Agent = __nccwpck_require__(9965) -const { - kAgent, - kMockAgentSet, - kMockAgentGet, - kDispatches, - kIsMockActive, - kNetConnect, - kGetNetConnect, - kOptions, - kFactory -} = __nccwpck_require__(1117) -const MockClient = __nccwpck_require__(7365) -const MockPool = __nccwpck_require__(4004) -const { matchValue, buildMockOptions } = __nccwpck_require__(3397) -const { InvalidArgumentError, UndiciError } = __nccwpck_require__(8707) -const Dispatcher = __nccwpck_require__(992) -const Pluralizer = __nccwpck_require__(1529) -const PendingInterceptorsFormatter = __nccwpck_require__(6142) - -class FakeWeakRef { - constructor (value) { - this.value = value - } - - deref () { - return this.value - } -} - -class MockAgent extends Dispatcher { - constructor (opts) { - super(opts) - - this[kNetConnect] = true - this[kIsMockActive] = true - - // Instantiate Agent and encapsulate - if ((opts && opts.agent && typeof opts.agent.dispatch !== 'function')) { - throw new InvalidArgumentError('Argument opts.agent must implement Agent') - } - const agent = opts && opts.agent ? opts.agent : new Agent(opts) - this[kAgent] = agent - - this[kClients] = agent[kClients] - this[kOptions] = buildMockOptions(opts) - } - - get (origin) { - let dispatcher = this[kMockAgentGet](origin) - - if (!dispatcher) { - dispatcher = this[kFactory](origin) - this[kMockAgentSet](origin, dispatcher) - } - return dispatcher - } - - dispatch (opts, handler) { - // Call MockAgent.get to perform additional setup before dispatching as normal - this.get(opts.origin) - return this[kAgent].dispatch(opts, handler) - } - - async close () { - await this[kAgent].close() - this[kClients].clear() - } - - deactivate () { - this[kIsMockActive] = false - } - - activate () { - this[kIsMockActive] = true - } - - enableNetConnect (matcher) { - if (typeof matcher === 'string' || typeof matcher === 'function' || matcher instanceof RegExp) { - if (Array.isArray(this[kNetConnect])) { - this[kNetConnect].push(matcher) - } else { - this[kNetConnect] = [matcher] - } - } else if (typeof matcher === 'undefined') { - this[kNetConnect] = true - } else { - throw new InvalidArgumentError('Unsupported matcher. Must be one of String|Function|RegExp.') - } - } - - disableNetConnect () { - this[kNetConnect] = false - } - - // This is required to bypass issues caused by using global symbols - see: - // https://github.com/nodejs/undici/issues/1447 - get isMockActive () { - return this[kIsMockActive] - } - - [kMockAgentSet] (origin, dispatcher) { - this[kClients].set(origin, new FakeWeakRef(dispatcher)) - } - - [kFactory] (origin) { - const mockOptions = Object.assign({ agent: this }, this[kOptions]) - return this[kOptions] && this[kOptions].connections === 1 - ? new MockClient(origin, mockOptions) - : new MockPool(origin, mockOptions) - } - - [kMockAgentGet] (origin) { - // First check if we can immediately find it - const ref = this[kClients].get(origin) - if (ref) { - return ref.deref() - } - - // If the origin is not a string create a dummy parent pool and return to user - if (typeof origin !== 'string') { - const dispatcher = this[kFactory]('http://localhost:9999') - this[kMockAgentSet](origin, dispatcher) - return dispatcher - } - - // If we match, create a pool and assign the same dispatches - for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) { - const nonExplicitDispatcher = nonExplicitRef.deref() - if (nonExplicitDispatcher && typeof keyMatcher !== 'string' && matchValue(keyMatcher, origin)) { - const dispatcher = this[kFactory](origin) - this[kMockAgentSet](origin, dispatcher) - dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches] - return dispatcher - } - } - } - - [kGetNetConnect] () { - return this[kNetConnect] - } - - pendingInterceptors () { - const mockAgentClients = this[kClients] - - return Array.from(mockAgentClients.entries()) - .flatMap(([origin, scope]) => scope.deref()[kDispatches].map(dispatch => ({ ...dispatch, origin }))) - .filter(({ pending }) => pending) - } - - assertNoPendingInterceptors ({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) { - const pending = this.pendingInterceptors() - - if (pending.length === 0) { - return - } - - const pluralizer = new Pluralizer('interceptor', 'interceptors').pluralize(pending.length) - - throw new UndiciError(` -${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending: - -${pendingInterceptorsFormatter.format(pending)} -`.trim()) - } -} - -module.exports = MockAgent - - -/***/ }), - -/***/ 7365: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { promisify } = __nccwpck_require__(9023) -const Client = __nccwpck_require__(6197) -const { buildMockDispatch } = __nccwpck_require__(3397) -const { - kDispatches, - kMockAgent, - kClose, - kOriginalClose, - kOrigin, - kOriginalDispatch, - kConnected -} = __nccwpck_require__(1117) -const { MockInterceptor } = __nccwpck_require__(1511) -const Symbols = __nccwpck_require__(6443) -const { InvalidArgumentError } = __nccwpck_require__(8707) - -/** - * MockClient provides an API that extends the Client to influence the mockDispatches. - */ -class MockClient extends Client { - constructor (origin, opts) { - super(origin, opts) - - if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') { - throw new InvalidArgumentError('Argument opts.agent must implement Agent') - } - - this[kMockAgent] = opts.agent - this[kOrigin] = origin - this[kDispatches] = [] - this[kConnected] = 1 - this[kOriginalDispatch] = this.dispatch - this[kOriginalClose] = this.close.bind(this) - - this.dispatch = buildMockDispatch.call(this) - this.close = this[kClose] - } - - get [Symbols.kConnected] () { - return this[kConnected] - } - - /** - * Sets up the base interceptor for mocking replies from undici. - */ - intercept (opts) { - return new MockInterceptor(opts, this[kDispatches]) - } - - async [kClose] () { - await promisify(this[kOriginalClose])() - this[kConnected] = 0 - this[kMockAgent][Symbols.kClients].delete(this[kOrigin]) - } -} - -module.exports = MockClient - - -/***/ }), - -/***/ 2429: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { UndiciError } = __nccwpck_require__(8707) - -class MockNotMatchedError extends UndiciError { - constructor (message) { - super(message) - Error.captureStackTrace(this, MockNotMatchedError) - this.name = 'MockNotMatchedError' - this.message = message || 'The request does not match any registered mock dispatches' - this.code = 'UND_MOCK_ERR_MOCK_NOT_MATCHED' - } -} - -module.exports = { - MockNotMatchedError -} - - -/***/ }), - -/***/ 1511: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { getResponseData, buildKey, addMockDispatch } = __nccwpck_require__(3397) -const { - kDispatches, - kDispatchKey, - kDefaultHeaders, - kDefaultTrailers, - kContentLength, - kMockDispatch -} = __nccwpck_require__(1117) -const { InvalidArgumentError } = __nccwpck_require__(8707) -const { buildURL } = __nccwpck_require__(3440) - -/** - * Defines the scope API for an interceptor reply - */ -class MockScope { - constructor (mockDispatch) { - this[kMockDispatch] = mockDispatch - } - - /** - * Delay a reply by a set amount in ms. - */ - delay (waitInMs) { - if (typeof waitInMs !== 'number' || !Number.isInteger(waitInMs) || waitInMs <= 0) { - throw new InvalidArgumentError('waitInMs must be a valid integer > 0') - } - - this[kMockDispatch].delay = waitInMs - return this - } - - /** - * For a defined reply, never mark as consumed. - */ - persist () { - this[kMockDispatch].persist = true - return this - } - - /** - * Allow one to define a reply for a set amount of matching requests. - */ - times (repeatTimes) { - if (typeof repeatTimes !== 'number' || !Number.isInteger(repeatTimes) || repeatTimes <= 0) { - throw new InvalidArgumentError('repeatTimes must be a valid integer > 0') - } - - this[kMockDispatch].times = repeatTimes - return this - } -} - -/** - * Defines an interceptor for a Mock - */ -class MockInterceptor { - constructor (opts, mockDispatches) { - if (typeof opts !== 'object') { - throw new InvalidArgumentError('opts must be an object') - } - if (typeof opts.path === 'undefined') { - throw new InvalidArgumentError('opts.path must be defined') - } - if (typeof opts.method === 'undefined') { - opts.method = 'GET' - } - // See https://github.com/nodejs/undici/issues/1245 - // As per RFC 3986, clients are not supposed to send URI - // fragments to servers when they retrieve a document, - if (typeof opts.path === 'string') { - if (opts.query) { - opts.path = buildURL(opts.path, opts.query) - } else { - // Matches https://github.com/nodejs/undici/blob/main/lib/fetch/index.js#L1811 - const parsedURL = new URL(opts.path, 'data://') - opts.path = parsedURL.pathname + parsedURL.search - } - } - if (typeof opts.method === 'string') { - opts.method = opts.method.toUpperCase() - } - - this[kDispatchKey] = buildKey(opts) - this[kDispatches] = mockDispatches - this[kDefaultHeaders] = {} - this[kDefaultTrailers] = {} - this[kContentLength] = false - } - - createMockScopeDispatchData (statusCode, data, responseOptions = {}) { - const responseData = getResponseData(data) - const contentLength = this[kContentLength] ? { 'content-length': responseData.length } : {} - const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers } - const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers } - - return { statusCode, data, headers, trailers } - } - - validateReplyParameters (statusCode, data, responseOptions) { - if (typeof statusCode === 'undefined') { - throw new InvalidArgumentError('statusCode must be defined') - } - if (typeof data === 'undefined') { - throw new InvalidArgumentError('data must be defined') - } - if (typeof responseOptions !== 'object') { - throw new InvalidArgumentError('responseOptions must be an object') - } - } - - /** - * Mock an undici request with a defined reply. - */ - reply (replyData) { - // Values of reply aren't available right now as they - // can only be available when the reply callback is invoked. - if (typeof replyData === 'function') { - // We'll first wrap the provided callback in another function, - // this function will properly resolve the data from the callback - // when invoked. - const wrappedDefaultsCallback = (opts) => { - // Our reply options callback contains the parameter for statusCode, data and options. - const resolvedData = replyData(opts) - - // Check if it is in the right format - if (typeof resolvedData !== 'object') { - throw new InvalidArgumentError('reply options callback must return an object') - } - - const { statusCode, data = '', responseOptions = {} } = resolvedData - this.validateReplyParameters(statusCode, data, responseOptions) - // Since the values can be obtained immediately we return them - // from this higher order function that will be resolved later. - return { - ...this.createMockScopeDispatchData(statusCode, data, responseOptions) - } - } - - // Add usual dispatch data, but this time set the data parameter to function that will eventually provide data. - const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback) - return new MockScope(newMockDispatch) - } - - // We can have either one or three parameters, if we get here, - // we should have 1-3 parameters. So we spread the arguments of - // this function to obtain the parameters, since replyData will always - // just be the statusCode. - const [statusCode, data = '', responseOptions = {}] = [...arguments] - this.validateReplyParameters(statusCode, data, responseOptions) - - // Send in-already provided data like usual - const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions) - const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData) - return new MockScope(newMockDispatch) - } - - /** - * Mock an undici request with a defined error. - */ - replyWithError (error) { - if (typeof error === 'undefined') { - throw new InvalidArgumentError('error must be defined') - } - - const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error }) - return new MockScope(newMockDispatch) - } - - /** - * Set default reply headers on the interceptor for subsequent replies - */ - defaultReplyHeaders (headers) { - if (typeof headers === 'undefined') { - throw new InvalidArgumentError('headers must be defined') - } - - this[kDefaultHeaders] = headers - return this - } - - /** - * Set default reply trailers on the interceptor for subsequent replies - */ - defaultReplyTrailers (trailers) { - if (typeof trailers === 'undefined') { - throw new InvalidArgumentError('trailers must be defined') - } - - this[kDefaultTrailers] = trailers - return this - } - - /** - * Set reply content length header for replies on the interceptor - */ - replyContentLength () { - this[kContentLength] = true - return this - } -} - -module.exports.MockInterceptor = MockInterceptor -module.exports.MockScope = MockScope - - -/***/ }), - -/***/ 4004: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { promisify } = __nccwpck_require__(9023) -const Pool = __nccwpck_require__(5076) -const { buildMockDispatch } = __nccwpck_require__(3397) -const { - kDispatches, - kMockAgent, - kClose, - kOriginalClose, - kOrigin, - kOriginalDispatch, - kConnected -} = __nccwpck_require__(1117) -const { MockInterceptor } = __nccwpck_require__(1511) -const Symbols = __nccwpck_require__(6443) -const { InvalidArgumentError } = __nccwpck_require__(8707) - -/** - * MockPool provides an API that extends the Pool to influence the mockDispatches. - */ -class MockPool extends Pool { - constructor (origin, opts) { - super(origin, opts) - - if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') { - throw new InvalidArgumentError('Argument opts.agent must implement Agent') - } - - this[kMockAgent] = opts.agent - this[kOrigin] = origin - this[kDispatches] = [] - this[kConnected] = 1 - this[kOriginalDispatch] = this.dispatch - this[kOriginalClose] = this.close.bind(this) - - this.dispatch = buildMockDispatch.call(this) - this.close = this[kClose] - } - - get [Symbols.kConnected] () { - return this[kConnected] - } - - /** - * Sets up the base interceptor for mocking replies from undici. - */ - intercept (opts) { - return new MockInterceptor(opts, this[kDispatches]) - } - - async [kClose] () { - await promisify(this[kOriginalClose])() - this[kConnected] = 0 - this[kMockAgent][Symbols.kClients].delete(this[kOrigin]) - } -} - -module.exports = MockPool - - -/***/ }), - -/***/ 1117: -/***/ ((module) => { - -"use strict"; - - -module.exports = { - kAgent: Symbol('agent'), - kOptions: Symbol('options'), - kFactory: Symbol('factory'), - kDispatches: Symbol('dispatches'), - kDispatchKey: Symbol('dispatch key'), - kDefaultHeaders: Symbol('default headers'), - kDefaultTrailers: Symbol('default trailers'), - kContentLength: Symbol('content length'), - kMockAgent: Symbol('mock agent'), - kMockAgentSet: Symbol('mock agent set'), - kMockAgentGet: Symbol('mock agent get'), - kMockDispatch: Symbol('mock dispatch'), - kClose: Symbol('close'), - kOriginalClose: Symbol('original agent close'), - kOrigin: Symbol('origin'), - kIsMockActive: Symbol('is mock active'), - kNetConnect: Symbol('net connect'), - kGetNetConnect: Symbol('get net connect'), - kConnected: Symbol('connected') -} - - -/***/ }), - -/***/ 3397: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { MockNotMatchedError } = __nccwpck_require__(2429) -const { - kDispatches, - kMockAgent, - kOriginalDispatch, - kOrigin, - kGetNetConnect -} = __nccwpck_require__(1117) -const { buildURL, nop } = __nccwpck_require__(3440) -const { STATUS_CODES } = __nccwpck_require__(8611) -const { - types: { - isPromise - } -} = __nccwpck_require__(9023) - -function matchValue (match, value) { - if (typeof match === 'string') { - return match === value - } - if (match instanceof RegExp) { - return match.test(value) - } - if (typeof match === 'function') { - return match(value) === true - } - return false -} - -function lowerCaseEntries (headers) { - return Object.fromEntries( - Object.entries(headers).map(([headerName, headerValue]) => { - return [headerName.toLocaleLowerCase(), headerValue] - }) - ) -} - -/** - * @param {import('../../index').Headers|string[]|Record} headers - * @param {string} key - */ -function getHeaderByName (headers, key) { - if (Array.isArray(headers)) { - for (let i = 0; i < headers.length; i += 2) { - if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) { - return headers[i + 1] - } - } - - return undefined - } else if (typeof headers.get === 'function') { - return headers.get(key) - } else { - return lowerCaseEntries(headers)[key.toLocaleLowerCase()] - } -} - -/** @param {string[]} headers */ -function buildHeadersFromArray (headers) { // fetch HeadersList - const clone = headers.slice() - const entries = [] - for (let index = 0; index < clone.length; index += 2) { - entries.push([clone[index], clone[index + 1]]) - } - return Object.fromEntries(entries) -} - -function matchHeaders (mockDispatch, headers) { - if (typeof mockDispatch.headers === 'function') { - if (Array.isArray(headers)) { // fetch HeadersList - headers = buildHeadersFromArray(headers) - } - return mockDispatch.headers(headers ? lowerCaseEntries(headers) : {}) - } - if (typeof mockDispatch.headers === 'undefined') { - return true - } - if (typeof headers !== 'object' || typeof mockDispatch.headers !== 'object') { - return false - } - - for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch.headers)) { - const headerValue = getHeaderByName(headers, matchHeaderName) - - if (!matchValue(matchHeaderValue, headerValue)) { - return false - } - } - return true -} - -function safeUrl (path) { - if (typeof path !== 'string') { - return path - } - - const pathSegments = path.split('?') - - if (pathSegments.length !== 2) { - return path - } - - const qp = new URLSearchParams(pathSegments.pop()) - qp.sort() - return [...pathSegments, qp.toString()].join('?') -} - -function matchKey (mockDispatch, { path, method, body, headers }) { - const pathMatch = matchValue(mockDispatch.path, path) - const methodMatch = matchValue(mockDispatch.method, method) - const bodyMatch = typeof mockDispatch.body !== 'undefined' ? matchValue(mockDispatch.body, body) : true - const headersMatch = matchHeaders(mockDispatch, headers) - return pathMatch && methodMatch && bodyMatch && headersMatch -} - -function getResponseData (data) { - if (Buffer.isBuffer(data)) { - return data - } else if (typeof data === 'object') { - return JSON.stringify(data) - } else { - return data.toString() - } -} - -function getMockDispatch (mockDispatches, key) { - const basePath = key.query ? buildURL(key.path, key.query) : key.path - const resolvedPath = typeof basePath === 'string' ? safeUrl(basePath) : basePath - - // Match path - let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(safeUrl(path), resolvedPath)) - if (matchedMockDispatches.length === 0) { - throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`) - } - - // Match method - matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method)) - if (matchedMockDispatches.length === 0) { - throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`) - } - - // Match body - matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== 'undefined' ? matchValue(body, key.body) : true) - if (matchedMockDispatches.length === 0) { - throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`) - } - - // Match headers - matchedMockDispatches = matchedMockDispatches.filter((mockDispatch) => matchHeaders(mockDispatch, key.headers)) - if (matchedMockDispatches.length === 0) { - throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === 'object' ? JSON.stringify(key.headers) : key.headers}'`) - } - - return matchedMockDispatches[0] -} - -function addMockDispatch (mockDispatches, key, data) { - const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false } - const replyData = typeof data === 'function' ? { callback: data } : { ...data } - const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } } - mockDispatches.push(newMockDispatch) - return newMockDispatch -} - -function deleteMockDispatch (mockDispatches, key) { - const index = mockDispatches.findIndex(dispatch => { - if (!dispatch.consumed) { - return false - } - return matchKey(dispatch, key) - }) - if (index !== -1) { - mockDispatches.splice(index, 1) - } -} - -function buildKey (opts) { - const { path, method, body, headers, query } = opts - return { - path, - method, - body, - headers, - query - } -} - -function generateKeyValues (data) { - return Object.entries(data).reduce((keyValuePairs, [key, value]) => [ - ...keyValuePairs, - Buffer.from(`${key}`), - Array.isArray(value) ? value.map(x => Buffer.from(`${x}`)) : Buffer.from(`${value}`) - ], []) -} - -/** - * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status - * @param {number} statusCode - */ -function getStatusText (statusCode) { - return STATUS_CODES[statusCode] || 'unknown' -} - -async function getResponse (body) { - const buffers = [] - for await (const data of body) { - buffers.push(data) - } - return Buffer.concat(buffers).toString('utf8') -} - -/** - * Mock dispatch function used to simulate undici dispatches - */ -function mockDispatch (opts, handler) { - // Get mock dispatch from built key - const key = buildKey(opts) - const mockDispatch = getMockDispatch(this[kDispatches], key) - - mockDispatch.timesInvoked++ - - // Here's where we resolve a callback if a callback is present for the dispatch data. - if (mockDispatch.data.callback) { - mockDispatch.data = { ...mockDispatch.data, ...mockDispatch.data.callback(opts) } - } - - // Parse mockDispatch data - const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch - const { timesInvoked, times } = mockDispatch - - // If it's used up and not persistent, mark as consumed - mockDispatch.consumed = !persist && timesInvoked >= times - mockDispatch.pending = timesInvoked < times - - // If specified, trigger dispatch error - if (error !== null) { - deleteMockDispatch(this[kDispatches], key) - handler.onError(error) - return true - } - - // Handle the request with a delay if necessary - if (typeof delay === 'number' && delay > 0) { - setTimeout(() => { - handleReply(this[kDispatches]) - }, delay) - } else { - handleReply(this[kDispatches]) - } - - function handleReply (mockDispatches, _data = data) { - // fetch's HeadersList is a 1D string array - const optsHeaders = Array.isArray(opts.headers) - ? buildHeadersFromArray(opts.headers) - : opts.headers - const body = typeof _data === 'function' - ? _data({ ...opts, headers: optsHeaders }) - : _data - - // util.types.isPromise is likely needed for jest. - if (isPromise(body)) { - // If handleReply is asynchronous, throwing an error - // in the callback will reject the promise, rather than - // synchronously throw the error, which breaks some tests. - // Rather, we wait for the callback to resolve if it is a - // promise, and then re-run handleReply with the new body. - body.then((newData) => handleReply(mockDispatches, newData)) - return - } - - const responseData = getResponseData(body) - const responseHeaders = generateKeyValues(headers) - const responseTrailers = generateKeyValues(trailers) - - handler.abort = nop - handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode)) - handler.onData(Buffer.from(responseData)) - handler.onComplete(responseTrailers) - deleteMockDispatch(mockDispatches, key) - } - - function resume () {} - - return true -} - -function buildMockDispatch () { - const agent = this[kMockAgent] - const origin = this[kOrigin] - const originalDispatch = this[kOriginalDispatch] - - return function dispatch (opts, handler) { - if (agent.isMockActive) { - try { - mockDispatch.call(this, opts, handler) - } catch (error) { - if (error instanceof MockNotMatchedError) { - const netConnect = agent[kGetNetConnect]() - if (netConnect === false) { - throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`) - } - if (checkNetConnect(netConnect, origin)) { - originalDispatch.call(this, opts, handler) - } else { - throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`) - } - } else { - throw error - } - } - } else { - originalDispatch.call(this, opts, handler) - } - } -} - -function checkNetConnect (netConnect, origin) { - const url = new URL(origin) - if (netConnect === true) { - return true - } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) { - return true - } - return false -} - -function buildMockOptions (opts) { - if (opts) { - const { agent, ...mockOptions } = opts - return mockOptions - } -} - -module.exports = { - getResponseData, - getMockDispatch, - addMockDispatch, - deleteMockDispatch, - buildKey, - generateKeyValues, - matchValue, - getResponse, - getStatusText, - mockDispatch, - buildMockDispatch, - checkNetConnect, - buildMockOptions, - getHeaderByName -} - - -/***/ }), - -/***/ 6142: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { Transform } = __nccwpck_require__(2203) -const { Console } = __nccwpck_require__(4236) - -/** - * Gets the output of `console.table(…)` as a string. - */ -module.exports = class PendingInterceptorsFormatter { - constructor ({ disableColors } = {}) { - this.transform = new Transform({ - transform (chunk, _enc, cb) { - cb(null, chunk) - } - }) - - this.logger = new Console({ - stdout: this.transform, - inspectOptions: { - colors: !disableColors && !process.env.CI - } - }) - } - - format (pendingInterceptors) { - const withPrettyHeaders = pendingInterceptors.map( - ({ method, path, data: { statusCode }, persist, times, timesInvoked, origin }) => ({ - Method: method, - Origin: origin, - Path: path, - 'Status code': statusCode, - Persistent: persist ? '✅' : '❌', - Invocations: timesInvoked, - Remaining: persist ? Infinity : times - timesInvoked - })) - - this.logger.table(withPrettyHeaders) - return this.transform.read().toString() - } -} - - -/***/ }), - -/***/ 1529: -/***/ ((module) => { - -"use strict"; - - -const singulars = { - pronoun: 'it', - is: 'is', - was: 'was', - this: 'this' -} - -const plurals = { - pronoun: 'they', - is: 'are', - was: 'were', - this: 'these' -} - -module.exports = class Pluralizer { - constructor (singular, plural) { - this.singular = singular - this.plural = plural - } - - pluralize (count) { - const one = count === 1 - const keys = one ? singulars : plurals - const noun = one ? this.singular : this.plural - return { ...keys, count, noun } - } -} - - -/***/ }), - -/***/ 4869: -/***/ ((module) => { - -"use strict"; -/* eslint-disable */ - - - -// Extracted from node/lib/internal/fixed_queue.js - -// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two. -const kSize = 2048; -const kMask = kSize - 1; - -// The FixedQueue is implemented as a singly-linked list of fixed-size -// circular buffers. It looks something like this: -// -// head tail -// | | -// v v -// +-----------+ <-----\ +-----------+ <------\ +-----------+ -// | [null] | \----- | next | \------- | next | -// +-----------+ +-----------+ +-----------+ -// | item | <-- bottom | item | <-- bottom | [empty] | -// | item | | item | | [empty] | -// | item | | item | | [empty] | -// | item | | item | | [empty] | -// | item | | item | bottom --> | item | -// | item | | item | | item | -// | ... | | ... | | ... | -// | item | | item | | item | -// | item | | item | | item | -// | [empty] | <-- top | item | | item | -// | [empty] | | item | | item | -// | [empty] | | [empty] | <-- top top --> | [empty] | -// +-----------+ +-----------+ +-----------+ -// -// Or, if there is only one circular buffer, it looks something -// like either of these: -// -// head tail head tail -// | | | | -// v v v v -// +-----------+ +-----------+ -// | [null] | | [null] | -// +-----------+ +-----------+ -// | [empty] | | item | -// | [empty] | | item | -// | item | <-- bottom top --> | [empty] | -// | item | | [empty] | -// | [empty] | <-- top bottom --> | item | -// | [empty] | | item | -// +-----------+ +-----------+ -// -// Adding a value means moving `top` forward by one, removing means -// moving `bottom` forward by one. After reaching the end, the queue -// wraps around. -// -// When `top === bottom` the current queue is empty and when -// `top + 1 === bottom` it's full. This wastes a single space of storage -// but allows much quicker checks. - -class FixedCircularBuffer { - constructor() { - this.bottom = 0; - this.top = 0; - this.list = new Array(kSize); - this.next = null; - } - - isEmpty() { - return this.top === this.bottom; - } - - isFull() { - return ((this.top + 1) & kMask) === this.bottom; - } - - push(data) { - this.list[this.top] = data; - this.top = (this.top + 1) & kMask; - } - - shift() { - const nextItem = this.list[this.bottom]; - if (nextItem === undefined) - return null; - this.list[this.bottom] = undefined; - this.bottom = (this.bottom + 1) & kMask; - return nextItem; - } -} - -module.exports = class FixedQueue { - constructor() { - this.head = this.tail = new FixedCircularBuffer(); - } - - isEmpty() { - return this.head.isEmpty(); - } - - push(data) { - if (this.head.isFull()) { - // Head is full: Creates a new queue, sets the old queue's `.next` to it, - // and sets it as the new main queue. - this.head = this.head.next = new FixedCircularBuffer(); - } - this.head.push(data); - } - - shift() { - const tail = this.tail; - const next = tail.shift(); - if (tail.isEmpty() && tail.next !== null) { - // If there is another queue, it forms the new tail. - this.tail = tail.next; - } - return next; - } -}; - - -/***/ }), - -/***/ 8640: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const DispatcherBase = __nccwpck_require__(1) -const FixedQueue = __nccwpck_require__(4869) -const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = __nccwpck_require__(6443) -const PoolStats = __nccwpck_require__(4622) - -const kClients = Symbol('clients') -const kNeedDrain = Symbol('needDrain') -const kQueue = Symbol('queue') -const kClosedResolve = Symbol('closed resolve') -const kOnDrain = Symbol('onDrain') -const kOnConnect = Symbol('onConnect') -const kOnDisconnect = Symbol('onDisconnect') -const kOnConnectionError = Symbol('onConnectionError') -const kGetDispatcher = Symbol('get dispatcher') -const kAddClient = Symbol('add client') -const kRemoveClient = Symbol('remove client') -const kStats = Symbol('stats') - -class PoolBase extends DispatcherBase { - constructor () { - super() - - this[kQueue] = new FixedQueue() - this[kClients] = [] - this[kQueued] = 0 - - const pool = this - - this[kOnDrain] = function onDrain (origin, targets) { - const queue = pool[kQueue] - - let needDrain = false - - while (!needDrain) { - const item = queue.shift() - if (!item) { - break - } - pool[kQueued]-- - needDrain = !this.dispatch(item.opts, item.handler) - } - - this[kNeedDrain] = needDrain - - if (!this[kNeedDrain] && pool[kNeedDrain]) { - pool[kNeedDrain] = false - pool.emit('drain', origin, [pool, ...targets]) - } - - if (pool[kClosedResolve] && queue.isEmpty()) { - Promise - .all(pool[kClients].map(c => c.close())) - .then(pool[kClosedResolve]) - } - } - - this[kOnConnect] = (origin, targets) => { - pool.emit('connect', origin, [pool, ...targets]) - } - - this[kOnDisconnect] = (origin, targets, err) => { - pool.emit('disconnect', origin, [pool, ...targets], err) - } - - this[kOnConnectionError] = (origin, targets, err) => { - pool.emit('connectionError', origin, [pool, ...targets], err) - } - - this[kStats] = new PoolStats(this) - } - - get [kBusy] () { - return this[kNeedDrain] - } - - get [kConnected] () { - return this[kClients].filter(client => client[kConnected]).length - } - - get [kFree] () { - return this[kClients].filter(client => client[kConnected] && !client[kNeedDrain]).length - } - - get [kPending] () { - let ret = this[kQueued] - for (const { [kPending]: pending } of this[kClients]) { - ret += pending - } - return ret - } - - get [kRunning] () { - let ret = 0 - for (const { [kRunning]: running } of this[kClients]) { - ret += running - } - return ret - } - - get [kSize] () { - let ret = this[kQueued] - for (const { [kSize]: size } of this[kClients]) { - ret += size - } - return ret - } - - get stats () { - return this[kStats] - } - - async [kClose] () { - if (this[kQueue].isEmpty()) { - return Promise.all(this[kClients].map(c => c.close())) - } else { - return new Promise((resolve) => { - this[kClosedResolve] = resolve - }) - } - } - - async [kDestroy] (err) { - while (true) { - const item = this[kQueue].shift() - if (!item) { - break - } - item.handler.onError(err) - } - - return Promise.all(this[kClients].map(c => c.destroy(err))) - } - - [kDispatch] (opts, handler) { - const dispatcher = this[kGetDispatcher]() - - if (!dispatcher) { - this[kNeedDrain] = true - this[kQueue].push({ opts, handler }) - this[kQueued]++ - } else if (!dispatcher.dispatch(opts, handler)) { - dispatcher[kNeedDrain] = true - this[kNeedDrain] = !this[kGetDispatcher]() - } - - return !this[kNeedDrain] - } - - [kAddClient] (client) { - client - .on('drain', this[kOnDrain]) - .on('connect', this[kOnConnect]) - .on('disconnect', this[kOnDisconnect]) - .on('connectionError', this[kOnConnectionError]) - - this[kClients].push(client) - - if (this[kNeedDrain]) { - process.nextTick(() => { - if (this[kNeedDrain]) { - this[kOnDrain](client[kUrl], [this, client]) - } - }) - } - - return this - } - - [kRemoveClient] (client) { - client.close(() => { - const idx = this[kClients].indexOf(client) - if (idx !== -1) { - this[kClients].splice(idx, 1) - } - }) - - this[kNeedDrain] = this[kClients].some(dispatcher => ( - !dispatcher[kNeedDrain] && - dispatcher.closed !== true && - dispatcher.destroyed !== true - )) - } -} - -module.exports = { - PoolBase, - kClients, - kNeedDrain, - kAddClient, - kRemoveClient, - kGetDispatcher -} - - -/***/ }), - -/***/ 4622: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = __nccwpck_require__(6443) -const kPool = Symbol('pool') - -class PoolStats { - constructor (pool) { - this[kPool] = pool - } - - get connected () { - return this[kPool][kConnected] - } - - get free () { - return this[kPool][kFree] - } - - get pending () { - return this[kPool][kPending] - } - - get queued () { - return this[kPool][kQueued] - } - - get running () { - return this[kPool][kRunning] - } - - get size () { - return this[kPool][kSize] - } -} - -module.exports = PoolStats - - -/***/ }), - -/***/ 5076: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { - PoolBase, - kClients, - kNeedDrain, - kAddClient, - kGetDispatcher -} = __nccwpck_require__(8640) -const Client = __nccwpck_require__(6197) -const { - InvalidArgumentError -} = __nccwpck_require__(8707) -const util = __nccwpck_require__(3440) -const { kUrl, kInterceptors } = __nccwpck_require__(6443) -const buildConnector = __nccwpck_require__(9136) - -const kOptions = Symbol('options') -const kConnections = Symbol('connections') -const kFactory = Symbol('factory') - -function defaultFactory (origin, opts) { - return new Client(origin, opts) -} - -class Pool extends PoolBase { - constructor (origin, { - connections, - factory = defaultFactory, - connect, - connectTimeout, - tls, - maxCachedSessions, - socketPath, - autoSelectFamily, - autoSelectFamilyAttemptTimeout, - allowH2, - ...options - } = {}) { - super() - - if (connections != null && (!Number.isFinite(connections) || connections < 0)) { - throw new InvalidArgumentError('invalid connections') - } - - if (typeof factory !== 'function') { - throw new InvalidArgumentError('factory must be a function.') - } - - if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') { - throw new InvalidArgumentError('connect must be a function or an object') - } - - if (typeof connect !== 'function') { - connect = buildConnector({ - ...tls, - maxCachedSessions, - allowH2, - socketPath, - timeout: connectTimeout, - ...(util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined), - ...connect - }) - } - - this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool) - ? options.interceptors.Pool - : [] - this[kConnections] = connections || null - this[kUrl] = util.parseOrigin(origin) - this[kOptions] = { ...util.deepClone(options), connect, allowH2 } - this[kOptions].interceptors = options.interceptors - ? { ...options.interceptors } - : undefined - this[kFactory] = factory - - this.on('connectionError', (origin, targets, error) => { - // If a connection error occurs, we remove the client from the pool, - // and emit a connectionError event. They will not be re-used. - // Fixes https://github.com/nodejs/undici/issues/3895 - for (const target of targets) { - // Do not use kRemoveClient here, as it will close the client, - // but the client cannot be closed in this state. - const idx = this[kClients].indexOf(target) - if (idx !== -1) { - this[kClients].splice(idx, 1) - } - } - }) - } - - [kGetDispatcher] () { - let dispatcher = this[kClients].find(dispatcher => !dispatcher[kNeedDrain]) - - if (dispatcher) { - return dispatcher - } - - if (!this[kConnections] || this[kClients].length < this[kConnections]) { - dispatcher = this[kFactory](this[kUrl], this[kOptions]) - this[kAddClient](dispatcher) - } - - return dispatcher - } -} - -module.exports = Pool - - -/***/ }), - -/***/ 2720: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { kProxy, kClose, kDestroy, kInterceptors } = __nccwpck_require__(6443) -const { URL } = __nccwpck_require__(7016) -const Agent = __nccwpck_require__(9965) -const Pool = __nccwpck_require__(5076) -const DispatcherBase = __nccwpck_require__(1) -const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(8707) -const buildConnector = __nccwpck_require__(9136) - -const kAgent = Symbol('proxy agent') -const kClient = Symbol('proxy client') -const kProxyHeaders = Symbol('proxy headers') -const kRequestTls = Symbol('request tls settings') -const kProxyTls = Symbol('proxy tls settings') -const kConnectEndpoint = Symbol('connect endpoint function') - -function defaultProtocolPort (protocol) { - return protocol === 'https:' ? 443 : 80 -} - -function buildProxyOptions (opts) { - if (typeof opts === 'string') { - opts = { uri: opts } - } - - if (!opts || !opts.uri) { - throw new InvalidArgumentError('Proxy opts.uri is mandatory') - } - - return { - uri: opts.uri, - protocol: opts.protocol || 'https' - } -} - -function defaultFactory (origin, opts) { - return new Pool(origin, opts) -} - -class ProxyAgent extends DispatcherBase { - constructor (opts) { - super(opts) - this[kProxy] = buildProxyOptions(opts) - this[kAgent] = new Agent(opts) - this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) - ? opts.interceptors.ProxyAgent - : [] - - if (typeof opts === 'string') { - opts = { uri: opts } - } - - if (!opts || !opts.uri) { - throw new InvalidArgumentError('Proxy opts.uri is mandatory') - } - - const { clientFactory = defaultFactory } = opts - - if (typeof clientFactory !== 'function') { - throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.') - } - - this[kRequestTls] = opts.requestTls - this[kProxyTls] = opts.proxyTls - this[kProxyHeaders] = opts.headers || {} - - const resolvedUrl = new URL(opts.uri) - const { origin, port, host, username, password } = resolvedUrl - - if (opts.auth && opts.token) { - throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token') - } else if (opts.auth) { - /* @deprecated in favour of opts.token */ - this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}` - } else if (opts.token) { - this[kProxyHeaders]['proxy-authorization'] = opts.token - } else if (username && password) { - this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}` - } - - const connect = buildConnector({ ...opts.proxyTls }) - this[kConnectEndpoint] = buildConnector({ ...opts.requestTls }) - this[kClient] = clientFactory(resolvedUrl, { connect }) - this[kAgent] = new Agent({ - ...opts, - connect: async (opts, callback) => { - let requestedHost = opts.host - if (!opts.port) { - requestedHost += `:${defaultProtocolPort(opts.protocol)}` - } - try { - const { socket, statusCode } = await this[kClient].connect({ - origin, - port, - path: requestedHost, - signal: opts.signal, - headers: { - ...this[kProxyHeaders], - host - } - }) - if (statusCode !== 200) { - socket.on('error', () => {}).destroy() - callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`)) - } - if (opts.protocol !== 'https:') { - callback(null, socket) - return - } - let servername - if (this[kRequestTls]) { - servername = this[kRequestTls].servername - } else { - servername = opts.servername - } - this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback) - } catch (err) { - callback(err) - } - } - }) - } - - dispatch (opts, handler) { - const { host } = new URL(opts.origin) - const headers = buildHeaders(opts.headers) - throwIfProxyAuthIsSent(headers) - return this[kAgent].dispatch( - { - ...opts, - headers: { - ...headers, - host - } - }, - handler - ) - } - - async [kClose] () { - await this[kAgent].close() - await this[kClient].close() - } - - async [kDestroy] () { - await this[kAgent].destroy() - await this[kClient].destroy() - } -} - -/** - * @param {string[] | Record} headers - * @returns {Record} - */ -function buildHeaders (headers) { - // When using undici.fetch, the headers list is stored - // as an array. - if (Array.isArray(headers)) { - /** @type {Record} */ - const headersPair = {} - - for (let i = 0; i < headers.length; i += 2) { - headersPair[headers[i]] = headers[i + 1] - } - - return headersPair - } - - return headers -} - -/** - * @param {Record} headers - * - * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers - * Nevertheless, it was changed and to avoid a security vulnerability by end users - * this check was created. - * It should be removed in the next major version for performance reasons - */ -function throwIfProxyAuthIsSent (headers) { - const existProxyAuth = headers && Object.keys(headers) - .find((key) => key.toLowerCase() === 'proxy-authorization') - if (existProxyAuth) { - throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor') - } -} - -module.exports = ProxyAgent - - -/***/ }), - -/***/ 8804: -/***/ ((module) => { - -"use strict"; - - -let fastNow = Date.now() -let fastNowTimeout - -const fastTimers = [] - -function onTimeout () { - fastNow = Date.now() - - let len = fastTimers.length - let idx = 0 - while (idx < len) { - const timer = fastTimers[idx] - - if (timer.state === 0) { - timer.state = fastNow + timer.delay - } else if (timer.state > 0 && fastNow >= timer.state) { - timer.state = -1 - timer.callback(timer.opaque) - } - - if (timer.state === -1) { - timer.state = -2 - if (idx !== len - 1) { - fastTimers[idx] = fastTimers.pop() - } else { - fastTimers.pop() - } - len -= 1 - } else { - idx += 1 - } - } - - if (fastTimers.length > 0) { - refreshTimeout() - } -} - -function refreshTimeout () { - if (fastNowTimeout && fastNowTimeout.refresh) { - fastNowTimeout.refresh() - } else { - clearTimeout(fastNowTimeout) - fastNowTimeout = setTimeout(onTimeout, 1e3) - if (fastNowTimeout.unref) { - fastNowTimeout.unref() - } - } -} - -class Timeout { - constructor (callback, delay, opaque) { - this.callback = callback - this.delay = delay - this.opaque = opaque - - // -2 not in timer list - // -1 in timer list but inactive - // 0 in timer list waiting for time - // > 0 in timer list waiting for time to expire - this.state = -2 - - this.refresh() - } - - refresh () { - if (this.state === -2) { - fastTimers.push(this) - if (!fastNowTimeout || fastTimers.length === 1) { - refreshTimeout() - } - } - - this.state = 0 - } - - clear () { - this.state = -1 - } -} - -module.exports = { - setTimeout (callback, delay, opaque) { - return delay < 1e3 - ? setTimeout(callback, delay, opaque) - : new Timeout(callback, delay, opaque) - }, - clearTimeout (timeout) { - if (timeout instanceof Timeout) { - timeout.clear() - } else { - clearTimeout(timeout) - } - } -} - - -/***/ }), - -/***/ 8550: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const diagnosticsChannel = __nccwpck_require__(1637) -const { uid, states } = __nccwpck_require__(8294) -const { - kReadyState, - kSentClose, - kByteParser, - kReceivedClose -} = __nccwpck_require__(2933) -const { fireEvent, failWebsocketConnection } = __nccwpck_require__(3574) -const { CloseEvent } = __nccwpck_require__(6255) -const { makeRequest } = __nccwpck_require__(5194) -const { fetching } = __nccwpck_require__(2315) -const { Headers } = __nccwpck_require__(6349) -const { getGlobalDispatcher } = __nccwpck_require__(2581) -const { kHeadersList } = __nccwpck_require__(6443) - -const channels = {} -channels.open = diagnosticsChannel.channel('undici:websocket:open') -channels.close = diagnosticsChannel.channel('undici:websocket:close') -channels.socketError = diagnosticsChannel.channel('undici:websocket:socket_error') - -/** @type {import('crypto')} */ -let crypto -try { - crypto = __nccwpck_require__(6982) -} catch { - -} - -/** - * @see https://websockets.spec.whatwg.org/#concept-websocket-establish - * @param {URL} url - * @param {string|string[]} protocols - * @param {import('./websocket').WebSocket} ws - * @param {(response: any) => void} onEstablish - * @param {Partial} options - */ -function establishWebSocketConnection (url, protocols, ws, onEstablish, options) { - // 1. Let requestURL be a copy of url, with its scheme set to "http", if url’s - // scheme is "ws", and to "https" otherwise. - const requestURL = url - - requestURL.protocol = url.protocol === 'ws:' ? 'http:' : 'https:' - - // 2. Let request be a new request, whose URL is requestURL, client is client, - // service-workers mode is "none", referrer is "no-referrer", mode is - // "websocket", credentials mode is "include", cache mode is "no-store" , - // and redirect mode is "error". - const request = makeRequest({ - urlList: [requestURL], - serviceWorkers: 'none', - referrer: 'no-referrer', - mode: 'websocket', - credentials: 'include', - cache: 'no-store', - redirect: 'error' - }) - - // Note: undici extension, allow setting custom headers. - if (options.headers) { - const headersList = new Headers(options.headers)[kHeadersList] - - request.headersList = headersList - } - - // 3. Append (`Upgrade`, `websocket`) to request’s header list. - // 4. Append (`Connection`, `Upgrade`) to request’s header list. - // Note: both of these are handled by undici currently. - // https://github.com/nodejs/undici/blob/68c269c4144c446f3f1220951338daef4a6b5ec4/lib/client.js#L1397 - - // 5. Let keyValue be a nonce consisting of a randomly selected - // 16-byte value that has been forgiving-base64-encoded and - // isomorphic encoded. - const keyValue = crypto.randomBytes(16).toString('base64') - - // 6. Append (`Sec-WebSocket-Key`, keyValue) to request’s - // header list. - request.headersList.append('sec-websocket-key', keyValue) - - // 7. Append (`Sec-WebSocket-Version`, `13`) to request’s - // header list. - request.headersList.append('sec-websocket-version', '13') - - // 8. For each protocol in protocols, combine - // (`Sec-WebSocket-Protocol`, protocol) in request’s header - // list. - for (const protocol of protocols) { - request.headersList.append('sec-websocket-protocol', protocol) - } - - // 9. Let permessageDeflate be a user-agent defined - // "permessage-deflate" extension header value. - // https://github.com/mozilla/gecko-dev/blob/ce78234f5e653a5d3916813ff990f053510227bc/netwerk/protocol/websocket/WebSocketChannel.cpp#L2673 - // TODO: enable once permessage-deflate is supported - const permessageDeflate = '' // 'permessage-deflate; 15' - - // 10. Append (`Sec-WebSocket-Extensions`, permessageDeflate) to - // request’s header list. - // request.headersList.append('sec-websocket-extensions', permessageDeflate) - - // 11. Fetch request with useParallelQueue set to true, and - // processResponse given response being these steps: - const controller = fetching({ - request, - useParallelQueue: true, - dispatcher: options.dispatcher ?? getGlobalDispatcher(), - processResponse (response) { - // 1. If response is a network error or its status is not 101, - // fail the WebSocket connection. - if (response.type === 'error' || response.status !== 101) { - failWebsocketConnection(ws, 'Received network error or non-101 status code.') - return - } - - // 2. If protocols is not the empty list and extracting header - // list values given `Sec-WebSocket-Protocol` and response’s - // header list results in null, failure, or the empty byte - // sequence, then fail the WebSocket connection. - if (protocols.length !== 0 && !response.headersList.get('Sec-WebSocket-Protocol')) { - failWebsocketConnection(ws, 'Server did not respond with sent protocols.') - return - } - - // 3. Follow the requirements stated step 2 to step 6, inclusive, - // of the last set of steps in section 4.1 of The WebSocket - // Protocol to validate response. This either results in fail - // the WebSocket connection or the WebSocket connection is - // established. - - // 2. If the response lacks an |Upgrade| header field or the |Upgrade| - // header field contains a value that is not an ASCII case- - // insensitive match for the value "websocket", the client MUST - // _Fail the WebSocket Connection_. - if (response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') { - failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".') - return - } - - // 3. If the response lacks a |Connection| header field or the - // |Connection| header field doesn't contain a token that is an - // ASCII case-insensitive match for the value "Upgrade", the client - // MUST _Fail the WebSocket Connection_. - if (response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') { - failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".') - return - } - - // 4. If the response lacks a |Sec-WebSocket-Accept| header field or - // the |Sec-WebSocket-Accept| contains a value other than the - // base64-encoded SHA-1 of the concatenation of the |Sec-WebSocket- - // Key| (as a string, not base64-decoded) with the string "258EAFA5- - // E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and - // trailing whitespace, the client MUST _Fail the WebSocket - // Connection_. - const secWSAccept = response.headersList.get('Sec-WebSocket-Accept') - const digest = crypto.createHash('sha1').update(keyValue + uid).digest('base64') - if (secWSAccept !== digest) { - failWebsocketConnection(ws, 'Incorrect hash received in Sec-WebSocket-Accept header.') - return - } - - // 5. If the response includes a |Sec-WebSocket-Extensions| header - // field and this header field indicates the use of an extension - // that was not present in the client's handshake (the server has - // indicated an extension not requested by the client), the client - // MUST _Fail the WebSocket Connection_. (The parsing of this - // header field to determine which extensions are requested is - // discussed in Section 9.1.) - const secExtension = response.headersList.get('Sec-WebSocket-Extensions') - - if (secExtension !== null && secExtension !== permessageDeflate) { - failWebsocketConnection(ws, 'Received different permessage-deflate than the one set.') - return - } - - // 6. If the response includes a |Sec-WebSocket-Protocol| header field - // and this header field indicates the use of a subprotocol that was - // not present in the client's handshake (the server has indicated a - // subprotocol not requested by the client), the client MUST _Fail - // the WebSocket Connection_. - const secProtocol = response.headersList.get('Sec-WebSocket-Protocol') - - if (secProtocol !== null && secProtocol !== request.headersList.get('Sec-WebSocket-Protocol')) { - failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.') - return - } - - response.socket.on('data', onSocketData) - response.socket.on('close', onSocketClose) - response.socket.on('error', onSocketError) - - if (channels.open.hasSubscribers) { - channels.open.publish({ - address: response.socket.address(), - protocol: secProtocol, - extensions: secExtension - }) - } - - onEstablish(response) - } - }) - - return controller -} - -/** - * @param {Buffer} chunk - */ -function onSocketData (chunk) { - if (!this.ws[kByteParser].write(chunk)) { - this.pause() - } -} - -/** - * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol - * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4 - */ -function onSocketClose () { - const { ws } = this - - // If the TCP connection was closed after the - // WebSocket closing handshake was completed, the WebSocket connection - // is said to have been closed _cleanly_. - const wasClean = ws[kSentClose] && ws[kReceivedClose] - - let code = 1005 - let reason = '' - - const result = ws[kByteParser].closingInfo - - if (result) { - code = result.code ?? 1005 - reason = result.reason - } else if (!ws[kSentClose]) { - // If _The WebSocket - // Connection is Closed_ and no Close control frame was received by the - // endpoint (such as could occur if the underlying transport connection - // is lost), _The WebSocket Connection Close Code_ is considered to be - // 1006. - code = 1006 - } - - // 1. Change the ready state to CLOSED (3). - ws[kReadyState] = states.CLOSED - - // 2. If the user agent was required to fail the WebSocket - // connection, or if the WebSocket connection was closed - // after being flagged as full, fire an event named error - // at the WebSocket object. - // TODO - - // 3. Fire an event named close at the WebSocket object, - // using CloseEvent, with the wasClean attribute - // initialized to true if the connection closed cleanly - // and false otherwise, the code attribute initialized to - // the WebSocket connection close code, and the reason - // attribute initialized to the result of applying UTF-8 - // decode without BOM to the WebSocket connection close - // reason. - fireEvent('close', ws, CloseEvent, { - wasClean, code, reason - }) - - if (channels.close.hasSubscribers) { - channels.close.publish({ - websocket: ws, - code, - reason - }) - } -} - -function onSocketError (error) { - const { ws } = this - - ws[kReadyState] = states.CLOSING - - if (channels.socketError.hasSubscribers) { - channels.socketError.publish(error) - } - - this.destroy() -} - -module.exports = { - establishWebSocketConnection -} - - -/***/ }), - -/***/ 8294: -/***/ ((module) => { - -"use strict"; - - -// This is a Globally Unique Identifier unique used -// to validate that the endpoint accepts websocket -// connections. -// See https://www.rfc-editor.org/rfc/rfc6455.html#section-1.3 -const uid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11' - -/** @type {PropertyDescriptor} */ -const staticPropertyDescriptors = { - enumerable: true, - writable: false, - configurable: false -} - -const states = { - CONNECTING: 0, - OPEN: 1, - CLOSING: 2, - CLOSED: 3 -} - -const opcodes = { - CONTINUATION: 0x0, - TEXT: 0x1, - BINARY: 0x2, - CLOSE: 0x8, - PING: 0x9, - PONG: 0xA -} - -const maxUnsigned16Bit = 2 ** 16 - 1 // 65535 - -const parserStates = { - INFO: 0, - PAYLOADLENGTH_16: 2, - PAYLOADLENGTH_64: 3, - READ_DATA: 4 -} - -const emptyBuffer = Buffer.allocUnsafe(0) - -module.exports = { - uid, - staticPropertyDescriptors, - states, - opcodes, - maxUnsigned16Bit, - parserStates, - emptyBuffer -} - - -/***/ }), - -/***/ 6255: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { webidl } = __nccwpck_require__(4222) -const { kEnumerableProperty } = __nccwpck_require__(3440) -const { MessagePort } = __nccwpck_require__(8167) - -/** - * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent - */ -class MessageEvent extends Event { - #eventInit - - constructor (type, eventInitDict = {}) { - webidl.argumentLengthCheck(arguments, 1, { header: 'MessageEvent constructor' }) - - type = webidl.converters.DOMString(type) - eventInitDict = webidl.converters.MessageEventInit(eventInitDict) - - super(type, eventInitDict) - - this.#eventInit = eventInitDict - } - - get data () { - webidl.brandCheck(this, MessageEvent) - - return this.#eventInit.data - } - - get origin () { - webidl.brandCheck(this, MessageEvent) - - return this.#eventInit.origin - } - - get lastEventId () { - webidl.brandCheck(this, MessageEvent) - - return this.#eventInit.lastEventId - } - - get source () { - webidl.brandCheck(this, MessageEvent) - - return this.#eventInit.source - } - - get ports () { - webidl.brandCheck(this, MessageEvent) - - if (!Object.isFrozen(this.#eventInit.ports)) { - Object.freeze(this.#eventInit.ports) - } - - return this.#eventInit.ports - } - - initMessageEvent ( - type, - bubbles = false, - cancelable = false, - data = null, - origin = '', - lastEventId = '', - source = null, - ports = [] - ) { - webidl.brandCheck(this, MessageEvent) - - webidl.argumentLengthCheck(arguments, 1, { header: 'MessageEvent.initMessageEvent' }) - - return new MessageEvent(type, { - bubbles, cancelable, data, origin, lastEventId, source, ports - }) - } -} - -/** - * @see https://websockets.spec.whatwg.org/#the-closeevent-interface - */ -class CloseEvent extends Event { - #eventInit - - constructor (type, eventInitDict = {}) { - webidl.argumentLengthCheck(arguments, 1, { header: 'CloseEvent constructor' }) - - type = webidl.converters.DOMString(type) - eventInitDict = webidl.converters.CloseEventInit(eventInitDict) - - super(type, eventInitDict) - - this.#eventInit = eventInitDict - } - - get wasClean () { - webidl.brandCheck(this, CloseEvent) - - return this.#eventInit.wasClean - } - - get code () { - webidl.brandCheck(this, CloseEvent) - - return this.#eventInit.code - } - - get reason () { - webidl.brandCheck(this, CloseEvent) - - return this.#eventInit.reason - } -} - -// https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface -class ErrorEvent extends Event { - #eventInit - - constructor (type, eventInitDict) { - webidl.argumentLengthCheck(arguments, 1, { header: 'ErrorEvent constructor' }) - - super(type, eventInitDict) - - type = webidl.converters.DOMString(type) - eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {}) - - this.#eventInit = eventInitDict - } - - get message () { - webidl.brandCheck(this, ErrorEvent) - - return this.#eventInit.message - } - - get filename () { - webidl.brandCheck(this, ErrorEvent) - - return this.#eventInit.filename - } - - get lineno () { - webidl.brandCheck(this, ErrorEvent) - - return this.#eventInit.lineno - } - - get colno () { - webidl.brandCheck(this, ErrorEvent) - - return this.#eventInit.colno - } - - get error () { - webidl.brandCheck(this, ErrorEvent) - - return this.#eventInit.error - } -} - -Object.defineProperties(MessageEvent.prototype, { - [Symbol.toStringTag]: { - value: 'MessageEvent', - configurable: true - }, - data: kEnumerableProperty, - origin: kEnumerableProperty, - lastEventId: kEnumerableProperty, - source: kEnumerableProperty, - ports: kEnumerableProperty, - initMessageEvent: kEnumerableProperty -}) - -Object.defineProperties(CloseEvent.prototype, { - [Symbol.toStringTag]: { - value: 'CloseEvent', - configurable: true - }, - reason: kEnumerableProperty, - code: kEnumerableProperty, - wasClean: kEnumerableProperty -}) - -Object.defineProperties(ErrorEvent.prototype, { - [Symbol.toStringTag]: { - value: 'ErrorEvent', - configurable: true - }, - message: kEnumerableProperty, - filename: kEnumerableProperty, - lineno: kEnumerableProperty, - colno: kEnumerableProperty, - error: kEnumerableProperty -}) - -webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort) - -webidl.converters['sequence'] = webidl.sequenceConverter( - webidl.converters.MessagePort -) - -const eventInit = [ - { - key: 'bubbles', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'cancelable', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'composed', - converter: webidl.converters.boolean, - defaultValue: false - } -] - -webidl.converters.MessageEventInit = webidl.dictionaryConverter([ - ...eventInit, - { - key: 'data', - converter: webidl.converters.any, - defaultValue: null - }, - { - key: 'origin', - converter: webidl.converters.USVString, - defaultValue: '' - }, - { - key: 'lastEventId', - converter: webidl.converters.DOMString, - defaultValue: '' - }, - { - key: 'source', - // Node doesn't implement WindowProxy or ServiceWorker, so the only - // valid value for source is a MessagePort. - converter: webidl.nullableConverter(webidl.converters.MessagePort), - defaultValue: null - }, - { - key: 'ports', - converter: webidl.converters['sequence'], - get defaultValue () { - return [] - } - } -]) - -webidl.converters.CloseEventInit = webidl.dictionaryConverter([ - ...eventInit, - { - key: 'wasClean', - converter: webidl.converters.boolean, - defaultValue: false - }, - { - key: 'code', - converter: webidl.converters['unsigned short'], - defaultValue: 0 - }, - { - key: 'reason', - converter: webidl.converters.USVString, - defaultValue: '' - } -]) - -webidl.converters.ErrorEventInit = webidl.dictionaryConverter([ - ...eventInit, - { - key: 'message', - converter: webidl.converters.DOMString, - defaultValue: '' - }, - { - key: 'filename', - converter: webidl.converters.USVString, - defaultValue: '' - }, - { - key: 'lineno', - converter: webidl.converters['unsigned long'], - defaultValue: 0 - }, - { - key: 'colno', - converter: webidl.converters['unsigned long'], - defaultValue: 0 - }, - { - key: 'error', - converter: webidl.converters.any - } -]) - -module.exports = { - MessageEvent, - CloseEvent, - ErrorEvent -} - - -/***/ }), - -/***/ 1237: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { maxUnsigned16Bit } = __nccwpck_require__(8294) - -/** @type {import('crypto')} */ -let crypto -try { - crypto = __nccwpck_require__(6982) -} catch { - -} - -class WebsocketFrameSend { - /** - * @param {Buffer|undefined} data - */ - constructor (data) { - this.frameData = data - this.maskKey = crypto.randomBytes(4) - } - - createFrame (opcode) { - const bodyLength = this.frameData?.byteLength ?? 0 - - /** @type {number} */ - let payloadLength = bodyLength // 0-125 - let offset = 6 - - if (bodyLength > maxUnsigned16Bit) { - offset += 8 // payload length is next 8 bytes - payloadLength = 127 - } else if (bodyLength > 125) { - offset += 2 // payload length is next 2 bytes - payloadLength = 126 - } - - const buffer = Buffer.allocUnsafe(bodyLength + offset) - - // Clear first 2 bytes, everything else is overwritten - buffer[0] = buffer[1] = 0 - buffer[0] |= 0x80 // FIN - buffer[0] = (buffer[0] & 0xF0) + opcode // opcode - - /*! ws. MIT License. Einar Otto Stangvik */ - buffer[offset - 4] = this.maskKey[0] - buffer[offset - 3] = this.maskKey[1] - buffer[offset - 2] = this.maskKey[2] - buffer[offset - 1] = this.maskKey[3] - - buffer[1] = payloadLength - - if (payloadLength === 126) { - buffer.writeUInt16BE(bodyLength, 2) - } else if (payloadLength === 127) { - // Clear extended payload length - buffer[2] = buffer[3] = 0 - buffer.writeUIntBE(bodyLength, 4, 6) - } - - buffer[1] |= 0x80 // MASK - - // mask body - for (let i = 0; i < bodyLength; i++) { - buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4] - } - - return buffer - } -} - -module.exports = { - WebsocketFrameSend -} - - -/***/ }), - -/***/ 3171: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { Writable } = __nccwpck_require__(2203) -const diagnosticsChannel = __nccwpck_require__(1637) -const { parserStates, opcodes, states, emptyBuffer } = __nccwpck_require__(8294) -const { kReadyState, kSentClose, kResponse, kReceivedClose } = __nccwpck_require__(2933) -const { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = __nccwpck_require__(3574) -const { WebsocketFrameSend } = __nccwpck_require__(1237) - -// This code was influenced by ws released under the MIT license. -// Copyright (c) 2011 Einar Otto Stangvik -// Copyright (c) 2013 Arnout Kazemier and contributors -// Copyright (c) 2016 Luigi Pinca and contributors - -const channels = {} -channels.ping = diagnosticsChannel.channel('undici:websocket:ping') -channels.pong = diagnosticsChannel.channel('undici:websocket:pong') - -class ByteParser extends Writable { - #buffers = [] - #byteOffset = 0 - - #state = parserStates.INFO - - #info = {} - #fragments = [] - - constructor (ws) { - super() - - this.ws = ws - } - - /** - * @param {Buffer} chunk - * @param {() => void} callback - */ - _write (chunk, _, callback) { - this.#buffers.push(chunk) - this.#byteOffset += chunk.length - - this.run(callback) - } - - /** - * Runs whenever a new chunk is received. - * Callback is called whenever there are no more chunks buffering, - * or not enough bytes are buffered to parse. - */ - run (callback) { - while (true) { - if (this.#state === parserStates.INFO) { - // If there aren't enough bytes to parse the payload length, etc. - if (this.#byteOffset < 2) { - return callback() - } - - const buffer = this.consume(2) - - this.#info.fin = (buffer[0] & 0x80) !== 0 - this.#info.opcode = buffer[0] & 0x0F - - // If we receive a fragmented message, we use the type of the first - // frame to parse the full message as binary/text, when it's terminated - this.#info.originalOpcode ??= this.#info.opcode - - this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION - - if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) { - // Only text and binary frames can be fragmented - failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.') - return - } - - const payloadLength = buffer[1] & 0x7F - - if (payloadLength <= 125) { - this.#info.payloadLength = payloadLength - this.#state = parserStates.READ_DATA - } else if (payloadLength === 126) { - this.#state = parserStates.PAYLOADLENGTH_16 - } else if (payloadLength === 127) { - this.#state = parserStates.PAYLOADLENGTH_64 - } - - if (this.#info.fragmented && payloadLength > 125) { - // A fragmented frame can't be fragmented itself - failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.') - return - } else if ( - (this.#info.opcode === opcodes.PING || - this.#info.opcode === opcodes.PONG || - this.#info.opcode === opcodes.CLOSE) && - payloadLength > 125 - ) { - // Control frames can have a payload length of 125 bytes MAX - failWebsocketConnection(this.ws, 'Payload length for control frame exceeded 125 bytes.') - return - } else if (this.#info.opcode === opcodes.CLOSE) { - if (payloadLength === 1) { - failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.') - return - } - - const body = this.consume(payloadLength) - - this.#info.closeInfo = this.parseCloseBody(false, body) - - if (!this.ws[kSentClose]) { - // If an endpoint receives a Close frame and did not previously send a - // Close frame, the endpoint MUST send a Close frame in response. (When - // sending a Close frame in response, the endpoint typically echos the - // status code it received.) - const body = Buffer.allocUnsafe(2) - body.writeUInt16BE(this.#info.closeInfo.code, 0) - const closeFrame = new WebsocketFrameSend(body) - - this.ws[kResponse].socket.write( - closeFrame.createFrame(opcodes.CLOSE), - (err) => { - if (!err) { - this.ws[kSentClose] = true + *blockSequence(seq) { + const it = seq.items[seq.items.length - 1]; + switch (this.type) { + case "newline": + if (it.value) { + const end = "end" in it.value ? it.value.end : void 0; + const last = Array.isArray(end) ? end[end.length - 1] : void 0; + if (last?.type === "comment") + end?.push(this.sourceToken); + else + seq.items.push({ start: [this.sourceToken] }); + } else + it.start.push(this.sourceToken); + return; + case "space": + case "comment": + if (it.value) + seq.items.push({ start: [this.sourceToken] }); + else { + if (this.atIndentedComment(it.start, seq.indent)) { + const prev = seq.items[seq.items.length - 2]; + const end = prev?.value?.end; + if (Array.isArray(end)) { + Array.prototype.push.apply(end, it.start); + end.push(this.sourceToken); + seq.items.pop(); + return; } } - ) - } - - // Upon either sending or receiving a Close control frame, it is said - // that _The WebSocket Closing Handshake is Started_ and that the - // WebSocket connection is in the CLOSING state. - this.ws[kReadyState] = states.CLOSING - this.ws[kReceivedClose] = true - - this.end() - - return - } else if (this.#info.opcode === opcodes.PING) { - // Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in - // response, unless it already received a Close frame. - // A Pong frame sent in response to a Ping frame must have identical - // "Application data" - - const body = this.consume(payloadLength) - - if (!this.ws[kReceivedClose]) { - const frame = new WebsocketFrameSend(body) - - this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG)) - - if (channels.ping.hasSubscribers) { - channels.ping.publish({ - payload: body - }) + it.start.push(this.sourceToken); } + return; + case "anchor": + case "tag": + if (it.value || this.indent <= seq.indent) + break; + it.start.push(this.sourceToken); + return; + case "seq-item-ind": + if (this.indent !== seq.indent) + break; + if (it.value || includesToken(it.start, "seq-item-ind")) + seq.items.push({ start: [this.sourceToken] }); + else + it.start.push(this.sourceToken); + return; + } + if (this.indent > seq.indent) { + const bv = this.startBlockValue(seq); + if (bv) { + this.stack.push(bv); + return; } - - this.#state = parserStates.INFO - - if (this.#byteOffset > 0) { - continue - } else { - callback() - return + } + yield* this.pop(); + yield* this.step(); + } + *flowCollection(fc) { + const it = fc.items[fc.items.length - 1]; + if (this.type === "flow-error-end") { + let top; + do { + yield* this.pop(); + top = this.peek(1); + } while (top && top.type === "flow-collection"); + } else if (fc.end.length === 0) { + switch (this.type) { + case "comma": + case "explicit-key-ind": + if (!it || it.sep) + fc.items.push({ start: [this.sourceToken] }); + else + it.start.push(this.sourceToken); + return; + case "map-value-ind": + if (!it || it.value) + fc.items.push({ start: [], key: null, sep: [this.sourceToken] }); + else if (it.sep) + it.sep.push(this.sourceToken); + else + Object.assign(it, { key: null, sep: [this.sourceToken] }); + return; + case "space": + case "comment": + case "newline": + case "anchor": + case "tag": + if (!it || it.value) + fc.items.push({ start: [this.sourceToken] }); + else if (it.sep) + it.sep.push(this.sourceToken); + else + it.start.push(this.sourceToken); + return; + case "alias": + case "scalar": + case "single-quoted-scalar": + case "double-quoted-scalar": { + const fs = this.flowScalar(this.type); + if (!it || it.value) + fc.items.push({ start: [], key: fs, sep: [] }); + else if (it.sep) + this.stack.push(fs); + else + Object.assign(it, { key: fs, sep: [] }); + return; + } + case "flow-map-end": + case "flow-seq-end": + fc.end.push(this.sourceToken); + return; } - } else if (this.#info.opcode === opcodes.PONG) { - // A Pong frame MAY be sent unsolicited. This serves as a - // unidirectional heartbeat. A response to an unsolicited Pong frame is - // not expected. - - const body = this.consume(payloadLength) - - if (channels.pong.hasSubscribers) { - channels.pong.publish({ - payload: body - }) + const bv = this.startBlockValue(fc); + if (bv) + this.stack.push(bv); + else { + yield* this.pop(); + yield* this.step(); } - - if (this.#byteOffset > 0) { - continue + } else { + const parent = this.peek(2); + if (parent.type === "block-map" && (this.type === "map-value-ind" && parent.indent === fc.indent || this.type === "newline" && !parent.items[parent.items.length - 1].sep)) { + yield* this.pop(); + yield* this.step(); + } else if (this.type === "map-value-ind" && parent.type !== "flow-collection") { + const prev = getPrevProps(parent); + const start = getFirstKeyStartProps(prev); + fixFlowSeqItems(fc); + const sep = fc.end.splice(1, fc.end.length); + sep.push(this.sourceToken); + const map = { + type: "block-map", + offset: fc.offset, + indent: fc.indent, + items: [{ start, key: fc, sep }] + }; + this.onKeyLine = true; + this.stack[this.stack.length - 1] = map; } else { - callback() - return + yield* this.lineEnd(fc); } } - } else if (this.#state === parserStates.PAYLOADLENGTH_16) { - if (this.#byteOffset < 2) { - return callback() - } - - const buffer = this.consume(2) - - this.#info.payloadLength = buffer.readUInt16BE(0) - this.#state = parserStates.READ_DATA - } else if (this.#state === parserStates.PAYLOADLENGTH_64) { - if (this.#byteOffset < 8) { - return callback() - } - - const buffer = this.consume(8) - const upper = buffer.readUInt32BE(0) - - // 2^31 is the maxinimum bytes an arraybuffer can contain - // on 32-bit systems. Although, on 64-bit systems, this is - // 2^53-1 bytes. - // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length - // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275 - // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e - if (upper > 2 ** 31 - 1) { - failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.') - return - } - - const lower = buffer.readUInt32BE(4) - - this.#info.payloadLength = (upper << 8) + lower - this.#state = parserStates.READ_DATA - } else if (this.#state === parserStates.READ_DATA) { - if (this.#byteOffset < this.#info.payloadLength) { - // If there is still more data in this chunk that needs to be read - return callback() - } else if (this.#byteOffset >= this.#info.payloadLength) { - // If the server sent multiple frames in a single chunk - - const body = this.consume(this.#info.payloadLength) - - this.#fragments.push(body) - - // If the frame is unfragmented, or a fragmented frame was terminated, - // a message was received - if (!this.#info.fragmented || (this.#info.fin && this.#info.opcode === opcodes.CONTINUATION)) { - const fullMessage = Buffer.concat(this.#fragments) - - websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage) - - this.#info = {} - this.#fragments.length = 0 + } + flowScalar(type) { + if (this.onNewLine) { + let nl = this.source.indexOf("\n") + 1; + while (nl !== 0) { + this.onNewLine(this.offset + nl); + nl = this.source.indexOf("\n", nl) + 1; } - - this.#state = parserStates.INFO } + return { + type, + offset: this.offset, + indent: this.indent, + source: this.source + }; } - - if (this.#byteOffset > 0) { - continue - } else { - callback() - break + startBlockValue(parent) { + switch (this.type) { + case "alias": + case "scalar": + case "single-quoted-scalar": + case "double-quoted-scalar": + return this.flowScalar(this.type); + case "block-scalar-header": + return { + type: "block-scalar", + offset: this.offset, + indent: this.indent, + props: [this.sourceToken], + source: "" + }; + case "flow-map-start": + case "flow-seq-start": + return { + type: "flow-collection", + offset: this.offset, + indent: this.indent, + start: this.sourceToken, + items: [], + end: [] + }; + case "seq-item-ind": + return { + type: "block-seq", + offset: this.offset, + indent: this.indent, + items: [{ start: [this.sourceToken] }] + }; + case "explicit-key-ind": { + this.onKeyLine = true; + const prev = getPrevProps(parent); + const start = getFirstKeyStartProps(prev); + start.push(this.sourceToken); + return { + type: "block-map", + offset: this.offset, + indent: this.indent, + items: [{ start, explicitKey: true }] + }; + } + case "map-value-ind": { + this.onKeyLine = true; + const prev = getPrevProps(parent); + const start = getFirstKeyStartProps(prev); + return { + type: "block-map", + offset: this.offset, + indent: this.indent, + items: [{ start, key: null, sep: [this.sourceToken] }] + }; + } + } + return null; } - } - } - - /** - * Take n bytes from the buffered Buffers - * @param {number} n - * @returns {Buffer|null} - */ - consume (n) { - if (n > this.#byteOffset) { - return null - } else if (n === 0) { - return emptyBuffer - } - - if (this.#buffers[0].length === n) { - this.#byteOffset -= this.#buffers[0].length - return this.#buffers.shift() - } - - const buffer = Buffer.allocUnsafe(n) - let offset = 0 - - while (offset !== n) { - const next = this.#buffers[0] - const { length } = next - - if (length + offset === n) { - buffer.set(this.#buffers.shift(), offset) - break - } else if (length + offset > n) { - buffer.set(next.subarray(0, n - offset), offset) - this.#buffers[0] = next.subarray(n - offset) - break - } else { - buffer.set(this.#buffers.shift(), offset) - offset += next.length + atIndentedComment(start, indent) { + if (this.type !== "comment") + return false; + if (this.indent <= indent) + return false; + return start.every((st) => st.type === "newline" || st.type === "space"); + } + *documentEnd(docEnd) { + if (this.type !== "doc-mode") { + if (docEnd.end) + docEnd.end.push(this.sourceToken); + else + docEnd.end = [this.sourceToken]; + if (this.type === "newline") + yield* this.pop(); + } } - } - - this.#byteOffset -= n - - return buffer - } - - parseCloseBody (onlyCode, data) { - // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.5 - /** @type {number|undefined} */ - let code - - if (data.length >= 2) { - // _The WebSocket Connection Close Code_ is - // defined as the status code (Section 7.4) contained in the first Close - // control frame received by the application - code = data.readUInt16BE(0) - } - - if (onlyCode) { - if (!isValidStatusCode(code)) { - return null + *lineEnd(token) { + switch (this.type) { + case "comma": + case "doc-start": + case "doc-end": + case "flow-seq-end": + case "flow-map-end": + case "map-value-ind": + yield* this.pop(); + yield* this.step(); + break; + case "newline": + this.onKeyLine = false; + // fallthrough + case "space": + case "comment": + default: + if (token.end) + token.end.push(this.sourceToken); + else + token.end = [this.sourceToken]; + if (this.type === "newline") + yield* this.pop(); + } } - - return { code } - } - - // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.6 - /** @type {Buffer} */ - let reason = data.subarray(2) - - // Remove BOM - if (reason[0] === 0xEF && reason[1] === 0xBB && reason[2] === 0xBF) { - reason = reason.subarray(3) - } - - if (code !== undefined && !isValidStatusCode(code)) { - return null - } - - try { - // TODO: optimize this - reason = new TextDecoder('utf-8', { fatal: true }).decode(reason) - } catch { - return null - } - - return { code, reason } - } - - get closingInfo () { - return this.#info.closeInfo - } -} - -module.exports = { - ByteParser -} - - -/***/ }), - -/***/ 2933: -/***/ ((module) => { - -"use strict"; - - -module.exports = { - kWebSocketURL: Symbol('url'), - kReadyState: Symbol('ready state'), - kController: Symbol('controller'), - kResponse: Symbol('response'), - kBinaryType: Symbol('binary type'), - kSentClose: Symbol('sent close'), - kReceivedClose: Symbol('received close'), - kByteParser: Symbol('byte parser') -} - - -/***/ }), - -/***/ 3574: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = __nccwpck_require__(2933) -const { states, opcodes } = __nccwpck_require__(8294) -const { MessageEvent, ErrorEvent } = __nccwpck_require__(6255) - -/* globals Blob */ - -/** - * @param {import('./websocket').WebSocket} ws - */ -function isEstablished (ws) { - // If the server's response is validated as provided for above, it is - // said that _The WebSocket Connection is Established_ and that the - // WebSocket Connection is in the OPEN state. - return ws[kReadyState] === states.OPEN -} - -/** - * @param {import('./websocket').WebSocket} ws - */ -function isClosing (ws) { - // Upon either sending or receiving a Close control frame, it is said - // that _The WebSocket Closing Handshake is Started_ and that the - // WebSocket connection is in the CLOSING state. - return ws[kReadyState] === states.CLOSING -} - -/** - * @param {import('./websocket').WebSocket} ws - */ -function isClosed (ws) { - return ws[kReadyState] === states.CLOSED -} - -/** - * @see https://dom.spec.whatwg.org/#concept-event-fire - * @param {string} e - * @param {EventTarget} target - * @param {EventInit | undefined} eventInitDict - */ -function fireEvent (e, target, eventConstructor = Event, eventInitDict) { - // 1. If eventConstructor is not given, then let eventConstructor be Event. - - // 2. Let event be the result of creating an event given eventConstructor, - // in the relevant realm of target. - // 3. Initialize event’s type attribute to e. - const event = new eventConstructor(e, eventInitDict) // eslint-disable-line new-cap - - // 4. Initialize any other IDL attributes of event as described in the - // invocation of this algorithm. - - // 5. Return the result of dispatching event at target, with legacy target - // override flag set if set. - target.dispatchEvent(event) -} - -/** - * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol - * @param {import('./websocket').WebSocket} ws - * @param {number} type Opcode - * @param {Buffer} data application data - */ -function websocketMessageReceived (ws, type, data) { - // 1. If ready state is not OPEN (1), then return. - if (ws[kReadyState] !== states.OPEN) { - return - } - - // 2. Let dataForEvent be determined by switching on type and binary type: - let dataForEvent - - if (type === opcodes.TEXT) { - // -> type indicates that the data is Text - // a new DOMString containing data - try { - dataForEvent = new TextDecoder('utf-8', { fatal: true }).decode(data) - } catch { - failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.') - return - } - } else if (type === opcodes.BINARY) { - if (ws[kBinaryType] === 'blob') { - // -> type indicates that the data is Binary and binary type is "blob" - // a new Blob object, created in the relevant Realm of the WebSocket - // object, that represents data as its raw data - dataForEvent = new Blob([data]) - } else { - // -> type indicates that the data is Binary and binary type is "arraybuffer" - // a new ArrayBuffer object, created in the relevant Realm of the - // WebSocket object, whose contents are data - dataForEvent = new Uint8Array(data).buffer - } - } - - // 3. Fire an event named message at the WebSocket object, using MessageEvent, - // with the origin attribute initialized to the serialization of the WebSocket - // object’s url's origin, and the data attribute initialized to dataForEvent. - fireEvent('message', ws, MessageEvent, { - origin: ws[kWebSocketURL].origin, - data: dataForEvent - }) -} - -/** - * @see https://datatracker.ietf.org/doc/html/rfc6455 - * @see https://datatracker.ietf.org/doc/html/rfc2616 - * @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407 - * @param {string} protocol - */ -function isValidSubprotocol (protocol) { - // If present, this value indicates one - // or more comma-separated subprotocol the client wishes to speak, - // ordered by preference. The elements that comprise this value - // MUST be non-empty strings with characters in the range U+0021 to - // U+007E not including separator characters as defined in - // [RFC2616] and MUST all be unique strings. - if (protocol.length === 0) { - return false - } - - for (const char of protocol) { - const code = char.charCodeAt(0) - - if ( - code < 0x21 || - code > 0x7E || - char === '(' || - char === ')' || - char === '<' || - char === '>' || - char === '@' || - char === ',' || - char === ';' || - char === ':' || - char === '\\' || - char === '"' || - char === '/' || - char === '[' || - char === ']' || - char === '?' || - char === '=' || - char === '{' || - char === '}' || - code === 32 || // SP - code === 9 // HT - ) { - return false - } - } - - return true -} - -/** - * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4 - * @param {number} code - */ -function isValidStatusCode (code) { - if (code >= 1000 && code < 1015) { - return ( - code !== 1004 && // reserved - code !== 1005 && // "MUST NOT be set as a status code" - code !== 1006 // "MUST NOT be set as a status code" - ) - } - - return code >= 3000 && code <= 4999 -} - -/** - * @param {import('./websocket').WebSocket} ws - * @param {string|undefined} reason - */ -function failWebsocketConnection (ws, reason) { - const { [kController]: controller, [kResponse]: response } = ws - - controller.abort() - - if (response?.socket && !response.socket.destroyed) { - response.socket.destroy() - } - - if (reason) { - fireEvent('error', ws, ErrorEvent, { - error: new Error(reason) - }) - } -} - -module.exports = { - isEstablished, - isClosing, - isClosed, - fireEvent, - isValidSubprotocol, - isValidStatusCode, - failWebsocketConnection, - websocketMessageReceived -} - - -/***/ }), - -/***/ 5171: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const { webidl } = __nccwpck_require__(4222) -const { DOMException } = __nccwpck_require__(7326) -const { URLSerializer } = __nccwpck_require__(4322) -const { getGlobalOrigin } = __nccwpck_require__(5628) -const { staticPropertyDescriptors, states, opcodes, emptyBuffer } = __nccwpck_require__(8294) -const { - kWebSocketURL, - kReadyState, - kController, - kBinaryType, - kResponse, - kSentClose, - kByteParser -} = __nccwpck_require__(2933) -const { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = __nccwpck_require__(3574) -const { establishWebSocketConnection } = __nccwpck_require__(8550) -const { WebsocketFrameSend } = __nccwpck_require__(1237) -const { ByteParser } = __nccwpck_require__(3171) -const { kEnumerableProperty, isBlobLike } = __nccwpck_require__(3440) -const { getGlobalDispatcher } = __nccwpck_require__(2581) -const { types } = __nccwpck_require__(9023) - -let experimentalWarned = false - -// https://websockets.spec.whatwg.org/#interface-definition -class WebSocket extends EventTarget { - #events = { - open: null, - error: null, - close: null, - message: null - } - - #bufferedAmount = 0 - #protocol = '' - #extensions = '' - - /** - * @param {string} url - * @param {string|string[]} protocols - */ - constructor (url, protocols = []) { - super() - - webidl.argumentLengthCheck(arguments, 1, { header: 'WebSocket constructor' }) - - if (!experimentalWarned) { - experimentalWarned = true - process.emitWarning('WebSockets are experimental, expect them to change at any time.', { - code: 'UNDICI-WS' - }) - } - - const options = webidl.converters['DOMString or sequence or WebSocketInit'](protocols) - - url = webidl.converters.USVString(url) - protocols = options.protocols - - // 1. Let baseURL be this's relevant settings object's API base URL. - const baseURL = getGlobalOrigin() - - // 1. Let urlRecord be the result of applying the URL parser to url with baseURL. - let urlRecord - - try { - urlRecord = new URL(url, baseURL) - } catch (e) { - // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException. - throw new DOMException(e, 'SyntaxError') - } - - // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws". - if (urlRecord.protocol === 'http:') { - urlRecord.protocol = 'ws:' - } else if (urlRecord.protocol === 'https:') { - // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss". - urlRecord.protocol = 'wss:' - } - - // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException. - if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') { - throw new DOMException( - `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, - 'SyntaxError' - ) - } - - // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError" - // DOMException. - if (urlRecord.hash || urlRecord.href.endsWith('#')) { - throw new DOMException('Got fragment', 'SyntaxError') - } - - // 8. If protocols is a string, set protocols to a sequence consisting - // of just that string. - if (typeof protocols === 'string') { - protocols = [protocols] - } - - // 9. If any of the values in protocols occur more than once or otherwise - // fail to match the requirements for elements that comprise the value - // of `Sec-WebSocket-Protocol` fields as defined by The WebSocket - // protocol, then throw a "SyntaxError" DOMException. - if (protocols.length !== new Set(protocols.map(p => p.toLowerCase())).size) { - throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError') - } - - if (protocols.length > 0 && !protocols.every(p => isValidSubprotocol(p))) { - throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError') - } - - // 10. Set this's url to urlRecord. - this[kWebSocketURL] = new URL(urlRecord.href) - - // 11. Let client be this's relevant settings object. - - // 12. Run this step in parallel: - - // 1. Establish a WebSocket connection given urlRecord, protocols, - // and client. - this[kController] = establishWebSocketConnection( - urlRecord, - protocols, - this, - (response) => this.#onConnectionEstablished(response), - options - ) - - // Each WebSocket object has an associated ready state, which is a - // number representing the state of the connection. Initially it must - // be CONNECTING (0). - this[kReadyState] = WebSocket.CONNECTING - - // The extensions attribute must initially return the empty string. - - // The protocol attribute must initially return the empty string. - - // Each WebSocket object has an associated binary type, which is a - // BinaryType. Initially it must be "blob". - this[kBinaryType] = 'blob' + }; + exports2.Parser = Parser; } +}); - /** - * @see https://websockets.spec.whatwg.org/#dom-websocket-close - * @param {number|undefined} code - * @param {string|undefined} reason - */ - close (code = undefined, reason = undefined) { - webidl.brandCheck(this, WebSocket) - - if (code !== undefined) { - code = webidl.converters['unsigned short'](code, { clamp: true }) - } - - if (reason !== undefined) { - reason = webidl.converters.USVString(reason) - } - - // 1. If code is present, but is neither an integer equal to 1000 nor an - // integer in the range 3000 to 4999, inclusive, throw an - // "InvalidAccessError" DOMException. - if (code !== undefined) { - if (code !== 1000 && (code < 3000 || code > 4999)) { - throw new DOMException('invalid code', 'InvalidAccessError') +// node_modules/yaml/dist/public-api.js +var require_public_api = __commonJS({ + "node_modules/yaml/dist/public-api.js"(exports2) { + "use strict"; + var composer = require_composer(); + var Document = require_Document(); + var errors = require_errors(); + var log = require_log(); + var identity = require_identity(); + var lineCounter = require_line_counter(); + var parser = require_parser(); + function parseOptions(options) { + const prettyErrors = options.prettyErrors !== false; + const lineCounter$1 = options.lineCounter || prettyErrors && new lineCounter.LineCounter() || null; + return { lineCounter: lineCounter$1, prettyErrors }; + } + function parseAllDocuments(source, options = {}) { + const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options); + const parser$1 = new parser.Parser(lineCounter2?.addNewLine); + const composer$1 = new composer.Composer(options); + const docs = Array.from(composer$1.compose(parser$1.parse(source))); + if (prettyErrors && lineCounter2) + for (const doc of docs) { + doc.errors.forEach(errors.prettifyError(source, lineCounter2)); + doc.warnings.forEach(errors.prettifyError(source, lineCounter2)); + } + if (docs.length > 0) + return docs; + return Object.assign([], { empty: true }, composer$1.streamInfo()); + } + function parseDocument(source, options = {}) { + const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options); + const parser$1 = new parser.Parser(lineCounter2?.addNewLine); + const composer$1 = new composer.Composer(options); + let doc = null; + for (const _doc of composer$1.compose(parser$1.parse(source), true, source.length)) { + if (!doc) + doc = _doc; + else if (doc.options.logLevel !== "silent") { + doc.errors.push(new errors.YAMLParseError(_doc.range.slice(0, 2), "MULTIPLE_DOCS", "Source contains multiple documents; please use YAML.parseAllDocuments()")); + break; + } + } + if (prettyErrors && lineCounter2) { + doc.errors.forEach(errors.prettifyError(source, lineCounter2)); + doc.warnings.forEach(errors.prettifyError(source, lineCounter2)); } + return doc; } - - let reasonByteLength = 0 - - // 2. If reason is present, then run these substeps: - if (reason !== undefined) { - // 1. Let reasonBytes be the result of encoding reason. - // 2. If reasonBytes is longer than 123 bytes, then throw a - // "SyntaxError" DOMException. - reasonByteLength = Buffer.byteLength(reason) - - if (reasonByteLength > 123) { - throw new DOMException( - `Reason must be less than 123 bytes; received ${reasonByteLength}`, - 'SyntaxError' - ) + function parse(src, reviver, options) { + let _reviver = void 0; + if (typeof reviver === "function") { + _reviver = reviver; + } else if (options === void 0 && reviver && typeof reviver === "object") { + options = reviver; + } + const doc = parseDocument(src, options); + if (!doc) + return null; + doc.warnings.forEach((warning) => log.warn(doc.options.logLevel, warning)); + if (doc.errors.length > 0) { + if (doc.options.logLevel !== "silent") + throw doc.errors[0]; + else + doc.errors = []; } + return doc.toJS(Object.assign({ reviver: _reviver }, options)); } - - // 3. Run the first matching steps from the following list: - if (this[kReadyState] === WebSocket.CLOSING || this[kReadyState] === WebSocket.CLOSED) { - // If this's ready state is CLOSING (2) or CLOSED (3) - // Do nothing. - } else if (!isEstablished(this)) { - // If the WebSocket connection is not yet established - // Fail the WebSocket connection and set this's ready state - // to CLOSING (2). - failWebsocketConnection(this, 'Connection was closed before it was established.') - this[kReadyState] = WebSocket.CLOSING - } else if (!isClosing(this)) { - // If the WebSocket closing handshake has not yet been started - // Start the WebSocket closing handshake and set this's ready - // state to CLOSING (2). - // - If neither code nor reason is present, the WebSocket Close - // message must not have a body. - // - If code is present, then the status code to use in the - // WebSocket Close message must be the integer given by code. - // - If reason is also present, then reasonBytes must be - // provided in the Close message after the status code. - - const frame = new WebsocketFrameSend() - - // If neither code nor reason is present, the WebSocket Close - // message must not have a body. - - // If code is present, then the status code to use in the - // WebSocket Close message must be the integer given by code. - if (code !== undefined && reason === undefined) { - frame.frameData = Buffer.allocUnsafe(2) - frame.frameData.writeUInt16BE(code, 0) - } else if (code !== undefined && reason !== undefined) { - // If reason is also present, then reasonBytes must be - // provided in the Close message after the status code. - frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength) - frame.frameData.writeUInt16BE(code, 0) - // the body MAY contain UTF-8-encoded data with value /reason/ - frame.frameData.write(reason, 2, 'utf-8') - } else { - frame.frameData = emptyBuffer + function stringify2(value, replacer, options) { + let _replacer = null; + if (typeof replacer === "function" || Array.isArray(replacer)) { + _replacer = replacer; + } else if (options === void 0 && replacer) { + options = replacer; } - - /** @type {import('stream').Duplex} */ - const socket = this[kResponse].socket - - socket.write(frame.createFrame(opcodes.CLOSE), (err) => { - if (!err) { - this[kSentClose] = true - } - }) - - // Upon either sending or receiving a Close control frame, it is said - // that _The WebSocket Closing Handshake is Started_ and that the - // WebSocket connection is in the CLOSING state. - this[kReadyState] = states.CLOSING - } else { - // Otherwise - // Set this's ready state to CLOSING (2). - this[kReadyState] = WebSocket.CLOSING + if (typeof options === "string") + options = options.length; + if (typeof options === "number") { + const indent = Math.round(options); + options = indent < 1 ? void 0 : indent > 8 ? { indent: 8 } : { indent }; + } + if (value === void 0) { + const { keepUndefined } = options ?? replacer ?? {}; + if (!keepUndefined) + return void 0; + } + if (identity.isDocument(value) && !_replacer) + return value.toString(options); + return new Document.Document(value, _replacer, options).toString(options); } + exports2.parse = parse; + exports2.parseAllDocuments = parseAllDocuments; + exports2.parseDocument = parseDocument; + exports2.stringify = stringify2; } +}); - /** - * @see https://websockets.spec.whatwg.org/#dom-websocket-send - * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data - */ - send (data) { - webidl.brandCheck(this, WebSocket) - - webidl.argumentLengthCheck(arguments, 1, { header: 'WebSocket.send' }) - - data = webidl.converters.WebSocketSendData(data) - - // 1. If this's ready state is CONNECTING, then throw an - // "InvalidStateError" DOMException. - if (this[kReadyState] === WebSocket.CONNECTING) { - throw new DOMException('Sent before connected.', 'InvalidStateError') - } - - // 2. Run the appropriate set of steps from the following list: - // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1 - // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2 +// node_modules/yaml/dist/index.js +var require_dist = __commonJS({ + "node_modules/yaml/dist/index.js"(exports2) { + "use strict"; + var composer = require_composer(); + var Document = require_Document(); + var Schema = require_Schema(); + var errors = require_errors(); + var Alias = require_Alias(); + var identity = require_identity(); + var Pair = require_Pair(); + var Scalar = require_Scalar(); + var YAMLMap = require_YAMLMap(); + var YAMLSeq = require_YAMLSeq(); + var cst = require_cst(); + var lexer = require_lexer(); + var lineCounter = require_line_counter(); + var parser = require_parser(); + var publicApi = require_public_api(); + var visit = require_visit(); + exports2.Composer = composer.Composer; + exports2.Document = Document.Document; + exports2.Schema = Schema.Schema; + exports2.YAMLError = errors.YAMLError; + exports2.YAMLParseError = errors.YAMLParseError; + exports2.YAMLWarning = errors.YAMLWarning; + exports2.Alias = Alias.Alias; + exports2.isAlias = identity.isAlias; + exports2.isCollection = identity.isCollection; + exports2.isDocument = identity.isDocument; + exports2.isMap = identity.isMap; + exports2.isNode = identity.isNode; + exports2.isPair = identity.isPair; + exports2.isScalar = identity.isScalar; + exports2.isSeq = identity.isSeq; + exports2.Pair = Pair.Pair; + exports2.Scalar = Scalar.Scalar; + exports2.YAMLMap = YAMLMap.YAMLMap; + exports2.YAMLSeq = YAMLSeq.YAMLSeq; + exports2.CST = cst; + exports2.Lexer = lexer.Lexer; + exports2.LineCounter = lineCounter.LineCounter; + exports2.Parser = parser.Parser; + exports2.parse = publicApi.parse; + exports2.parseAllDocuments = publicApi.parseAllDocuments; + exports2.parseDocument = publicApi.parseDocument; + exports2.stringify = publicApi.stringify; + exports2.visit = visit.visit; + exports2.visitAsync = visit.visitAsync; + } +}); - if (!isEstablished(this) || isClosing(this)) { - return +// node_modules/@actions/core/lib/utils.js +var require_utils = __commonJS({ + "node_modules/@actions/core/lib/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.toCommandProperties = exports2.toCommandValue = void 0; + function toCommandValue(input) { + if (input === null || input === void 0) { + return ""; + } else if (typeof input === "string" || input instanceof String) { + return input; + } + return JSON.stringify(input); } - - /** @type {import('stream').Duplex} */ - const socket = this[kResponse].socket - - // If data is a string - if (typeof data === 'string') { - // If the WebSocket connection is established and the WebSocket - // closing handshake has not yet started, then the user agent - // must send a WebSocket Message comprised of the data argument - // using a text frame opcode; if the data cannot be sent, e.g. - // because it would need to be buffered but the buffer is full, - // the user agent must flag the WebSocket as full and then close - // the WebSocket connection. Any invocation of this method with a - // string argument that does not throw an exception must increase - // the bufferedAmount attribute by the number of bytes needed to - // express the argument as UTF-8. - - const value = Buffer.from(data) - const frame = new WebsocketFrameSend(value) - const buffer = frame.createFrame(opcodes.TEXT) - - this.#bufferedAmount += value.byteLength - socket.write(buffer, () => { - this.#bufferedAmount -= value.byteLength - }) - } else if (types.isArrayBuffer(data)) { - // If the WebSocket connection is established, and the WebSocket - // closing handshake has not yet started, then the user agent must - // send a WebSocket Message comprised of data using a binary frame - // opcode; if the data cannot be sent, e.g. because it would need - // to be buffered but the buffer is full, the user agent must flag - // the WebSocket as full and then close the WebSocket connection. - // The data to be sent is the data stored in the buffer described - // by the ArrayBuffer object. Any invocation of this method with an - // ArrayBuffer argument that does not throw an exception must - // increase the bufferedAmount attribute by the length of the - // ArrayBuffer in bytes. - - const value = Buffer.from(data) - const frame = new WebsocketFrameSend(value) - const buffer = frame.createFrame(opcodes.BINARY) - - this.#bufferedAmount += value.byteLength - socket.write(buffer, () => { - this.#bufferedAmount -= value.byteLength - }) - } else if (ArrayBuffer.isView(data)) { - // If the WebSocket connection is established, and the WebSocket - // closing handshake has not yet started, then the user agent must - // send a WebSocket Message comprised of data using a binary frame - // opcode; if the data cannot be sent, e.g. because it would need to - // be buffered but the buffer is full, the user agent must flag the - // WebSocket as full and then close the WebSocket connection. The - // data to be sent is the data stored in the section of the buffer - // described by the ArrayBuffer object that data references. Any - // invocation of this method with this kind of argument that does - // not throw an exception must increase the bufferedAmount attribute - // by the length of data’s buffer in bytes. - - const ab = Buffer.from(data, data.byteOffset, data.byteLength) - - const frame = new WebsocketFrameSend(ab) - const buffer = frame.createFrame(opcodes.BINARY) - - this.#bufferedAmount += ab.byteLength - socket.write(buffer, () => { - this.#bufferedAmount -= ab.byteLength - }) - } else if (isBlobLike(data)) { - // If the WebSocket connection is established, and the WebSocket - // closing handshake has not yet started, then the user agent must - // send a WebSocket Message comprised of data using a binary frame - // opcode; if the data cannot be sent, e.g. because it would need to - // be buffered but the buffer is full, the user agent must flag the - // WebSocket as full and then close the WebSocket connection. The data - // to be sent is the raw data represented by the Blob object. Any - // invocation of this method with a Blob argument that does not throw - // an exception must increase the bufferedAmount attribute by the size - // of the Blob object’s raw data, in bytes. - - const frame = new WebsocketFrameSend() - - data.arrayBuffer().then((ab) => { - const value = Buffer.from(ab) - frame.frameData = value - const buffer = frame.createFrame(opcodes.BINARY) - - this.#bufferedAmount += value.byteLength - socket.write(buffer, () => { - this.#bufferedAmount -= value.byteLength - }) - }) + exports2.toCommandValue = toCommandValue; + function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; } + exports2.toCommandProperties = toCommandProperties; } +}); - get readyState () { - webidl.brandCheck(this, WebSocket) - - // The readyState getter steps are to return this's ready state. - return this[kReadyState] - } - - get bufferedAmount () { - webidl.brandCheck(this, WebSocket) - - return this.#bufferedAmount - } - - get url () { - webidl.brandCheck(this, WebSocket) - - // The url getter steps are to return this's url, serialized. - return URLSerializer(this[kWebSocketURL]) - } - - get extensions () { - webidl.brandCheck(this, WebSocket) - - return this.#extensions - } - - get protocol () { - webidl.brandCheck(this, WebSocket) - - return this.#protocol - } - - get onopen () { - webidl.brandCheck(this, WebSocket) - - return this.#events.open - } - - set onopen (fn) { - webidl.brandCheck(this, WebSocket) - - if (this.#events.open) { - this.removeEventListener('open', this.#events.open) +// node_modules/@actions/core/lib/command.js +var require_command = __commonJS({ + "node_modules/@actions/core/lib/command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.issue = exports2.issueCommand = void 0; + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); + } + exports2.issueCommand = issueCommand; + function issue(name, message = "") { + issueCommand(name, {}, message); + } + exports2.issue = issue; + var CMD_STRING = "::"; + var Command = class { + constructor(command, properties, message) { + if (!command) { + command = "missing.command"; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += " "; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } else { + cmdStr += ","; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } + }; + function escapeData(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A"); } - - if (typeof fn === 'function') { - this.#events.open = fn - this.addEventListener('open', fn) - } else { - this.#events.open = null + function escapeProperty(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C"); } } +}); - get onerror () { - webidl.brandCheck(this, WebSocket) - - return this.#events.error - } - - set onerror (fn) { - webidl.brandCheck(this, WebSocket) - - if (this.#events.error) { - this.removeEventListener('error', this.#events.error) +// node_modules/@actions/core/lib/file-command.js +var require_file_command = __commonJS({ + "node_modules/@actions/core/lib/file-command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.prepareKeyValueMessage = exports2.issueFileCommand = void 0; + var crypto = __importStar(require("crypto")); + var fs = __importStar(require("fs")); + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { + encoding: "utf8" + }); } - - if (typeof fn === 'function') { - this.#events.error = fn - this.addEventListener('error', fn) - } else { - this.#events.error = null + exports2.issueFileCommand = issueFileCommand; + function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${crypto.randomUUID()}`; + const convertedValue = (0, utils_1.toCommandValue)(value); + if (key.includes(delimiter)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + } + if (convertedValue.includes(delimiter)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + } + return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; } + exports2.prepareKeyValueMessage = prepareKeyValueMessage; } +}); - get onclose () { - webidl.brandCheck(this, WebSocket) - - return this.#events.close - } - - set onclose (fn) { - webidl.brandCheck(this, WebSocket) - - if (this.#events.close) { - this.removeEventListener('close', this.#events.close) +// node_modules/@actions/http-client/lib/proxy.js +var require_proxy = __commonJS({ + "node_modules/@actions/http-client/lib/proxy.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.checkBypass = exports2.getProxyUrl = void 0; + function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === "https:"; + if (checkBypass(reqUrl)) { + return void 0; + } + const proxyVar = (() => { + if (usingSsl) { + return process.env["https_proxy"] || process.env["HTTPS_PROXY"]; + } else { + return process.env["http_proxy"] || process.env["HTTP_PROXY"]; + } + })(); + if (proxyVar) { + try { + return new DecodedURL(proxyVar); + } catch (_a2) { + if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) + return new DecodedURL(`http://${proxyVar}`); + } + } else { + return void 0; + } } - - if (typeof fn === 'function') { - this.#events.close = fn - this.addEventListener('close', fn) - } else { - this.#events.close = null + exports2.getProxyUrl = getProxyUrl; + function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) { + return true; + } + const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || ""; + if (!noProxy) { + return false; + } + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } else if (reqUrl.protocol === "http:") { + reqPort = 80; + } else if (reqUrl.protocol === "https:") { + reqPort = 443; + } + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === "number") { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) { + if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) { + return true; + } + } + return false; } + exports2.checkBypass = checkBypass; + function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]"); + } + var DecodedURL = class extends URL { + constructor(url, base) { + super(url, base); + this._decodedUsername = decodeURIComponent(super.username); + this._decodedPassword = decodeURIComponent(super.password); + } + get username() { + return this._decodedUsername; + } + get password() { + return this._decodedPassword; + } + }; } +}); - get onmessage () { - webidl.brandCheck(this, WebSocket) - - return this.#events.message - } - - set onmessage (fn) { - webidl.brandCheck(this, WebSocket) - - if (this.#events.message) { - this.removeEventListener('message', this.#events.message) +// node_modules/tunnel/lib/tunnel.js +var require_tunnel = __commonJS({ + "node_modules/tunnel/lib/tunnel.js"(exports2) { + "use strict"; + var net = require("net"); + var tls = require("tls"); + var http = require("http"); + var https = require("https"); + var events = require("events"); + var assert = require("assert"); + var util = require("util"); + exports2.httpOverHttp = httpOverHttp; + exports2.httpsOverHttp = httpsOverHttp; + exports2.httpOverHttps = httpOverHttps; + exports2.httpsOverHttps = httpsOverHttps; + function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; + } + function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; + } + function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + self.on("free", function onFree(socket, host, port, localAddress) { + var options2 = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options2.host && pending.port === options2.port) { + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); } - - if (typeof fn === 'function') { - this.#events.message = fn - this.addEventListener('message', fn) - } else { - this.#events.message = null + util.inherits(TunnelingAgent, events.EventEmitter); + TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({ request: req }, self.options, toOptions(host, port, localAddress)); + if (self.sockets.length >= this.maxSockets) { + self.requests.push(options); + return; + } + self.createSocket(options, function(socket) { + socket.on("free", onFree); + socket.on("close", onCloseOrRemove); + socket.on("agentRemove", onCloseOrRemove); + req.onSocket(socket); + function onFree() { + self.emit("free", socket, options); + } + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener("free", onFree); + socket.removeListener("close", onCloseOrRemove); + socket.removeListener("agentRemove", onCloseOrRemove); + } + }); + }; + TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: "CONNECT", + path: options.host + ":" + options.port, + agent: false, + headers: { + host: options.host + ":" + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64"); + } + debug("making CONNECT request"); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; + connectReq.once("response", onResponse); + connectReq.once("upgrade", onUpgrade); + connectReq.once("connect", onConnect); + connectReq.once("error", onError); + connectReq.end(); + function onResponse(res) { + res.upgrade = true; + } + function onUpgrade(res, socket, head) { + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + if (res.statusCode !== 200) { + debug( + "tunneling socket could not be established, statusCode=%d", + res.statusCode + ); + socket.destroy(); + var error2 = new Error("tunneling socket could not be established, statusCode=" + res.statusCode); + error2.code = "ECONNRESET"; + options.request.emit("error", error2); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug("got illegal response body from proxy"); + socket.destroy(); + var error2 = new Error("got illegal response body from proxy"); + error2.code = "ECONNRESET"; + options.request.emit("error", error2); + self.removeSocket(placeholder); + return; + } + debug("tunneling connection has established"); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + function onError(cause) { + connectReq.removeAllListeners(); + debug( + "tunneling socket could not be established, cause=%s\n", + cause.message, + cause.stack + ); + var error2 = new Error("tunneling socket could not be established, cause=" + cause.message); + error2.code = "ECONNRESET"; + options.request.emit("error", error2); + self.removeSocket(placeholder); + } + }; + TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket); + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + var pending = this.requests.shift(); + if (pending) { + this.createSocket(pending, function(socket2) { + pending.request.onSocket(socket2); + }); + } + }; + function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader("host"); + var tlsOptions = mergeOptions({}, self.options, { + socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host + }); + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); } - } - - get binaryType () { - webidl.brandCheck(this, WebSocket) - - return this[kBinaryType] - } - - set binaryType (type) { - webidl.brandCheck(this, WebSocket) - - if (type !== 'blob' && type !== 'arraybuffer') { - this[kBinaryType] = 'blob' + function toOptions(host, port, localAddress) { + if (typeof host === "string") { + return { + host, + port, + localAddress + }; + } + return host; + } + function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === "object") { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== void 0) { + target[k] = overrides[k]; + } + } + } + } + return target; + } + var debug; + if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === "string") { + args[0] = "TUNNEL: " + args[0]; + } else { + args.unshift("TUNNEL:"); + } + console.error.apply(console, args); + }; } else { - this[kBinaryType] = type + debug = function() { + }; } + exports2.debug = debug; } +}); - /** - * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol - */ - #onConnectionEstablished (response) { - // processResponse is called when the "response’s header list has been received and initialized." - // once this happens, the connection is open - this[kResponse] = response - - const parser = new ByteParser(this) - parser.on('drain', function onParserDrain () { - this.ws[kResponse].socket.resume() - }) - - response.socket.ws = this - this[kByteParser] = parser - - // 1. Change the ready state to OPEN (1). - this[kReadyState] = states.OPEN - - // 2. Change the extensions attribute’s value to the extensions in use, if - // it is not the null value. - // https://datatracker.ietf.org/doc/html/rfc6455#section-9.1 - const extensions = response.headersList.get('sec-websocket-extensions') - - if (extensions !== null) { - this.#extensions = extensions - } - - // 3. Change the protocol attribute’s value to the subprotocol in use, if - // it is not the null value. - // https://datatracker.ietf.org/doc/html/rfc6455#section-1.9 - const protocol = response.headersList.get('sec-websocket-protocol') - - if (protocol !== null) { - this.#protocol = protocol - } - - // 4. Fire an event named open at the WebSocket object. - fireEvent('open', this) +// node_modules/tunnel/index.js +var require_tunnel2 = __commonJS({ + "node_modules/tunnel/index.js"(exports2, module2) { + module2.exports = require_tunnel(); } -} - -// https://websockets.spec.whatwg.org/#dom-websocket-connecting -WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING -// https://websockets.spec.whatwg.org/#dom-websocket-open -WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN -// https://websockets.spec.whatwg.org/#dom-websocket-closing -WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING -// https://websockets.spec.whatwg.org/#dom-websocket-closed -WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED - -Object.defineProperties(WebSocket.prototype, { - CONNECTING: staticPropertyDescriptors, - OPEN: staticPropertyDescriptors, - CLOSING: staticPropertyDescriptors, - CLOSED: staticPropertyDescriptors, - url: kEnumerableProperty, - readyState: kEnumerableProperty, - bufferedAmount: kEnumerableProperty, - onopen: kEnumerableProperty, - onerror: kEnumerableProperty, - onclose: kEnumerableProperty, - close: kEnumerableProperty, - onmessage: kEnumerableProperty, - binaryType: kEnumerableProperty, - send: kEnumerableProperty, - extensions: kEnumerableProperty, - protocol: kEnumerableProperty, - [Symbol.toStringTag]: { - value: 'WebSocket', - writable: false, - enumerable: false, - configurable: true - } -}) - -Object.defineProperties(WebSocket, { - CONNECTING: staticPropertyDescriptors, - OPEN: staticPropertyDescriptors, - CLOSING: staticPropertyDescriptors, - CLOSED: staticPropertyDescriptors -}) - -webidl.converters['sequence'] = webidl.sequenceConverter( - webidl.converters.DOMString -) +}); -webidl.converters['DOMString or sequence'] = function (V) { - if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) { - return webidl.converters['sequence'](V) +// node_modules/undici/lib/core/symbols.js +var require_symbols = __commonJS({ + "node_modules/undici/lib/core/symbols.js"(exports2, module2) { + module2.exports = { + kClose: Symbol("close"), + kDestroy: Symbol("destroy"), + kDispatch: Symbol("dispatch"), + kUrl: Symbol("url"), + kWriting: Symbol("writing"), + kResuming: Symbol("resuming"), + kQueue: Symbol("queue"), + kConnect: Symbol("connect"), + kConnecting: Symbol("connecting"), + kHeadersList: Symbol("headers list"), + kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"), + kKeepAliveMaxTimeout: Symbol("max keep alive timeout"), + kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"), + kKeepAliveTimeoutValue: Symbol("keep alive timeout"), + kKeepAlive: Symbol("keep alive"), + kHeadersTimeout: Symbol("headers timeout"), + kBodyTimeout: Symbol("body timeout"), + kServerName: Symbol("server name"), + kLocalAddress: Symbol("local address"), + kHost: Symbol("host"), + kNoRef: Symbol("no ref"), + kBodyUsed: Symbol("used"), + kRunning: Symbol("running"), + kBlocking: Symbol("blocking"), + kPending: Symbol("pending"), + kSize: Symbol("size"), + kBusy: Symbol("busy"), + kQueued: Symbol("queued"), + kFree: Symbol("free"), + kConnected: Symbol("connected"), + kClosed: Symbol("closed"), + kNeedDrain: Symbol("need drain"), + kReset: Symbol("reset"), + kDestroyed: Symbol.for("nodejs.stream.destroyed"), + kMaxHeadersSize: Symbol("max headers size"), + kRunningIdx: Symbol("running index"), + kPendingIdx: Symbol("pending index"), + kError: Symbol("error"), + kClients: Symbol("clients"), + kClient: Symbol("client"), + kParser: Symbol("parser"), + kOnDestroyed: Symbol("destroy callbacks"), + kPipelining: Symbol("pipelining"), + kSocket: Symbol("socket"), + kHostHeader: Symbol("host header"), + kConnector: Symbol("connector"), + kStrictContentLength: Symbol("strict content length"), + kMaxRedirections: Symbol("maxRedirections"), + kMaxRequests: Symbol("maxRequestsPerClient"), + kProxy: Symbol("proxy agent options"), + kCounter: Symbol("socket request counter"), + kInterceptors: Symbol("dispatch interceptors"), + kMaxResponseSize: Symbol("max response size"), + kHTTP2Session: Symbol("http2Session"), + kHTTP2SessionState: Symbol("http2Session state"), + kHTTP2BuildRequest: Symbol("http2 build request"), + kHTTP1BuildRequest: Symbol("http1 build request"), + kHTTP2CopyHeaders: Symbol("http2 copy headers"), + kHTTPConnVersion: Symbol("http connection version"), + kRetryHandlerDefaultRetry: Symbol("retry agent default retry"), + kConstruct: Symbol("constructable") + }; } +}); - return webidl.converters.DOMString(V) -} - -// This implements the propsal made in https://github.com/whatwg/websockets/issues/42 -webidl.converters.WebSocketInit = webidl.dictionaryConverter([ - { - key: 'protocols', - converter: webidl.converters['DOMString or sequence'], - get defaultValue () { - return [] - } - }, - { - key: 'dispatcher', - converter: (V) => V, - get defaultValue () { - return getGlobalDispatcher() - } - }, - { - key: 'headers', - converter: webidl.nullableConverter(webidl.converters.HeadersInit) +// node_modules/undici/lib/core/errors.js +var require_errors2 = __commonJS({ + "node_modules/undici/lib/core/errors.js"(exports2, module2) { + "use strict"; + var UndiciError = class extends Error { + constructor(message) { + super(message); + this.name = "UndiciError"; + this.code = "UND_ERR"; + } + }; + var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ConnectTimeoutError); + this.name = "ConnectTimeoutError"; + this.message = message || "Connect Timeout Error"; + this.code = "UND_ERR_CONNECT_TIMEOUT"; + } + }; + var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersTimeoutError); + this.name = "HeadersTimeoutError"; + this.message = message || "Headers Timeout Error"; + this.code = "UND_ERR_HEADERS_TIMEOUT"; + } + }; + var HeadersOverflowError = class _HeadersOverflowError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersOverflowError); + this.name = "HeadersOverflowError"; + this.message = message || "Headers Overflow Error"; + this.code = "UND_ERR_HEADERS_OVERFLOW"; + } + }; + var BodyTimeoutError = class _BodyTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _BodyTimeoutError); + this.name = "BodyTimeoutError"; + this.message = message || "Body Timeout Error"; + this.code = "UND_ERR_BODY_TIMEOUT"; + } + }; + var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError { + constructor(message, statusCode, headers, body) { + super(message); + Error.captureStackTrace(this, _ResponseStatusCodeError); + this.name = "ResponseStatusCodeError"; + this.message = message || "Response Status Code Error"; + this.code = "UND_ERR_RESPONSE_STATUS_CODE"; + this.body = body; + this.status = statusCode; + this.statusCode = statusCode; + this.headers = headers; + } + }; + var InvalidArgumentError = class _InvalidArgumentError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidArgumentError); + this.name = "InvalidArgumentError"; + this.message = message || "Invalid Argument Error"; + this.code = "UND_ERR_INVALID_ARG"; + } + }; + var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidReturnValueError); + this.name = "InvalidReturnValueError"; + this.message = message || "Invalid Return Value Error"; + this.code = "UND_ERR_INVALID_RETURN_VALUE"; + } + }; + var RequestAbortedError = class _RequestAbortedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestAbortedError); + this.name = "AbortError"; + this.message = message || "Request aborted"; + this.code = "UND_ERR_ABORTED"; + } + }; + var InformationalError = class _InformationalError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InformationalError); + this.name = "InformationalError"; + this.message = message || "Request information"; + this.code = "UND_ERR_INFO"; + } + }; + var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestContentLengthMismatchError); + this.name = "RequestContentLengthMismatchError"; + this.message = message || "Request body length does not match content-length header"; + this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"; + } + }; + var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseContentLengthMismatchError); + this.name = "ResponseContentLengthMismatchError"; + this.message = message || "Response body length does not match content-length header"; + this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"; + } + }; + var ClientDestroyedError = class _ClientDestroyedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientDestroyedError); + this.name = "ClientDestroyedError"; + this.message = message || "The client is destroyed"; + this.code = "UND_ERR_DESTROYED"; + } + }; + var ClientClosedError = class _ClientClosedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientClosedError); + this.name = "ClientClosedError"; + this.message = message || "The client is closed"; + this.code = "UND_ERR_CLOSED"; + } + }; + var SocketError = class _SocketError extends UndiciError { + constructor(message, socket) { + super(message); + Error.captureStackTrace(this, _SocketError); + this.name = "SocketError"; + this.message = message || "Socket error"; + this.code = "UND_ERR_SOCKET"; + this.socket = socket; + } + }; + var NotSupportedError = class _NotSupportedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _NotSupportedError); + this.name = "NotSupportedError"; + this.message = message || "Not supported error"; + this.code = "UND_ERR_NOT_SUPPORTED"; + } + }; + var BalancedPoolMissingUpstreamError = class extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, NotSupportedError); + this.name = "MissingUpstreamError"; + this.message = message || "No upstream has been added to the BalancedPool"; + this.code = "UND_ERR_BPL_MISSING_UPSTREAM"; + } + }; + var HTTPParserError = class _HTTPParserError extends Error { + constructor(message, code, data) { + super(message); + Error.captureStackTrace(this, _HTTPParserError); + this.name = "HTTPParserError"; + this.code = code ? `HPE_${code}` : void 0; + this.data = data ? data.toString() : void 0; + } + }; + var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseExceededMaxSizeError); + this.name = "ResponseExceededMaxSizeError"; + this.message = message || "Response content exceeded max size"; + this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE"; + } + }; + var RequestRetryError = class _RequestRetryError extends UndiciError { + constructor(message, code, { headers, data }) { + super(message); + Error.captureStackTrace(this, _RequestRetryError); + this.name = "RequestRetryError"; + this.message = message || "Request retry error"; + this.code = "UND_ERR_REQ_RETRY"; + this.statusCode = code; + this.data = data; + this.headers = headers; + } + }; + module2.exports = { + HTTPParserError, + UndiciError, + HeadersTimeoutError, + HeadersOverflowError, + BodyTimeoutError, + RequestContentLengthMismatchError, + ConnectTimeoutError, + ResponseStatusCodeError, + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError, + ClientDestroyedError, + ClientClosedError, + InformationalError, + SocketError, + NotSupportedError, + ResponseContentLengthMismatchError, + BalancedPoolMissingUpstreamError, + ResponseExceededMaxSizeError, + RequestRetryError + }; } -]) +}); -webidl.converters['DOMString or sequence or WebSocketInit'] = function (V) { - if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) { - return webidl.converters.WebSocketInit(V) +// node_modules/undici/lib/core/constants.js +var require_constants = __commonJS({ + "node_modules/undici/lib/core/constants.js"(exports2, module2) { + "use strict"; + var headerNameLowerCasedRecord = {}; + var wellknownHeaderNames = [ + "Accept", + "Accept-Encoding", + "Accept-Language", + "Accept-Ranges", + "Access-Control-Allow-Credentials", + "Access-Control-Allow-Headers", + "Access-Control-Allow-Methods", + "Access-Control-Allow-Origin", + "Access-Control-Expose-Headers", + "Access-Control-Max-Age", + "Access-Control-Request-Headers", + "Access-Control-Request-Method", + "Age", + "Allow", + "Alt-Svc", + "Alt-Used", + "Authorization", + "Cache-Control", + "Clear-Site-Data", + "Connection", + "Content-Disposition", + "Content-Encoding", + "Content-Language", + "Content-Length", + "Content-Location", + "Content-Range", + "Content-Security-Policy", + "Content-Security-Policy-Report-Only", + "Content-Type", + "Cookie", + "Cross-Origin-Embedder-Policy", + "Cross-Origin-Opener-Policy", + "Cross-Origin-Resource-Policy", + "Date", + "Device-Memory", + "Downlink", + "ECT", + "ETag", + "Expect", + "Expect-CT", + "Expires", + "Forwarded", + "From", + "Host", + "If-Match", + "If-Modified-Since", + "If-None-Match", + "If-Range", + "If-Unmodified-Since", + "Keep-Alive", + "Last-Modified", + "Link", + "Location", + "Max-Forwards", + "Origin", + "Permissions-Policy", + "Pragma", + "Proxy-Authenticate", + "Proxy-Authorization", + "RTT", + "Range", + "Referer", + "Referrer-Policy", + "Refresh", + "Retry-After", + "Sec-WebSocket-Accept", + "Sec-WebSocket-Extensions", + "Sec-WebSocket-Key", + "Sec-WebSocket-Protocol", + "Sec-WebSocket-Version", + "Server", + "Server-Timing", + "Service-Worker-Allowed", + "Service-Worker-Navigation-Preload", + "Set-Cookie", + "SourceMap", + "Strict-Transport-Security", + "Supports-Loading-Mode", + "TE", + "Timing-Allow-Origin", + "Trailer", + "Transfer-Encoding", + "Upgrade", + "Upgrade-Insecure-Requests", + "User-Agent", + "Vary", + "Via", + "WWW-Authenticate", + "X-Content-Type-Options", + "X-DNS-Prefetch-Control", + "X-Frame-Options", + "X-Permitted-Cross-Domain-Policies", + "X-Powered-By", + "X-Requested-With", + "X-XSS-Protection" + ]; + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = wellknownHeaderNames[i]; + const lowerCasedKey = key.toLowerCase(); + headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey; + } + Object.setPrototypeOf(headerNameLowerCasedRecord, null); + module2.exports = { + wellknownHeaderNames, + headerNameLowerCasedRecord + }; } +}); - return { protocols: webidl.converters['DOMString or sequence'](V) } -} - -webidl.converters.WebSocketSendData = function (V) { - if (webidl.util.Type(V) === 'Object') { - if (isBlobLike(V)) { - return webidl.converters.Blob(V, { strict: false }) +// node_modules/undici/lib/core/util.js +var require_util = __commonJS({ + "node_modules/undici/lib/core/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { kDestroyed, kBodyUsed } = require_symbols(); + var { IncomingMessage } = require("http"); + var stream = require("stream"); + var net = require("net"); + var { InvalidArgumentError } = require_errors2(); + var { Blob: Blob2 } = require("buffer"); + var nodeUtil = require("util"); + var { stringify: stringify2 } = require("querystring"); + var { headerNameLowerCasedRecord } = require_constants(); + var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v)); + function nop() { } - - if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { - return webidl.converters.BufferSource(V) + function isStream(obj) { + return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; } - } - - return webidl.converters.USVString(V) -} - -module.exports = { - WebSocket -} - - -/***/ }), - -/***/ 98: -/***/ (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.isValidConventionalCommitMessage = void 0; -exports.main = main; -const node_console_1 = __nccwpck_require__(7540); -const node_fs_1 = __nccwpck_require__(3024); -const yaml_1 = __importDefault(__nccwpck_require__(8815)); -const core_1 = __nccwpck_require__(7484); -const sdk_1 = __importDefault(__nccwpck_require__(6563)); -// https://www.conventionalcommits.org/en/v1.0.0/ -const CONVENTIONAL_COMMIT_REGEX = new RegExp(/^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?(!?): .*$/); -const isValidConventionalCommitMessage = (message) => { - return CONVENTIONAL_COMMIT_REGEX.test(message); -}; -exports.isValidConventionalCommitMessage = isValidConventionalCommitMessage; -// Detect if running in GitHub Actions or GitLab CI -function isGitLabCI() { - return process.env["GITLAB_CI"] === "true"; -} -// Get input values from either GitHub Actions or GitLab CI environment -function getInputValue(name, options) { - if (isGitLabCI()) { - // Try GitLab-specific INPUT_ prefixed variable first (like GitHub Actions) - const inputEnvName = `INPUT_${name.toUpperCase()}`; - const inputValue = process.env[inputEnvName]; - // Fall back to direct name for backward compatibility - const directEnvName = name.toUpperCase(); - const directValue = process.env[directEnvName]; - const value = inputValue || directValue; - if ((options === null || options === void 0 ? void 0 : options.required) && !value) { - throw new Error(`Input required and not supplied: ${name}`); - } - return value || ""; - } - else { - return (0, core_1.getInput)(name, options); + function isBlobLike2(object) { + return Blob2 && object instanceof Blob2 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]); } -} -// Get boolean input values from either GitHub Actions or GitLab CI environment -function getBooleanInputValue(name, options) { - var _a, _b; - if (isGitLabCI()) { - // Try GitLab-specific INPUT_ prefixed variable first (like GitHub Actions) - const inputEnvName = `INPUT_${name.toUpperCase()}`; - const inputValue = (_a = process.env[inputEnvName]) === null || _a === void 0 ? void 0 : _a.toLowerCase(); - // Fall back to direct name for backward compatibility - const directEnvName = name.toUpperCase(); - const directValue = (_b = process.env[directEnvName]) === null || _b === void 0 ? void 0 : _b.toLowerCase(); - const value = inputValue || directValue; - if ((options === null || options === void 0 ? void 0 : options.required) && value === undefined) { - throw new Error(`Input required and not supplied: ${name}`); - } - return value === "true"; - } - else { - return (0, core_1.getBooleanInput)(name, options); + function buildURL(url, queryParams) { + if (url.includes("?") || url.includes("#")) { + throw new Error('Query params cannot be passed when url already contains "?" or "#".'); + } + const stringified = stringify2(queryParams); + if (stringified) { + url += "?" + stringified; + } + return url; } -} -function main() { - return __awaiter(this, void 0, void 0, function* () { - // inputs - const stainless_api_key = getInputValue("stainless_api_key", { - required: true, - }); - const inputPath = getInputValue("input_path", { required: true }); - const configPath = getInputValue("config_path", { required: false }); - let projectName = getInputValue("project_name", { required: false }); - const commitMessage = getInputValue("commit_message", { required: false }); - const guessConfig = getBooleanInputValue("guess_config", { required: false }); - const branch = getInputValue("branch", { required: false }); - const outputPath = getInputValue("output_path"); - if (configPath && guessConfig) { - const errorMsg = "Can't set both configPath and guessConfig"; - (0, node_console_1.error)(errorMsg); - throw Error(errorMsg); - } - if (commitMessage && !(0, exports.isValidConventionalCommitMessage)(commitMessage)) { - const errorMsg = "Invalid commit message format. Please follow the Conventional Commits format: https://www.conventionalcommits.org/en/v1.0.0/"; - (0, node_console_1.error)(errorMsg); - throw Error(errorMsg); - } - if (!projectName) { - const stainless = new sdk_1.default({ apiKey: stainless_api_key }); - const projects = yield stainless.projects.list({ limit: 2 }); - if (projects.data.length === 0) { - const errorMsg = "No projects found. Please create a project first."; - (0, node_console_1.error)(errorMsg); - throw Error(errorMsg); - } - projectName = projects.data[0].slug; - if (projects.data.length > 1) { - (0, node_console_1.warn)(`Multiple projects found. Using ${projectName} as default, but we recommend specifying the project name in the inputs.`); - } + function parseURL(url) { + if (typeof url === "string") { + url = new URL(url); + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); } - (0, node_console_1.info)(configPath - ? "Uploading spec and config files..." - : "Uploading spec file..."); - const response = yield uploadSpecAndConfig(inputPath, configPath, stainless_api_key, projectName, commitMessage, guessConfig, branch); - if (!response.ok) { - const errorMsg = `Build failed with the following outcomes: ${JSON.stringify(response.errors)} See more details in the Stainless Studio.`; - (0, node_console_1.error)(errorMsg); - throw Error(errorMsg); - } - (0, node_console_1.info)("Uploaded!"); - if (outputPath) { - if (!response.decoratedSpec) { - const errorMsg = "Failed to get decorated spec"; - (0, node_console_1.error)(errorMsg); - throw Error(errorMsg); - } - // Decorated spec is currently always YAML, so convert it to JSON if needed. - if (!(outputPath.endsWith(".yml") || outputPath.endsWith(".yaml"))) { - response.decoratedSpec = JSON.stringify(yaml_1.default.parse(response.decoratedSpec), null, 2); - } - (0, node_fs_1.writeFileSync)(outputPath, response.decoratedSpec); - (0, node_console_1.info)("Wrote decorated spec to", outputPath); + return url; + } + if (!url || typeof url !== "object") { + throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object."); + } + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + if (!(url instanceof URL)) { + if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) { + throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer."); } - }); -} -function uploadSpecAndConfig(specPath, configPath, token, projectName, commitMessage, guessConfig, branch) { - return __awaiter(this, void 0, void 0, function* () { - var _a; - const stainless = new sdk_1.default({ apiKey: token, project: projectName }); - const specContent = (0, node_fs_1.readFileSync)(specPath, "utf8"); - let configContent; - if (guessConfig) { - configContent = (_a = Object.values(yield stainless.projects.configs.guess({ - branch, - spec: specContent, - }))[0]) === null || _a === void 0 ? void 0 : _a.content; - } - else if (configPath) { - configContent = (0, node_fs_1.readFileSync)(configPath, "utf8"); + if (url.path != null && typeof url.path !== "string") { + throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined."); } - const headers = {}; - if (isGitLabCI()) { - headers["X-GitLab-CI"] = "stainless-api/upload-openapi-spec-action"; + if (url.pathname != null && typeof url.pathname !== "string") { + throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined."); } - else { - headers["X-GitHub-Action"] = "stainless-api/upload-openapi-spec-action"; - } - let build = yield stainless.builds.create(Object.assign(Object.assign(Object.assign({}, (branch && { branch })), (commitMessage && { commit_message: commitMessage })), { revision: Object.assign({ "openapi.yml": { content: specContent } }, (configContent && { - "openapi.stainless.yml": { content: configContent }, - })), allow_empty: true }), { headers }); - const pollingStart = Date.now(); - let donePolling = false; - while (!donePolling && Date.now() - pollingStart < 10 * 60 * 1000) { - build = yield stainless.builds.retrieve(build.id); - donePolling = Object.values(build.targets).every((target) => target.commit.status === "completed"); - if (!donePolling) { - yield new Promise((resolve) => setTimeout(resolve, 5 * 1000)); - } + if (url.hostname != null && typeof url.hostname !== "string") { + throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined."); } - const errors = Object.entries(build.targets) - .map(([target, value]) => { - var _a, _b; - if ( - // The remaining possible conclusions ('merge_conflict', 'fatal', 'payment_required', etc.) should - // all be considered failures. - ((_a = value.commit) === null || _a === void 0 ? void 0 : _a.status) === "completed" && - ["noop", "error", "warning", "note", "success"].includes(value.commit.completed.conclusion)) { - return undefined; - } - else if (((_b = value.commit) === null || _b === void 0 ? void 0 : _b.status) === "completed") { - return { - target, - outcome: value.commit.completed.conclusion, - }; - } - else { - return { - target, - outcome: "timed_out", - }; - } - }) - .filter((e) => e !== undefined); - const ok = errors.length === 0; - const decoratedSpec = yield sdk_1.default.unwrapFile(build.documented_spec); - return { ok, errors, decoratedSpec }; - }); -} -if (require.main === require.cache[eval('__filename')]) { - main().catch((err) => { - console.error(err); - process.exit(1); - }); -} - - -/***/ }), - -/***/ 2613: -/***/ ((module) => { - -"use strict"; -module.exports = require("assert"); - -/***/ }), - -/***/ 290: -/***/ ((module) => { - -"use strict"; -module.exports = require("async_hooks"); - -/***/ }), - -/***/ 181: -/***/ ((module) => { - -"use strict"; -module.exports = require("buffer"); - -/***/ }), - -/***/ 5317: -/***/ ((module) => { - -"use strict"; -module.exports = require("child_process"); - -/***/ }), - -/***/ 4236: -/***/ ((module) => { - -"use strict"; -module.exports = require("console"); - -/***/ }), - -/***/ 6982: -/***/ ((module) => { - -"use strict"; -module.exports = require("crypto"); - -/***/ }), - -/***/ 1637: -/***/ ((module) => { - -"use strict"; -module.exports = require("diagnostics_channel"); - -/***/ }), - -/***/ 4434: -/***/ ((module) => { - -"use strict"; -module.exports = require("events"); - -/***/ }), - -/***/ 9896: -/***/ ((module) => { - -"use strict"; -module.exports = require("fs"); - -/***/ }), - -/***/ 8611: -/***/ ((module) => { - -"use strict"; -module.exports = require("http"); - -/***/ }), - -/***/ 5675: -/***/ ((module) => { - -"use strict"; -module.exports = require("http2"); - -/***/ }), - -/***/ 5692: -/***/ ((module) => { - -"use strict"; -module.exports = require("https"); - -/***/ }), - -/***/ 9278: -/***/ ((module) => { - -"use strict"; -module.exports = require("net"); - -/***/ }), - -/***/ 7540: -/***/ ((module) => { - -"use strict"; -module.exports = require("node:console"); - -/***/ }), - -/***/ 7598: -/***/ ((module) => { - -"use strict"; -module.exports = require("node:crypto"); - -/***/ }), - -/***/ 8474: -/***/ ((module) => { - -"use strict"; -module.exports = require("node:events"); - -/***/ }), - -/***/ 3024: -/***/ ((module) => { - -"use strict"; -module.exports = require("node:fs"); - -/***/ }), - -/***/ 7075: -/***/ ((module) => { - -"use strict"; -module.exports = require("node:stream"); - -/***/ }), - -/***/ 7975: -/***/ ((module) => { - -"use strict"; -module.exports = require("node:util"); - -/***/ }), - -/***/ 857: -/***/ ((module) => { - -"use strict"; -module.exports = require("os"); - -/***/ }), - -/***/ 6928: -/***/ ((module) => { - -"use strict"; -module.exports = require("path"); - -/***/ }), - -/***/ 2987: -/***/ ((module) => { - -"use strict"; -module.exports = require("perf_hooks"); - -/***/ }), - -/***/ 932: -/***/ ((module) => { - -"use strict"; -module.exports = require("process"); - -/***/ }), - -/***/ 3480: -/***/ ((module) => { - -"use strict"; -module.exports = require("querystring"); - -/***/ }), - -/***/ 2203: -/***/ ((module) => { - -"use strict"; -module.exports = require("stream"); - -/***/ }), - -/***/ 3774: -/***/ ((module) => { - -"use strict"; -module.exports = require("stream/web"); - -/***/ }), - -/***/ 3193: -/***/ ((module) => { - -"use strict"; -module.exports = require("string_decoder"); - -/***/ }), - -/***/ 3557: -/***/ ((module) => { - -"use strict"; -module.exports = require("timers"); - -/***/ }), - -/***/ 4756: -/***/ ((module) => { - -"use strict"; -module.exports = require("tls"); - -/***/ }), - -/***/ 7016: -/***/ ((module) => { - -"use strict"; -module.exports = require("url"); - -/***/ }), - -/***/ 9023: -/***/ ((module) => { - -"use strict"; -module.exports = require("util"); - -/***/ }), - -/***/ 8253: -/***/ ((module) => { - -"use strict"; -module.exports = require("util/types"); - -/***/ }), - -/***/ 8167: -/***/ ((module) => { - -"use strict"; -module.exports = require("worker_threads"); - -/***/ }), - -/***/ 3106: -/***/ ((module) => { - -"use strict"; -module.exports = require("zlib"); - -/***/ }), - -/***/ 7182: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const WritableStream = (__nccwpck_require__(7075).Writable) -const inherits = (__nccwpck_require__(7975).inherits) - -const StreamSearch = __nccwpck_require__(4136) - -const PartStream = __nccwpck_require__(612) -const HeaderParser = __nccwpck_require__(2271) - -const DASH = 45 -const B_ONEDASH = Buffer.from('-') -const B_CRLF = Buffer.from('\r\n') -const EMPTY_FN = function () {} - -function Dicer (cfg) { - if (!(this instanceof Dicer)) { return new Dicer(cfg) } - WritableStream.call(this, cfg) - - if (!cfg || (!cfg.headerFirst && typeof cfg.boundary !== 'string')) { throw new TypeError('Boundary required') } - - if (typeof cfg.boundary === 'string') { this.setBoundary(cfg.boundary) } else { this._bparser = undefined } - - this._headerFirst = cfg.headerFirst - - this._dashes = 0 - this._parts = 0 - this._finished = false - this._realFinish = false - this._isPreamble = true - this._justMatched = false - this._firstWrite = true - this._inHeader = true - this._part = undefined - this._cb = undefined - this._ignoreData = false - this._partOpts = { highWaterMark: cfg.partHwm } - this._pause = false - - const self = this - this._hparser = new HeaderParser(cfg) - this._hparser.on('header', function (header) { - self._inHeader = false - self._part.emit('header', header) - }) -} -inherits(Dicer, WritableStream) - -Dicer.prototype.emit = function (ev) { - if (ev === 'finish' && !this._realFinish) { - if (!this._finished) { - const self = this - process.nextTick(function () { - self.emit('error', new Error('Unexpected end of multipart data')) - if (self._part && !self._ignoreData) { - const type = (self._isPreamble ? 'Preamble' : 'Part') - self._part.emit('error', new Error(type + ' terminated early due to unexpected end of multipart data')) - self._part.push(null) - process.nextTick(function () { - self._realFinish = true - self.emit('finish') - self._realFinish = false - }) - return + if (url.origin != null && typeof url.origin !== "string") { + throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined."); + } + const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; + let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`; + let path2 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; + if (origin.endsWith("/")) { + origin = origin.substring(0, origin.length - 1); } - self._realFinish = true - self.emit('finish') - self._realFinish = false - }) + if (path2 && !path2.startsWith("/")) { + path2 = `/${path2}`; + } + url = new URL(origin + path2); + } + return url; } - } else { WritableStream.prototype.emit.apply(this, arguments) } -} - -Dicer.prototype._write = function (data, encoding, cb) { - // ignore unexpected data (e.g. extra trailer data after finished) - if (!this._hparser && !this._bparser) { return cb() } - - if (this._headerFirst && this._isPreamble) { - if (!this._part) { - this._part = new PartStream(this._partOpts) - if (this.listenerCount('preamble') !== 0) { this.emit('preamble', this._part) } else { this._ignore() } + function parseOrigin(url) { + url = parseURL(url); + if (url.pathname !== "/" || url.search || url.hash) { + throw new InvalidArgumentError("invalid url"); + } + return url; + } + function getHostname(host) { + if (host[0] === "[") { + const idx2 = host.indexOf("]"); + assert(idx2 !== -1); + return host.substring(1, idx2); + } + const idx = host.indexOf(":"); + if (idx === -1) return host; + return host.substring(0, idx); + } + function getServerName(host) { + if (!host) { + return null; + } + assert.strictEqual(typeof host, "string"); + const servername = getHostname(host); + if (net.isIP(servername)) { + return ""; + } + return servername; + } + function deepClone(obj) { + return JSON.parse(JSON.stringify(obj)); + } + function isAsyncIterable2(obj) { + return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function"); + } + function isIterable(obj) { + return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function")); + } + function bodyLength(body) { + if (body == null) { + return 0; + } else if (isStream(body)) { + const state = body._readableState; + return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; + } else if (isBlobLike2(body)) { + return body.size != null ? body.size : null; + } else if (isBuffer(body)) { + return body.byteLength; + } + return null; + } + function isDestroyed(stream2) { + return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]); + } + function isReadableAborted(stream2) { + const state = stream2 && stream2._readableState; + return isDestroyed(stream2) && state && !state.endEmitted; + } + function destroy(stream2, err) { + if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) { + return; + } + if (typeof stream2.destroy === "function") { + if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) { + stream2.socket = null; + } + stream2.destroy(err); + } else if (err) { + process.nextTick((stream3, err2) => { + stream3.emit("error", err2); + }, stream2, err); + } + if (stream2.destroyed !== true) { + stream2[kDestroyed] = true; + } + } + var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/; + function parseKeepAliveTimeout(val) { + const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR); + return m ? parseInt(m[1], 10) * 1e3 : null; + } + function headerNameToString(value) { + return headerNameLowerCasedRecord[value] || value.toLowerCase(); + } + function parseHeaders(headers, obj = {}) { + if (!Array.isArray(headers)) return headers; + for (let i = 0; i < headers.length; i += 2) { + const key = headers[i].toString().toLowerCase(); + let val = obj[key]; + if (!val) { + if (Array.isArray(headers[i + 1])) { + obj[key] = headers[i + 1].map((x) => x.toString("utf8")); + } else { + obj[key] = headers[i + 1].toString("utf8"); + } + } else { + if (!Array.isArray(val)) { + val = [val]; + obj[key] = val; + } + val.push(headers[i + 1].toString("utf8")); + } + } + if ("content-length" in obj && "content-disposition" in obj) { + obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1"); + } + return obj; + } + function parseRawHeaders(headers) { + const ret = []; + let hasContentLength = false; + let contentDispositionIdx = -1; + for (let n = 0; n < headers.length; n += 2) { + const key = headers[n + 0].toString(); + const val = headers[n + 1].toString("utf8"); + if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) { + ret.push(key, val); + hasContentLength = true; + } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) { + contentDispositionIdx = ret.push(key, val) - 1; + } else { + ret.push(key, val); + } + } + if (hasContentLength && contentDispositionIdx !== -1) { + ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1"); + } + return ret; + } + function isBuffer(buffer) { + return buffer instanceof Uint8Array || Buffer.isBuffer(buffer); + } + function validateHandler(handler, method, upgrade) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + if (typeof handler.onConnect !== "function") { + throw new InvalidArgumentError("invalid onConnect method"); + } + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) { + throw new InvalidArgumentError("invalid onBodySent method"); + } + if (upgrade || method === "CONNECT") { + if (typeof handler.onUpgrade !== "function") { + throw new InvalidArgumentError("invalid onUpgrade method"); + } + } else { + if (typeof handler.onHeaders !== "function") { + throw new InvalidArgumentError("invalid onHeaders method"); + } + if (typeof handler.onData !== "function") { + throw new InvalidArgumentError("invalid onData method"); + } + if (typeof handler.onComplete !== "function") { + throw new InvalidArgumentError("invalid onComplete method"); + } + } + } + function isDisturbed(body) { + return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body))); + } + function isErrored(body) { + return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test( + nodeUtil.inspect(body) + ))); + } + function isReadable(body) { + return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test( + nodeUtil.inspect(body) + ))); + } + function getSocketInfo(socket) { + return { + localAddress: socket.localAddress, + localPort: socket.localPort, + remoteAddress: socket.remoteAddress, + remotePort: socket.remotePort, + remoteFamily: socket.remoteFamily, + timeout: socket.timeout, + bytesWritten: socket.bytesWritten, + bytesRead: socket.bytesRead + }; + } + async function* convertIterableToBuffer(iterable) { + for await (const chunk of iterable) { + yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk); + } + } + var ReadableStream; + function ReadableStreamFrom2(iterable) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (ReadableStream.from) { + return ReadableStream.from(convertIterableToBuffer(iterable)); + } + let iterator; + return new ReadableStream( + { + async start() { + iterator = iterable[Symbol.asyncIterator](); + }, + async pull(controller) { + const { done, value } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + const buf = Buffer.isBuffer(value) ? value : Buffer.from(value); + controller.enqueue(new Uint8Array(buf)); + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + } + }, + 0 + ); + } + function isFormDataLike(object) { + return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData"; + } + function throwIfAborted(signal) { + if (!signal) { + return; + } + if (typeof signal.throwIfAborted === "function") { + signal.throwIfAborted(); + } else { + if (signal.aborted) { + const err = new Error("The operation was aborted"); + err.name = "AbortError"; + throw err; + } + } + } + function addAbortListener(signal, listener) { + if ("addEventListener" in signal) { + signal.addEventListener("abort", listener, { once: true }); + return () => signal.removeEventListener("abort", listener); + } + signal.addListener("abort", listener); + return () => signal.removeListener("abort", listener); + } + var hasToWellFormed = !!String.prototype.toWellFormed; + function toUSVString(val) { + if (hasToWellFormed) { + return `${val}`.toWellFormed(); + } else if (nodeUtil.toUSVString) { + return nodeUtil.toUSVString(val); + } + return `${val}`; } - const r = this._hparser.push(data) - if (!this._inHeader && r !== undefined && r < data.length) { data = data.slice(r) } else { return cb() } + function parseRangeHeader(range) { + if (range == null || range === "") return { start: 0, end: null, size: null }; + const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null; + return m ? { + start: parseInt(m[1]), + end: m[2] ? parseInt(m[2]) : null, + size: m[3] ? parseInt(m[3]) : null + } : null; + } + var kEnumerableProperty = /* @__PURE__ */ Object.create(null); + kEnumerableProperty.enumerable = true; + module2.exports = { + kEnumerableProperty, + nop, + isDisturbed, + isErrored, + isReadable, + toUSVString, + isReadableAborted, + isBlobLike: isBlobLike2, + parseOrigin, + parseURL, + getServerName, + isStream, + isIterable, + isAsyncIterable: isAsyncIterable2, + isDestroyed, + headerNameToString, + parseRawHeaders, + parseHeaders, + parseKeepAliveTimeout, + destroy, + bodyLength, + deepClone, + ReadableStreamFrom: ReadableStreamFrom2, + isBuffer, + validateHandler, + getSocketInfo, + isFormDataLike, + buildURL, + throwIfAborted, + addAbortListener, + parseRangeHeader, + nodeMajor, + nodeMinor, + nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13, + safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"] + }; } +}); - // allows for "easier" testing - if (this._firstWrite) { - this._bparser.push(B_CRLF) - this._firstWrite = false +// node_modules/undici/lib/timers.js +var require_timers = __commonJS({ + "node_modules/undici/lib/timers.js"(exports2, module2) { + "use strict"; + var fastNow = Date.now(); + var fastNowTimeout; + var fastTimers = []; + function onTimeout() { + fastNow = Date.now(); + let len = fastTimers.length; + let idx = 0; + while (idx < len) { + const timer = fastTimers[idx]; + if (timer.state === 0) { + timer.state = fastNow + timer.delay; + } else if (timer.state > 0 && fastNow >= timer.state) { + timer.state = -1; + timer.callback(timer.opaque); + } + if (timer.state === -1) { + timer.state = -2; + if (idx !== len - 1) { + fastTimers[idx] = fastTimers.pop(); + } else { + fastTimers.pop(); + } + len -= 1; + } else { + idx += 1; + } + } + if (fastTimers.length > 0) { + refreshTimeout(); + } + } + function refreshTimeout() { + if (fastNowTimeout && fastNowTimeout.refresh) { + fastNowTimeout.refresh(); + } else { + clearTimeout(fastNowTimeout); + fastNowTimeout = setTimeout(onTimeout, 1e3); + if (fastNowTimeout.unref) { + fastNowTimeout.unref(); + } + } + } + var Timeout = class { + constructor(callback, delay, opaque) { + this.callback = callback; + this.delay = delay; + this.opaque = opaque; + this.state = -2; + this.refresh(); + } + refresh() { + if (this.state === -2) { + fastTimers.push(this); + if (!fastNowTimeout || fastTimers.length === 1) { + refreshTimeout(); + } + } + this.state = 0; + } + clear() { + this.state = -1; + } + }; + module2.exports = { + setTimeout(callback, delay, opaque) { + return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque); + }, + clearTimeout(timeout) { + if (timeout instanceof Timeout) { + timeout.clear(); + } else { + clearTimeout(timeout); + } + } + }; } +}); - this._bparser.push(data) +// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js +var require_sbmh = __commonJS({ + "node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + function SBMH(needle) { + if (typeof needle === "string") { + needle = Buffer.from(needle); + } + if (!Buffer.isBuffer(needle)) { + throw new TypeError("The needle has to be a String or a Buffer."); + } + const needleLength = needle.length; + if (needleLength === 0) { + throw new Error("The needle cannot be an empty String/Buffer."); + } + if (needleLength > 256) { + throw new Error("The needle cannot have a length bigger than 256."); + } + this.maxMatches = Infinity; + this.matches = 0; + this._occ = new Array(256).fill(needleLength); + this._lookbehind_size = 0; + this._needle = needle; + this._bufpos = 0; + this._lookbehind = Buffer.alloc(needleLength); + for (var i = 0; i < needleLength - 1; ++i) { + this._occ[needle[i]] = needleLength - 1 - i; + } + } + inherits(SBMH, EventEmitter); + SBMH.prototype.reset = function() { + this._lookbehind_size = 0; + this.matches = 0; + this._bufpos = 0; + }; + SBMH.prototype.push = function(chunk, pos) { + if (!Buffer.isBuffer(chunk)) { + chunk = Buffer.from(chunk, "binary"); + } + const chlen = chunk.length; + this._bufpos = pos || 0; + let r; + while (r !== chlen && this.matches < this.maxMatches) { + r = this._sbmh_feed(chunk); + } + return r; + }; + SBMH.prototype._sbmh_feed = function(data) { + const len = data.length; + const needle = this._needle; + const needleLength = needle.length; + const lastNeedleChar = needle[needleLength - 1]; + let pos = -this._lookbehind_size; + let ch; + if (pos < 0) { + while (pos < 0 && pos <= len - needleLength) { + ch = this._sbmh_lookup_char(data, pos + needleLength - 1); + if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) { + this._lookbehind_size = 0; + ++this.matches; + this.emit("info", true); + return this._bufpos = pos + needleLength; + } + pos += this._occ[ch]; + } + if (pos < 0) { + while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { + ++pos; + } + } + if (pos >= 0) { + this.emit("info", false, this._lookbehind, 0, this._lookbehind_size); + this._lookbehind_size = 0; + } else { + const bytesToCutOff = this._lookbehind_size + pos; + if (bytesToCutOff > 0) { + this.emit("info", false, this._lookbehind, 0, bytesToCutOff); + } + this._lookbehind.copy( + this._lookbehind, + 0, + bytesToCutOff, + this._lookbehind_size - bytesToCutOff + ); + this._lookbehind_size -= bytesToCutOff; + data.copy(this._lookbehind, this._lookbehind_size); + this._lookbehind_size += len; + this._bufpos = len; + return len; + } + } + pos += (pos >= 0) * this._bufpos; + if (data.indexOf(needle, pos) !== -1) { + pos = data.indexOf(needle, pos); + ++this.matches; + if (pos > 0) { + this.emit("info", true, data, this._bufpos, pos); + } else { + this.emit("info", true); + } + return this._bufpos = pos + needleLength; + } else { + pos = len - needleLength; + } + while (pos < len && (data[pos] !== needle[0] || Buffer.compare( + data.subarray(pos, pos + len - pos), + needle.subarray(0, len - pos) + ) !== 0)) { + ++pos; + } + if (pos < len) { + data.copy(this._lookbehind, 0, pos, pos + (len - pos)); + this._lookbehind_size = len - pos; + } + if (pos > 0) { + this.emit("info", false, data, this._bufpos, pos < len ? pos : len); + } + this._bufpos = len; + return len; + }; + SBMH.prototype._sbmh_lookup_char = function(data, pos) { + return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos]; + }; + SBMH.prototype._sbmh_memcmp = function(data, pos, len) { + for (var i = 0; i < len; ++i) { + if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { + return false; + } + } + return true; + }; + module2.exports = SBMH; + } +}); - if (this._pause) { this._cb = cb } else { cb() } -} +// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js +var require_PartStream = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) { + "use strict"; + var inherits = require("node:util").inherits; + var ReadableStream = require("node:stream").Readable; + function PartStream(opts) { + ReadableStream.call(this, opts); + } + inherits(PartStream, ReadableStream); + PartStream.prototype._read = function(n) { + }; + module2.exports = PartStream; + } +}); -Dicer.prototype.reset = function () { - this._part = undefined - this._bparser = undefined - this._hparser = undefined -} +// node_modules/@fastify/busboy/lib/utils/getLimit.js +var require_getLimit = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) { + "use strict"; + module2.exports = function getLimit(limits, name, defaultLimit) { + if (!limits || limits[name] === void 0 || limits[name] === null) { + return defaultLimit; + } + if (typeof limits[name] !== "number" || isNaN(limits[name])) { + throw new TypeError("Limit " + name + " is not a valid number"); + } + return limits[name]; + }; + } +}); -Dicer.prototype.setBoundary = function (boundary) { - const self = this - this._bparser = new StreamSearch('\r\n--' + boundary) - this._bparser.on('info', function (isMatch, data, start, end) { - self._oninfo(isMatch, data, start, end) - }) -} +// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js +var require_HeaderParser = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + var getLimit = require_getLimit(); + var StreamSearch = require_sbmh(); + var B_DCRLF = Buffer.from("\r\n\r\n"); + var RE_CRLF = /\r\n/g; + var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/; + function HeaderParser(cfg) { + EventEmitter.call(this); + cfg = cfg || {}; + const self = this; + this.nread = 0; + this.maxed = false; + this.npairs = 0; + this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3); + this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024); + this.buffer = ""; + this.header = {}; + this.finished = false; + this.ss = new StreamSearch(B_DCRLF); + this.ss.on("info", function(isMatch, data, start, end) { + if (data && !self.maxed) { + if (self.nread + end - start >= self.maxHeaderSize) { + end = self.maxHeaderSize - self.nread + start; + self.nread = self.maxHeaderSize; + self.maxed = true; + } else { + self.nread += end - start; + } + self.buffer += data.toString("binary", start, end); + } + if (isMatch) { + self._finish(); + } + }); + } + inherits(HeaderParser, EventEmitter); + HeaderParser.prototype.push = function(data) { + const r = this.ss.push(data); + if (this.finished) { + return r; + } + }; + HeaderParser.prototype.reset = function() { + this.finished = false; + this.buffer = ""; + this.header = {}; + this.ss.reset(); + }; + HeaderParser.prototype._finish = function() { + if (this.buffer) { + this._parseHeader(); + } + this.ss.matches = this.ss.maxMatches; + const header = this.header; + this.header = {}; + this.buffer = ""; + this.finished = true; + this.nread = this.npairs = 0; + this.maxed = false; + this.emit("header", header); + }; + HeaderParser.prototype._parseHeader = function() { + if (this.npairs === this.maxHeaderPairs) { + return; + } + const lines = this.buffer.split(RE_CRLF); + const len = lines.length; + let m, h; + for (var i = 0; i < len; ++i) { + if (lines[i].length === 0) { + continue; + } + if (lines[i][0] === " " || lines[i][0] === " ") { + if (h) { + this.header[h][this.header[h].length - 1] += lines[i]; + continue; + } + } + const posColon = lines[i].indexOf(":"); + if (posColon === -1 || posColon === 0) { + return; + } + m = RE_HDR.exec(lines[i]); + h = m[1].toLowerCase(); + this.header[h] = this.header[h] || []; + this.header[h].push(m[2] || ""); + if (++this.npairs === this.maxHeaderPairs) { + break; + } + } + }; + module2.exports = HeaderParser; + } +}); -Dicer.prototype._ignore = function () { - if (this._part && !this._ignoreData) { - this._ignoreData = true - this._part.on('error', EMPTY_FN) - // we must perform some kind of read on the stream even though we are - // ignoring the data, otherwise node's Readable stream will not emit 'end' - // after pushing null to the stream - this._part.resume() +// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js +var require_Dicer = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var inherits = require("node:util").inherits; + var StreamSearch = require_sbmh(); + var PartStream = require_PartStream(); + var HeaderParser = require_HeaderParser(); + var DASH = 45; + var B_ONEDASH = Buffer.from("-"); + var B_CRLF = Buffer.from("\r\n"); + var EMPTY_FN = function() { + }; + function Dicer(cfg) { + if (!(this instanceof Dicer)) { + return new Dicer(cfg); + } + WritableStream.call(this, cfg); + if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") { + throw new TypeError("Boundary required"); + } + if (typeof cfg.boundary === "string") { + this.setBoundary(cfg.boundary); + } else { + this._bparser = void 0; + } + this._headerFirst = cfg.headerFirst; + this._dashes = 0; + this._parts = 0; + this._finished = false; + this._realFinish = false; + this._isPreamble = true; + this._justMatched = false; + this._firstWrite = true; + this._inHeader = true; + this._part = void 0; + this._cb = void 0; + this._ignoreData = false; + this._partOpts = { highWaterMark: cfg.partHwm }; + this._pause = false; + const self = this; + this._hparser = new HeaderParser(cfg); + this._hparser.on("header", function(header) { + self._inHeader = false; + self._part.emit("header", header); + }); + } + inherits(Dicer, WritableStream); + Dicer.prototype.emit = function(ev) { + if (ev === "finish" && !this._realFinish) { + if (!this._finished) { + const self = this; + process.nextTick(function() { + self.emit("error", new Error("Unexpected end of multipart data")); + if (self._part && !self._ignoreData) { + const type = self._isPreamble ? "Preamble" : "Part"; + self._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data")); + self._part.push(null); + process.nextTick(function() { + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + }); + return; + } + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + }); + } + } else { + WritableStream.prototype.emit.apply(this, arguments); + } + }; + Dicer.prototype._write = function(data, encoding, cb) { + if (!this._hparser && !this._bparser) { + return cb(); + } + if (this._headerFirst && this._isPreamble) { + if (!this._part) { + this._part = new PartStream(this._partOpts); + if (this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else { + this._ignore(); + } + } + const r = this._hparser.push(data); + if (!this._inHeader && r !== void 0 && r < data.length) { + data = data.slice(r); + } else { + return cb(); + } + } + if (this._firstWrite) { + this._bparser.push(B_CRLF); + this._firstWrite = false; + } + this._bparser.push(data); + if (this._pause) { + this._cb = cb; + } else { + cb(); + } + }; + Dicer.prototype.reset = function() { + this._part = void 0; + this._bparser = void 0; + this._hparser = void 0; + }; + Dicer.prototype.setBoundary = function(boundary) { + const self = this; + this._bparser = new StreamSearch("\r\n--" + boundary); + this._bparser.on("info", function(isMatch, data, start, end) { + self._oninfo(isMatch, data, start, end); + }); + }; + Dicer.prototype._ignore = function() { + if (this._part && !this._ignoreData) { + this._ignoreData = true; + this._part.on("error", EMPTY_FN); + this._part.resume(); + } + }; + Dicer.prototype._oninfo = function(isMatch, data, start, end) { + let buf; + const self = this; + let i = 0; + let r; + let shouldWriteMore = true; + if (!this._part && this._justMatched && data) { + while (this._dashes < 2 && start + i < end) { + if (data[start + i] === DASH) { + ++i; + ++this._dashes; + } else { + if (this._dashes) { + buf = B_ONEDASH; + } + this._dashes = 0; + break; + } + } + if (this._dashes === 2) { + if (start + i < end && this.listenerCount("trailer") !== 0) { + this.emit("trailer", data.slice(start + i, end)); + } + this.reset(); + this._finished = true; + if (self._parts === 0) { + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + } + } + if (this._dashes) { + return; + } + } + if (this._justMatched) { + this._justMatched = false; + } + if (!this._part) { + this._part = new PartStream(this._partOpts); + this._part._read = function(n) { + self._unpause(); + }; + if (this._isPreamble && this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else if (this._isPreamble !== true && this.listenerCount("part") !== 0) { + this.emit("part", this._part); + } else { + this._ignore(); + } + if (!this._isPreamble) { + this._inHeader = true; + } + } + if (data && start < end && !this._ignoreData) { + if (this._isPreamble || !this._inHeader) { + if (buf) { + shouldWriteMore = this._part.push(buf); + } + shouldWriteMore = this._part.push(data.slice(start, end)); + if (!shouldWriteMore) { + this._pause = true; + } + } else if (!this._isPreamble && this._inHeader) { + if (buf) { + this._hparser.push(buf); + } + r = this._hparser.push(data.slice(start, end)); + if (!this._inHeader && r !== void 0 && r < end) { + this._oninfo(false, data, start + r, end); + } + } + } + if (isMatch) { + this._hparser.reset(); + if (this._isPreamble) { + this._isPreamble = false; + } else { + if (start !== end) { + ++this._parts; + this._part.on("end", function() { + if (--self._parts === 0) { + if (self._finished) { + self._realFinish = true; + self.emit("finish"); + self._realFinish = false; + } else { + self._unpause(); + } + } + }); + } + } + this._part.push(null); + this._part = void 0; + this._ignoreData = false; + this._justMatched = true; + this._dashes = 0; + } + }; + Dicer.prototype._unpause = function() { + if (!this._pause) { + return; + } + this._pause = false; + if (this._cb) { + const cb = this._cb; + this._cb = void 0; + cb(); + } + }; + module2.exports = Dicer; } -} +}); -Dicer.prototype._oninfo = function (isMatch, data, start, end) { - let buf; const self = this; let i = 0; let r; let shouldWriteMore = true +// node_modules/@fastify/busboy/lib/utils/decodeText.js +var require_decodeText = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) { + "use strict"; + var utf8Decoder = new TextDecoder("utf-8"); + var textDecoders = /* @__PURE__ */ new Map([ + ["utf-8", utf8Decoder], + ["utf8", utf8Decoder] + ]); + function getDecoder(charset) { + let lc; + while (true) { + switch (charset) { + case "utf-8": + case "utf8": + return decoders.utf8; + case "latin1": + case "ascii": + // TODO: Make these a separate, strict decoder? + case "us-ascii": + case "iso-8859-1": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "windows-1252": + case "iso_8859-1:1987": + case "cp1252": + case "x-cp1252": + return decoders.latin1; + case "utf16le": + case "utf-16le": + case "ucs2": + case "ucs-2": + return decoders.utf16le; + case "base64": + return decoders.base64; + default: + if (lc === void 0) { + lc = true; + charset = charset.toLowerCase(); + continue; + } + return decoders.other.bind(charset); + } + } + } + var decoders = { + utf8: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.utf8Slice(0, data.length); + }, + latin1: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + return data; + } + return data.latin1Slice(0, data.length); + }, + utf16le: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.ucs2Slice(0, data.length); + }, + base64: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.base64Slice(0, data.length); + }, + other: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + if (textDecoders.has(exports2.toString())) { + try { + return textDecoders.get(exports2).decode(data); + } catch { + } + } + return typeof data === "string" ? data : data.toString(); + } + }; + function decodeText(text, sourceEncoding, destEncoding) { + if (text) { + return getDecoder(destEncoding)(text, sourceEncoding); + } + return text; + } + module2.exports = decodeText; + } +}); - if (!this._part && this._justMatched && data) { - while (this._dashes < 2 && (start + i) < end) { - if (data[start + i] === DASH) { - ++i - ++this._dashes +// node_modules/@fastify/busboy/lib/utils/parseParams.js +var require_parseParams = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) { + "use strict"; + var decodeText = require_decodeText(); + var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g; + var EncodedLookup = { + "%00": "\0", + "%01": "", + "%02": "", + "%03": "", + "%04": "", + "%05": "", + "%06": "", + "%07": "\x07", + "%08": "\b", + "%09": " ", + "%0a": "\n", + "%0A": "\n", + "%0b": "\v", + "%0B": "\v", + "%0c": "\f", + "%0C": "\f", + "%0d": "\r", + "%0D": "\r", + "%0e": "", + "%0E": "", + "%0f": "", + "%0F": "", + "%10": "", + "%11": "", + "%12": "", + "%13": "", + "%14": "", + "%15": "", + "%16": "", + "%17": "", + "%18": "", + "%19": "", + "%1a": "", + "%1A": "", + "%1b": "\x1B", + "%1B": "\x1B", + "%1c": "", + "%1C": "", + "%1d": "", + "%1D": "", + "%1e": "", + "%1E": "", + "%1f": "", + "%1F": "", + "%20": " ", + "%21": "!", + "%22": '"', + "%23": "#", + "%24": "$", + "%25": "%", + "%26": "&", + "%27": "'", + "%28": "(", + "%29": ")", + "%2a": "*", + "%2A": "*", + "%2b": "+", + "%2B": "+", + "%2c": ",", + "%2C": ",", + "%2d": "-", + "%2D": "-", + "%2e": ".", + "%2E": ".", + "%2f": "/", + "%2F": "/", + "%30": "0", + "%31": "1", + "%32": "2", + "%33": "3", + "%34": "4", + "%35": "5", + "%36": "6", + "%37": "7", + "%38": "8", + "%39": "9", + "%3a": ":", + "%3A": ":", + "%3b": ";", + "%3B": ";", + "%3c": "<", + "%3C": "<", + "%3d": "=", + "%3D": "=", + "%3e": ">", + "%3E": ">", + "%3f": "?", + "%3F": "?", + "%40": "@", + "%41": "A", + "%42": "B", + "%43": "C", + "%44": "D", + "%45": "E", + "%46": "F", + "%47": "G", + "%48": "H", + "%49": "I", + "%4a": "J", + "%4A": "J", + "%4b": "K", + "%4B": "K", + "%4c": "L", + "%4C": "L", + "%4d": "M", + "%4D": "M", + "%4e": "N", + "%4E": "N", + "%4f": "O", + "%4F": "O", + "%50": "P", + "%51": "Q", + "%52": "R", + "%53": "S", + "%54": "T", + "%55": "U", + "%56": "V", + "%57": "W", + "%58": "X", + "%59": "Y", + "%5a": "Z", + "%5A": "Z", + "%5b": "[", + "%5B": "[", + "%5c": "\\", + "%5C": "\\", + "%5d": "]", + "%5D": "]", + "%5e": "^", + "%5E": "^", + "%5f": "_", + "%5F": "_", + "%60": "`", + "%61": "a", + "%62": "b", + "%63": "c", + "%64": "d", + "%65": "e", + "%66": "f", + "%67": "g", + "%68": "h", + "%69": "i", + "%6a": "j", + "%6A": "j", + "%6b": "k", + "%6B": "k", + "%6c": "l", + "%6C": "l", + "%6d": "m", + "%6D": "m", + "%6e": "n", + "%6E": "n", + "%6f": "o", + "%6F": "o", + "%70": "p", + "%71": "q", + "%72": "r", + "%73": "s", + "%74": "t", + "%75": "u", + "%76": "v", + "%77": "w", + "%78": "x", + "%79": "y", + "%7a": "z", + "%7A": "z", + "%7b": "{", + "%7B": "{", + "%7c": "|", + "%7C": "|", + "%7d": "}", + "%7D": "}", + "%7e": "~", + "%7E": "~", + "%7f": "\x7F", + "%7F": "\x7F", + "%80": "\x80", + "%81": "\x81", + "%82": "\x82", + "%83": "\x83", + "%84": "\x84", + "%85": "\x85", + "%86": "\x86", + "%87": "\x87", + "%88": "\x88", + "%89": "\x89", + "%8a": "\x8A", + "%8A": "\x8A", + "%8b": "\x8B", + "%8B": "\x8B", + "%8c": "\x8C", + "%8C": "\x8C", + "%8d": "\x8D", + "%8D": "\x8D", + "%8e": "\x8E", + "%8E": "\x8E", + "%8f": "\x8F", + "%8F": "\x8F", + "%90": "\x90", + "%91": "\x91", + "%92": "\x92", + "%93": "\x93", + "%94": "\x94", + "%95": "\x95", + "%96": "\x96", + "%97": "\x97", + "%98": "\x98", + "%99": "\x99", + "%9a": "\x9A", + "%9A": "\x9A", + "%9b": "\x9B", + "%9B": "\x9B", + "%9c": "\x9C", + "%9C": "\x9C", + "%9d": "\x9D", + "%9D": "\x9D", + "%9e": "\x9E", + "%9E": "\x9E", + "%9f": "\x9F", + "%9F": "\x9F", + "%a0": "\xA0", + "%A0": "\xA0", + "%a1": "\xA1", + "%A1": "\xA1", + "%a2": "\xA2", + "%A2": "\xA2", + "%a3": "\xA3", + "%A3": "\xA3", + "%a4": "\xA4", + "%A4": "\xA4", + "%a5": "\xA5", + "%A5": "\xA5", + "%a6": "\xA6", + "%A6": "\xA6", + "%a7": "\xA7", + "%A7": "\xA7", + "%a8": "\xA8", + "%A8": "\xA8", + "%a9": "\xA9", + "%A9": "\xA9", + "%aa": "\xAA", + "%Aa": "\xAA", + "%aA": "\xAA", + "%AA": "\xAA", + "%ab": "\xAB", + "%Ab": "\xAB", + "%aB": "\xAB", + "%AB": "\xAB", + "%ac": "\xAC", + "%Ac": "\xAC", + "%aC": "\xAC", + "%AC": "\xAC", + "%ad": "\xAD", + "%Ad": "\xAD", + "%aD": "\xAD", + "%AD": "\xAD", + "%ae": "\xAE", + "%Ae": "\xAE", + "%aE": "\xAE", + "%AE": "\xAE", + "%af": "\xAF", + "%Af": "\xAF", + "%aF": "\xAF", + "%AF": "\xAF", + "%b0": "\xB0", + "%B0": "\xB0", + "%b1": "\xB1", + "%B1": "\xB1", + "%b2": "\xB2", + "%B2": "\xB2", + "%b3": "\xB3", + "%B3": "\xB3", + "%b4": "\xB4", + "%B4": "\xB4", + "%b5": "\xB5", + "%B5": "\xB5", + "%b6": "\xB6", + "%B6": "\xB6", + "%b7": "\xB7", + "%B7": "\xB7", + "%b8": "\xB8", + "%B8": "\xB8", + "%b9": "\xB9", + "%B9": "\xB9", + "%ba": "\xBA", + "%Ba": "\xBA", + "%bA": "\xBA", + "%BA": "\xBA", + "%bb": "\xBB", + "%Bb": "\xBB", + "%bB": "\xBB", + "%BB": "\xBB", + "%bc": "\xBC", + "%Bc": "\xBC", + "%bC": "\xBC", + "%BC": "\xBC", + "%bd": "\xBD", + "%Bd": "\xBD", + "%bD": "\xBD", + "%BD": "\xBD", + "%be": "\xBE", + "%Be": "\xBE", + "%bE": "\xBE", + "%BE": "\xBE", + "%bf": "\xBF", + "%Bf": "\xBF", + "%bF": "\xBF", + "%BF": "\xBF", + "%c0": "\xC0", + "%C0": "\xC0", + "%c1": "\xC1", + "%C1": "\xC1", + "%c2": "\xC2", + "%C2": "\xC2", + "%c3": "\xC3", + "%C3": "\xC3", + "%c4": "\xC4", + "%C4": "\xC4", + "%c5": "\xC5", + "%C5": "\xC5", + "%c6": "\xC6", + "%C6": "\xC6", + "%c7": "\xC7", + "%C7": "\xC7", + "%c8": "\xC8", + "%C8": "\xC8", + "%c9": "\xC9", + "%C9": "\xC9", + "%ca": "\xCA", + "%Ca": "\xCA", + "%cA": "\xCA", + "%CA": "\xCA", + "%cb": "\xCB", + "%Cb": "\xCB", + "%cB": "\xCB", + "%CB": "\xCB", + "%cc": "\xCC", + "%Cc": "\xCC", + "%cC": "\xCC", + "%CC": "\xCC", + "%cd": "\xCD", + "%Cd": "\xCD", + "%cD": "\xCD", + "%CD": "\xCD", + "%ce": "\xCE", + "%Ce": "\xCE", + "%cE": "\xCE", + "%CE": "\xCE", + "%cf": "\xCF", + "%Cf": "\xCF", + "%cF": "\xCF", + "%CF": "\xCF", + "%d0": "\xD0", + "%D0": "\xD0", + "%d1": "\xD1", + "%D1": "\xD1", + "%d2": "\xD2", + "%D2": "\xD2", + "%d3": "\xD3", + "%D3": "\xD3", + "%d4": "\xD4", + "%D4": "\xD4", + "%d5": "\xD5", + "%D5": "\xD5", + "%d6": "\xD6", + "%D6": "\xD6", + "%d7": "\xD7", + "%D7": "\xD7", + "%d8": "\xD8", + "%D8": "\xD8", + "%d9": "\xD9", + "%D9": "\xD9", + "%da": "\xDA", + "%Da": "\xDA", + "%dA": "\xDA", + "%DA": "\xDA", + "%db": "\xDB", + "%Db": "\xDB", + "%dB": "\xDB", + "%DB": "\xDB", + "%dc": "\xDC", + "%Dc": "\xDC", + "%dC": "\xDC", + "%DC": "\xDC", + "%dd": "\xDD", + "%Dd": "\xDD", + "%dD": "\xDD", + "%DD": "\xDD", + "%de": "\xDE", + "%De": "\xDE", + "%dE": "\xDE", + "%DE": "\xDE", + "%df": "\xDF", + "%Df": "\xDF", + "%dF": "\xDF", + "%DF": "\xDF", + "%e0": "\xE0", + "%E0": "\xE0", + "%e1": "\xE1", + "%E1": "\xE1", + "%e2": "\xE2", + "%E2": "\xE2", + "%e3": "\xE3", + "%E3": "\xE3", + "%e4": "\xE4", + "%E4": "\xE4", + "%e5": "\xE5", + "%E5": "\xE5", + "%e6": "\xE6", + "%E6": "\xE6", + "%e7": "\xE7", + "%E7": "\xE7", + "%e8": "\xE8", + "%E8": "\xE8", + "%e9": "\xE9", + "%E9": "\xE9", + "%ea": "\xEA", + "%Ea": "\xEA", + "%eA": "\xEA", + "%EA": "\xEA", + "%eb": "\xEB", + "%Eb": "\xEB", + "%eB": "\xEB", + "%EB": "\xEB", + "%ec": "\xEC", + "%Ec": "\xEC", + "%eC": "\xEC", + "%EC": "\xEC", + "%ed": "\xED", + "%Ed": "\xED", + "%eD": "\xED", + "%ED": "\xED", + "%ee": "\xEE", + "%Ee": "\xEE", + "%eE": "\xEE", + "%EE": "\xEE", + "%ef": "\xEF", + "%Ef": "\xEF", + "%eF": "\xEF", + "%EF": "\xEF", + "%f0": "\xF0", + "%F0": "\xF0", + "%f1": "\xF1", + "%F1": "\xF1", + "%f2": "\xF2", + "%F2": "\xF2", + "%f3": "\xF3", + "%F3": "\xF3", + "%f4": "\xF4", + "%F4": "\xF4", + "%f5": "\xF5", + "%F5": "\xF5", + "%f6": "\xF6", + "%F6": "\xF6", + "%f7": "\xF7", + "%F7": "\xF7", + "%f8": "\xF8", + "%F8": "\xF8", + "%f9": "\xF9", + "%F9": "\xF9", + "%fa": "\xFA", + "%Fa": "\xFA", + "%fA": "\xFA", + "%FA": "\xFA", + "%fb": "\xFB", + "%Fb": "\xFB", + "%fB": "\xFB", + "%FB": "\xFB", + "%fc": "\xFC", + "%Fc": "\xFC", + "%fC": "\xFC", + "%FC": "\xFC", + "%fd": "\xFD", + "%Fd": "\xFD", + "%fD": "\xFD", + "%FD": "\xFD", + "%fe": "\xFE", + "%Fe": "\xFE", + "%fE": "\xFE", + "%FE": "\xFE", + "%ff": "\xFF", + "%Ff": "\xFF", + "%fF": "\xFF", + "%FF": "\xFF" + }; + function encodedReplacer(match) { + return EncodedLookup[match]; + } + var STATE_KEY = 0; + var STATE_VALUE = 1; + var STATE_CHARSET = 2; + var STATE_LANG = 3; + function parseParams(str) { + const res = []; + let state = STATE_KEY; + let charset = ""; + let inquote = false; + let escaping = false; + let p = 0; + let tmp = ""; + const len = str.length; + for (var i = 0; i < len; ++i) { + const char = str[i]; + if (char === "\\" && inquote) { + if (escaping) { + escaping = false; + } else { + escaping = true; + continue; + } + } else if (char === '"') { + if (!escaping) { + if (inquote) { + inquote = false; + state = STATE_KEY; + } else { + inquote = true; + } + continue; + } else { + escaping = false; + } + } else { + if (escaping && inquote) { + tmp += "\\"; + } + escaping = false; + if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") { + if (state === STATE_CHARSET) { + state = STATE_LANG; + charset = tmp.substring(1); + } else { + state = STATE_VALUE; + } + tmp = ""; + continue; + } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) { + state = char === "*" ? STATE_CHARSET : STATE_VALUE; + res[p] = [tmp, void 0]; + tmp = ""; + continue; + } else if (!inquote && char === ";") { + state = STATE_KEY; + if (charset) { + if (tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } + charset = ""; + } else if (tmp.length) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + res[p] = tmp; + } else { + res[p][1] = tmp; + } + tmp = ""; + ++p; + continue; + } else if (!inquote && (char === " " || char === " ")) { + continue; + } + } + tmp += char; + } + if (charset && tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } else if (tmp) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + if (tmp) { + res[p] = tmp; + } } else { - if (this._dashes) { buf = B_ONEDASH } - this._dashes = 0 - break - } - } - if (this._dashes === 2) { - if ((start + i) < end && this.listenerCount('trailer') !== 0) { this.emit('trailer', data.slice(start + i, end)) } - this.reset() - this._finished = true - // no more parts will be added - if (self._parts === 0) { - self._realFinish = true - self.emit('finish') - self._realFinish = false - } - } - if (this._dashes) { return } - } - if (this._justMatched) { this._justMatched = false } - if (!this._part) { - this._part = new PartStream(this._partOpts) - this._part._read = function (n) { - self._unpause() - } - if (this._isPreamble && this.listenerCount('preamble') !== 0) { - this.emit('preamble', this._part) - } else if (this._isPreamble !== true && this.listenerCount('part') !== 0) { - this.emit('part', this._part) - } else { - this._ignore() - } - if (!this._isPreamble) { this._inHeader = true } - } - if (data && start < end && !this._ignoreData) { - if (this._isPreamble || !this._inHeader) { - if (buf) { shouldWriteMore = this._part.push(buf) } - shouldWriteMore = this._part.push(data.slice(start, end)) - if (!shouldWriteMore) { this._pause = true } - } else if (!this._isPreamble && this._inHeader) { - if (buf) { this._hparser.push(buf) } - r = this._hparser.push(data.slice(start, end)) - if (!this._inHeader && r !== undefined && r < end) { this._oninfo(false, data, start + r, end) } - } - } - if (isMatch) { - this._hparser.reset() - if (this._isPreamble) { this._isPreamble = false } else { - if (start !== end) { - ++this._parts - this._part.on('end', function () { - if (--self._parts === 0) { - if (self._finished) { - self._realFinish = true - self.emit('finish') - self._realFinish = false - } else { - self._unpause() - } - } - }) + res[p][1] = tmp; } + return res; } - this._part.push(null) - this._part = undefined - this._ignoreData = false - this._justMatched = true - this._dashes = 0 + module2.exports = parseParams; } -} - -Dicer.prototype._unpause = function () { - if (!this._pause) { return } +}); - this._pause = false - if (this._cb) { - const cb = this._cb - this._cb = undefined - cb() +// node_modules/@fastify/busboy/lib/utils/basename.js +var require_basename = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) { + "use strict"; + module2.exports = function basename(path2) { + if (typeof path2 !== "string") { + return ""; + } + for (var i = path2.length - 1; i >= 0; --i) { + switch (path2.charCodeAt(i)) { + case 47: + // '/' + case 92: + path2 = path2.slice(i + 1); + return path2 === ".." || path2 === "." ? "" : path2; + } + } + return path2 === ".." || path2 === "." ? "" : path2; + }; } -} - -module.exports = Dicer - - -/***/ }), - -/***/ 2271: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const EventEmitter = (__nccwpck_require__(8474).EventEmitter) -const inherits = (__nccwpck_require__(7975).inherits) -const getLimit = __nccwpck_require__(2393) - -const StreamSearch = __nccwpck_require__(4136) - -const B_DCRLF = Buffer.from('\r\n\r\n') -const RE_CRLF = /\r\n/g -const RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/ // eslint-disable-line no-control-regex - -function HeaderParser (cfg) { - EventEmitter.call(this) - - cfg = cfg || {} - const self = this - this.nread = 0 - this.maxed = false - this.npairs = 0 - this.maxHeaderPairs = getLimit(cfg, 'maxHeaderPairs', 2000) - this.maxHeaderSize = getLimit(cfg, 'maxHeaderSize', 80 * 1024) - this.buffer = '' - this.header = {} - this.finished = false - this.ss = new StreamSearch(B_DCRLF) - this.ss.on('info', function (isMatch, data, start, end) { - if (data && !self.maxed) { - if (self.nread + end - start >= self.maxHeaderSize) { - end = self.maxHeaderSize - self.nread + start - self.nread = self.maxHeaderSize - self.maxed = true - } else { self.nread += (end - start) } - - self.buffer += data.toString('binary', start, end) - } - if (isMatch) { self._finish() } - }) -} -inherits(HeaderParser, EventEmitter) - -HeaderParser.prototype.push = function (data) { - const r = this.ss.push(data) - if (this.finished) { return r } -} - -HeaderParser.prototype.reset = function () { - this.finished = false - this.buffer = '' - this.header = {} - this.ss.reset() -} - -HeaderParser.prototype._finish = function () { - if (this.buffer) { this._parseHeader() } - this.ss.matches = this.ss.maxMatches - const header = this.header - this.header = {} - this.buffer = '' - this.finished = true - this.nread = this.npairs = 0 - this.maxed = false - this.emit('header', header) -} - -HeaderParser.prototype._parseHeader = function () { - if (this.npairs === this.maxHeaderPairs) { return } - - const lines = this.buffer.split(RE_CRLF) - const len = lines.length - let m, h +}); - for (var i = 0; i < len; ++i) { // eslint-disable-line no-var - if (lines[i].length === 0) { continue } - if (lines[i][0] === '\t' || lines[i][0] === ' ') { - // folded header content - // RFC2822 says to just remove the CRLF and not the whitespace following - // it, so we follow the RFC and include the leading whitespace ... - if (h) { - this.header[h][this.header[h].length - 1] += lines[i] - continue +// node_modules/@fastify/busboy/lib/types/multipart.js +var require_multipart = __commonJS({ + "node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) { + "use strict"; + var { Readable } = require("node:stream"); + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var parseParams = require_parseParams(); + var decodeText = require_decodeText(); + var basename = require_basename(); + var getLimit = require_getLimit(); + var RE_BOUNDARY = /^boundary$/i; + var RE_FIELD = /^form-data$/i; + var RE_CHARSET = /^charset$/i; + var RE_FILENAME = /^filename$/i; + var RE_NAME = /^name$/i; + Multipart.detect = /^multipart\/form-data/i; + function Multipart(boy, cfg) { + let i; + let len; + const self = this; + let boundary; + const limits = cfg.limits; + const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0); + const parsedConType = cfg.parsedConType || []; + const defCharset = cfg.defCharset || "utf8"; + const preservePath = cfg.preservePath; + const fileOpts = { highWaterMark: cfg.fileHwm }; + for (i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) { + boundary = parsedConType[i][1]; + break; + } + } + function checkFinished() { + if (nends === 0 && finished && !boy._done) { + finished = false; + self.end(); + } + } + if (typeof boundary !== "string") { + throw new Error("Multipart: Boundary not found"); + } + const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + const fileSizeLimit = getLimit(limits, "fileSize", Infinity); + const filesLimit = getLimit(limits, "files", Infinity); + const fieldsLimit = getLimit(limits, "fields", Infinity); + const partsLimit = getLimit(limits, "parts", Infinity); + const headerPairsLimit = getLimit(limits, "headerPairs", 2e3); + const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024); + let nfiles = 0; + let nfields = 0; + let nends = 0; + let curFile; + let curField; + let finished = false; + this._needDrain = false; + this._pause = false; + this._cb = void 0; + this._nparts = 0; + this._boy = boy; + const parserCfg = { + boundary, + maxHeaderPairs: headerPairsLimit, + maxHeaderSize: headerSizeLimit, + partHwm: fileOpts.highWaterMark, + highWaterMark: cfg.highWaterMark + }; + this.parser = new Dicer(parserCfg); + this.parser.on("drain", function() { + self._needDrain = false; + if (self._cb && !self._pause) { + const cb = self._cb; + self._cb = void 0; + cb(); + } + }).on("part", function onPart(part) { + if (++self._nparts > partsLimit) { + self.parser.removeListener("part", onPart); + self.parser.on("part", skipPart); + boy.hitPartsLimit = true; + boy.emit("partsLimit"); + return skipPart(part); + } + if (curField) { + const field = curField; + field.emit("end"); + field.removeAllListeners("end"); + } + part.on("header", function(header) { + let contype; + let fieldname; + let parsed; + let charset; + let encoding; + let filename; + let nsize = 0; + if (header["content-type"]) { + parsed = parseParams(header["content-type"][0]); + if (parsed[0]) { + contype = parsed[0].toLowerCase(); + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_CHARSET.test(parsed[i][0])) { + charset = parsed[i][1].toLowerCase(); + break; + } + } + } + } + if (contype === void 0) { + contype = "text/plain"; + } + if (charset === void 0) { + charset = defCharset; + } + if (header["content-disposition"]) { + parsed = parseParams(header["content-disposition"][0]); + if (!RE_FIELD.test(parsed[0])) { + return skipPart(part); + } + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_NAME.test(parsed[i][0])) { + fieldname = parsed[i][1]; + } else if (RE_FILENAME.test(parsed[i][0])) { + filename = parsed[i][1]; + if (!preservePath) { + filename = basename(filename); + } + } + } + } else { + return skipPart(part); + } + if (header["content-transfer-encoding"]) { + encoding = header["content-transfer-encoding"][0].toLowerCase(); + } else { + encoding = "7bit"; + } + let onData, onEnd; + if (isPartAFile(fieldname, contype, filename)) { + if (nfiles === filesLimit) { + if (!boy.hitFilesLimit) { + boy.hitFilesLimit = true; + boy.emit("filesLimit"); + } + return skipPart(part); + } + ++nfiles; + if (boy.listenerCount("file") === 0) { + self.parser._ignore(); + return; + } + ++nends; + const file = new FileStream(fileOpts); + curFile = file; + file.on("end", function() { + --nends; + self._pause = false; + checkFinished(); + if (self._cb && !self._needDrain) { + const cb = self._cb; + self._cb = void 0; + cb(); + } + }); + file._read = function(n) { + if (!self._pause) { + return; + } + self._pause = false; + if (self._cb && !self._needDrain) { + const cb = self._cb; + self._cb = void 0; + cb(); + } + }; + boy.emit("file", fieldname, file, filename, encoding, contype); + onData = function(data) { + if ((nsize += data.length) > fileSizeLimit) { + const extralen = fileSizeLimit - nsize + data.length; + if (extralen > 0) { + file.push(data.slice(0, extralen)); + } + file.truncated = true; + file.bytesRead = fileSizeLimit; + part.removeAllListeners("data"); + file.emit("limit"); + return; + } else if (!file.push(data)) { + self._pause = true; + } + file.bytesRead = nsize; + }; + onEnd = function() { + curFile = void 0; + file.push(null); + }; + } else { + if (nfields === fieldsLimit) { + if (!boy.hitFieldsLimit) { + boy.hitFieldsLimit = true; + boy.emit("fieldsLimit"); + } + return skipPart(part); + } + ++nfields; + ++nends; + let buffer = ""; + let truncated = false; + curField = part; + onData = function(data) { + if ((nsize += data.length) > fieldSizeLimit) { + const extralen = fieldSizeLimit - (nsize - data.length); + buffer += data.toString("binary", 0, extralen); + truncated = true; + part.removeAllListeners("data"); + } else { + buffer += data.toString("binary"); + } + }; + onEnd = function() { + curField = void 0; + if (buffer.length) { + buffer = decodeText(buffer, "binary", charset); + } + boy.emit("field", fieldname, buffer, false, truncated, encoding, contype); + --nends; + checkFinished(); + }; + } + part._readableState.sync = false; + part.on("data", onData); + part.on("end", onEnd); + }).on("error", function(err) { + if (curFile) { + curFile.emit("error", err); + } + }); + }).on("error", function(err) { + boy.emit("error", err); + }).on("finish", function() { + finished = true; + checkFinished(); + }); + } + Multipart.prototype.write = function(chunk, cb) { + const r = this.parser.write(chunk); + if (r && !this._pause) { + cb(); + } else { + this._needDrain = !r; + this._cb = cb; + } + }; + Multipart.prototype.end = function() { + const self = this; + if (self.parser.writable) { + self.parser.end(); + } else if (!self._boy._done) { + process.nextTick(function() { + self._boy._done = true; + self._boy.emit("finish"); + }); } + }; + function skipPart(part) { + part.resume(); } - - const posColon = lines[i].indexOf(':') - if ( - posColon === -1 || - posColon === 0 - ) { - return + function FileStream(opts) { + Readable.call(this, opts); + this.bytesRead = 0; + this.truncated = false; } - m = RE_HDR.exec(lines[i]) - h = m[1].toLowerCase() - this.header[h] = this.header[h] || [] - this.header[h].push((m[2] || '')) - if (++this.npairs === this.maxHeaderPairs) { break } + inherits(FileStream, Readable); + FileStream.prototype._read = function(n) { + }; + module2.exports = Multipart; } -} - -module.exports = HeaderParser - - -/***/ }), - -/***/ 612: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const inherits = (__nccwpck_require__(7975).inherits) -const ReadableStream = (__nccwpck_require__(7075).Readable) - -function PartStream (opts) { - ReadableStream.call(this, opts) -} -inherits(PartStream, ReadableStream) - -PartStream.prototype._read = function (n) {} - -module.exports = PartStream - - -/***/ }), - -/***/ 4136: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -/** - * Copyright Brian White. All rights reserved. - * - * @see https://github.com/mscdex/streamsearch - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - * - * Based heavily on the Streaming Boyer-Moore-Horspool C++ implementation - * by Hongli Lai at: https://github.com/FooBarWidget/boyer-moore-horspool - */ -const EventEmitter = (__nccwpck_require__(8474).EventEmitter) -const inherits = (__nccwpck_require__(7975).inherits) +}); -function SBMH (needle) { - if (typeof needle === 'string') { - needle = Buffer.from(needle) +// node_modules/@fastify/busboy/lib/utils/Decoder.js +var require_Decoder = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) { + "use strict"; + var RE_PLUS = /\+/g; + var HEX = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ]; + function Decoder() { + this.buffer = void 0; + } + Decoder.prototype.write = function(str) { + str = str.replace(RE_PLUS, " "); + let res = ""; + let i = 0; + let p = 0; + const len = str.length; + for (; i < len; ++i) { + if (this.buffer !== void 0) { + if (!HEX[str.charCodeAt(i)]) { + res += "%" + this.buffer; + this.buffer = void 0; + --i; + } else { + this.buffer += str[i]; + ++p; + if (this.buffer.length === 2) { + res += String.fromCharCode(parseInt(this.buffer, 16)); + this.buffer = void 0; + } + } + } else if (str[i] === "%") { + if (i > p) { + res += str.substring(p, i); + p = i; + } + this.buffer = ""; + ++p; + } + } + if (p < len && this.buffer === void 0) { + res += str.substring(p); + } + return res; + }; + Decoder.prototype.reset = function() { + this.buffer = void 0; + }; + module2.exports = Decoder; } +}); - if (!Buffer.isBuffer(needle)) { - throw new TypeError('The needle has to be a String or a Buffer.') +// node_modules/@fastify/busboy/lib/types/urlencoded.js +var require_urlencoded = __commonJS({ + "node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) { + "use strict"; + var Decoder = require_Decoder(); + var decodeText = require_decodeText(); + var getLimit = require_getLimit(); + var RE_CHARSET = /^charset$/i; + UrlEncoded.detect = /^application\/x-www-form-urlencoded/i; + function UrlEncoded(boy, cfg) { + const limits = cfg.limits; + const parsedConType = cfg.parsedConType; + this.boy = boy; + this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100); + this.fieldsLimit = getLimit(limits, "fields", Infinity); + let charset; + for (var i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) { + charset = parsedConType[i][1].toLowerCase(); + break; + } + } + if (charset === void 0) { + charset = cfg.defCharset || "utf8"; + } + this.decoder = new Decoder(); + this.charset = charset; + this._fields = 0; + this._state = "key"; + this._checkingBytes = true; + this._bytesKey = 0; + this._bytesVal = 0; + this._key = ""; + this._val = ""; + this._keyTrunc = false; + this._valTrunc = false; + this._hitLimit = false; + } + UrlEncoded.prototype.write = function(data, cb) { + if (this._fields === this.fieldsLimit) { + if (!this.boy.hitFieldsLimit) { + this.boy.hitFieldsLimit = true; + this.boy.emit("fieldsLimit"); + } + return cb(); + } + let idxeq; + let idxamp; + let i; + let p = 0; + const len = data.length; + while (p < len) { + if (this._state === "key") { + idxeq = idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 61) { + idxeq = i; + break; + } else if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesKey; + } + } + if (idxeq !== void 0) { + if (idxeq > p) { + this._key += this.decoder.write(data.toString("binary", p, idxeq)); + } + this._state = "val"; + this._hitLimit = false; + this._checkingBytes = true; + this._val = ""; + this._bytesVal = 0; + this._valTrunc = false; + this.decoder.reset(); + p = idxeq + 1; + } else if (idxamp !== void 0) { + ++this._fields; + let key; + const keyTrunc = this._keyTrunc; + if (idxamp > p) { + key = this._key += this.decoder.write(data.toString("binary", p, idxamp)); + } else { + key = this._key; + } + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + if (key.length) { + this.boy.emit( + "field", + decodeText(key, "binary", this.charset), + "", + keyTrunc, + false + ); + } + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._key += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) { + this._checkingBytes = false; + this._keyTrunc = true; + } + } else { + if (p < len) { + this._key += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } else { + idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesVal; + } + } + if (idxamp !== void 0) { + ++this._fields; + if (idxamp > p) { + this._val += this.decoder.write(data.toString("binary", p, idxamp)); + } + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + this._state = "key"; + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._val += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) { + this._checkingBytes = false; + this._valTrunc = true; + } + } else { + if (p < len) { + this._val += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } + } + cb(); + }; + UrlEncoded.prototype.end = function() { + if (this.boy._done) { + return; + } + if (this._state === "key" && this._key.length > 0) { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + "", + this._keyTrunc, + false + ); + } else if (this._state === "val") { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + } + this.boy._done = true; + this.boy.emit("finish"); + }; + module2.exports = UrlEncoded; } +}); - const needleLength = needle.length - - if (needleLength === 0) { - throw new Error('The needle cannot be an empty String/Buffer.') +// node_modules/@fastify/busboy/lib/main.js +var require_main = __commonJS({ + "node_modules/@fastify/busboy/lib/main.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var MultipartParser = require_multipart(); + var UrlencodedParser = require_urlencoded(); + var parseParams = require_parseParams(); + function Busboy(opts) { + if (!(this instanceof Busboy)) { + return new Busboy(opts); + } + if (typeof opts !== "object") { + throw new TypeError("Busboy expected an options-Object."); + } + if (typeof opts.headers !== "object") { + throw new TypeError("Busboy expected an options-Object with headers-attribute."); + } + if (typeof opts.headers["content-type"] !== "string") { + throw new TypeError("Missing Content-Type-header."); + } + const { + headers, + ...streamOptions + } = opts; + this.opts = { + autoDestroy: false, + ...streamOptions + }; + WritableStream.call(this, this.opts); + this._done = false; + this._parser = this.getParserByHeaders(headers); + this._finished = false; + } + inherits(Busboy, WritableStream); + Busboy.prototype.emit = function(ev) { + if (ev === "finish") { + if (!this._done) { + this._parser?.end(); + return; + } else if (this._finished) { + return; + } + this._finished = true; + } + WritableStream.prototype.emit.apply(this, arguments); + }; + Busboy.prototype.getParserByHeaders = function(headers) { + const parsed = parseParams(headers["content-type"]); + const cfg = { + defCharset: this.opts.defCharset, + fileHwm: this.opts.fileHwm, + headers, + highWaterMark: this.opts.highWaterMark, + isPartAFile: this.opts.isPartAFile, + limits: this.opts.limits, + parsedConType: parsed, + preservePath: this.opts.preservePath + }; + if (MultipartParser.detect.test(parsed[0])) { + return new MultipartParser(this, cfg); + } + if (UrlencodedParser.detect.test(parsed[0])) { + return new UrlencodedParser(this, cfg); + } + throw new Error("Unsupported Content-Type."); + }; + Busboy.prototype._write = function(chunk, encoding, cb) { + this._parser.write(chunk, cb); + }; + module2.exports = Busboy; + module2.exports.default = Busboy; + module2.exports.Busboy = Busboy; + module2.exports.Dicer = Dicer; } +}); - if (needleLength > 256) { - throw new Error('The needle cannot have a length bigger than 256.') +// node_modules/undici/lib/fetch/constants.js +var require_constants2 = __commonJS({ + "node_modules/undici/lib/fetch/constants.js"(exports2, module2) { + "use strict"; + var { MessageChannel, receiveMessageOnPort } = require("worker_threads"); + var corsSafeListedMethods = ["GET", "HEAD", "POST"]; + var corsSafeListedMethodsSet = new Set(corsSafeListedMethods); + var nullBodyStatus = [101, 204, 205, 304]; + var redirectStatus = [301, 302, 303, 307, 308]; + var redirectStatusSet = new Set(redirectStatus); + var badPorts = [ + "1", + "7", + "9", + "11", + "13", + "15", + "17", + "19", + "20", + "21", + "22", + "23", + "25", + "37", + "42", + "43", + "53", + "69", + "77", + "79", + "87", + "95", + "101", + "102", + "103", + "104", + "109", + "110", + "111", + "113", + "115", + "117", + "119", + "123", + "135", + "137", + "139", + "143", + "161", + "179", + "389", + "427", + "465", + "512", + "513", + "514", + "515", + "526", + "530", + "531", + "532", + "540", + "548", + "554", + "556", + "563", + "587", + "601", + "636", + "989", + "990", + "993", + "995", + "1719", + "1720", + "1723", + "2049", + "3659", + "4045", + "5060", + "5061", + "6000", + "6566", + "6665", + "6666", + "6667", + "6668", + "6669", + "6697", + "10080" + ]; + var badPortsSet = new Set(badPorts); + var referrerPolicy = [ + "", + "no-referrer", + "no-referrer-when-downgrade", + "same-origin", + "origin", + "strict-origin", + "origin-when-cross-origin", + "strict-origin-when-cross-origin", + "unsafe-url" + ]; + var referrerPolicySet = new Set(referrerPolicy); + var requestRedirect = ["follow", "manual", "error"]; + var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"]; + var safeMethodsSet = new Set(safeMethods); + var requestMode = ["navigate", "same-origin", "no-cors", "cors"]; + var requestCredentials = ["omit", "same-origin", "include"]; + var requestCache = [ + "default", + "no-store", + "reload", + "no-cache", + "force-cache", + "only-if-cached" + ]; + var requestBodyHeader = [ + "content-encoding", + "content-language", + "content-location", + "content-type", + // See https://github.com/nodejs/undici/issues/2021 + // 'Content-Length' is a forbidden header name, which is typically + // removed in the Headers implementation. However, undici doesn't + // filter out headers, so we add it here. + "content-length" + ]; + var requestDuplex = [ + "half" + ]; + var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"]; + var forbiddenMethodsSet = new Set(forbiddenMethods); + var subresource = [ + "audio", + "audioworklet", + "font", + "image", + "manifest", + "paintworklet", + "script", + "style", + "track", + "video", + "xslt", + "" + ]; + var subresourceSet = new Set(subresource); + var DOMException2 = globalThis.DOMException ?? (() => { + try { + atob("~"); + } catch (err) { + return Object.getPrototypeOf(err).constructor; + } + })(); + var channel; + var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js + // structuredClone was added in v17.0.0, but fetch supports v16.8 + function structuredClone2(value, options = void 0) { + if (arguments.length === 0) { + throw new TypeError("missing argument"); + } + if (!channel) { + channel = new MessageChannel(); + } + channel.port1.unref(); + channel.port2.unref(); + channel.port1.postMessage(value, options?.transfer); + return receiveMessageOnPort(channel.port2).message; + }; + module2.exports = { + DOMException: DOMException2, + structuredClone, + subresource, + forbiddenMethods, + requestBodyHeader, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + redirectStatus, + corsSafeListedMethods, + nullBodyStatus, + safeMethods, + badPorts, + requestDuplex, + subresourceSet, + badPortsSet, + redirectStatusSet, + corsSafeListedMethodsSet, + safeMethodsSet, + forbiddenMethodsSet, + referrerPolicySet + }; } +}); - this.maxMatches = Infinity - this.matches = 0 - - this._occ = new Array(256) - .fill(needleLength) // Initialize occurrence table. - this._lookbehind_size = 0 - this._needle = needle - this._bufpos = 0 - - this._lookbehind = Buffer.alloc(needleLength) - - // Populate occurrence table with analysis of the needle, - // ignoring last letter. - for (var i = 0; i < needleLength - 1; ++i) { // eslint-disable-line no-var - this._occ[needle[i]] = needleLength - 1 - i +// node_modules/undici/lib/fetch/global.js +var require_global = __commonJS({ + "node_modules/undici/lib/fetch/global.js"(exports2, module2) { + "use strict"; + var globalOrigin = Symbol.for("undici.globalOrigin.1"); + function getGlobalOrigin() { + return globalThis[globalOrigin]; + } + function setGlobalOrigin(newOrigin) { + if (newOrigin === void 0) { + Object.defineProperty(globalThis, globalOrigin, { + value: void 0, + writable: true, + enumerable: false, + configurable: false + }); + return; + } + const parsedURL = new URL(newOrigin); + if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") { + throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`); + } + Object.defineProperty(globalThis, globalOrigin, { + value: parsedURL, + writable: true, + enumerable: false, + configurable: false + }); + } + module2.exports = { + getGlobalOrigin, + setGlobalOrigin + }; } -} -inherits(SBMH, EventEmitter) - -SBMH.prototype.reset = function () { - this._lookbehind_size = 0 - this.matches = 0 - this._bufpos = 0 -} - -SBMH.prototype.push = function (chunk, pos) { - if (!Buffer.isBuffer(chunk)) { - chunk = Buffer.from(chunk, 'binary') - } - const chlen = chunk.length - this._bufpos = pos || 0 - let r - while (r !== chlen && this.matches < this.maxMatches) { r = this._sbmh_feed(chunk) } - return r -} - -SBMH.prototype._sbmh_feed = function (data) { - const len = data.length - const needle = this._needle - const needleLength = needle.length - const lastNeedleChar = needle[needleLength - 1] - - // Positive: points to a position in `data` - // pos == 3 points to data[3] - // Negative: points to a position in the lookbehind buffer - // pos == -2 points to lookbehind[lookbehind_size - 2] - let pos = -this._lookbehind_size - let ch - - if (pos < 0) { - // Lookbehind buffer is not empty. Perform Boyer-Moore-Horspool - // search with character lookup code that considers both the - // lookbehind buffer and the current round's haystack data. - // - // Loop until - // there is a match. - // or until - // we've moved past the position that requires the - // lookbehind buffer. In this case we switch to the - // optimized loop. - // or until - // the character to look at lies outside the haystack. - while (pos < 0 && pos <= len - needleLength) { - ch = this._sbmh_lookup_char(data, pos + needleLength - 1) - - if ( - ch === lastNeedleChar && - this._sbmh_memcmp(data, pos, needleLength - 1) - ) { - this._lookbehind_size = 0 - ++this.matches - this.emit('info', true) +}); - return (this._bufpos = pos + needleLength) +// node_modules/undici/lib/fetch/util.js +var require_util2 = __commonJS({ + "node_modules/undici/lib/fetch/util.js"(exports2, module2) { + "use strict"; + var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2(); + var { getGlobalOrigin } = require_global(); + var { performance: performance2 } = require("perf_hooks"); + var { isBlobLike: isBlobLike2, toUSVString, ReadableStreamFrom: ReadableStreamFrom2 } = require_util(); + var assert = require("assert"); + var { isUint8Array } = require("util/types"); + var supportedHashes = []; + var crypto; + try { + crypto = require("crypto"); + const possibleRelevantHashes = ["sha256", "sha384", "sha512"]; + supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)); + } catch { + } + function responseURL(response) { + const urlList = response.urlList; + const length = urlList.length; + return length === 0 ? null : urlList[length - 1].toString(); + } + function responseLocationURL(response, requestFragment) { + if (!redirectStatusSet.has(response.status)) { + return null; + } + let location = response.headersList.get("location"); + if (location !== null && isValidHeaderValue(location)) { + location = new URL(location, responseURL(response)); + } + if (location && !location.hash) { + location.hash = requestFragment; + } + return location; + } + function requestCurrentURL(request) { + return request.urlList[request.urlList.length - 1]; + } + function requestBadPort(request) { + const url = requestCurrentURL(request); + if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) { + return "blocked"; + } + return "allowed"; + } + function isErrorLike(object) { + return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException"); + } + function isValidReasonPhrase(statusText) { + for (let i = 0; i < statusText.length; ++i) { + const c = statusText.charCodeAt(i); + if (!(c === 9 || // HTAB + c >= 32 && c <= 126 || // SP / VCHAR + c >= 128 && c <= 255)) { + return false; + } + } + return true; + } + function isTokenCharCode(c) { + switch (c) { + case 34: + case 40: + case 41: + case 44: + case 47: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 91: + case 92: + case 93: + case 123: + case 125: + return false; + default: + return c >= 33 && c <= 126; + } + } + function isValidHTTPToken(characters) { + if (characters.length === 0) { + return false; + } + for (let i = 0; i < characters.length; ++i) { + if (!isTokenCharCode(characters.charCodeAt(i))) { + return false; + } + } + return true; + } + function isValidHeaderName(potentialValue) { + return isValidHTTPToken(potentialValue); + } + function isValidHeaderValue(potentialValue) { + if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) { + return false; + } + if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) { + return false; + } + return true; + } + function setRequestReferrerPolicyOnRedirect(request, actualResponse) { + const { headersList } = actualResponse; + const policyHeader = (headersList.get("referrer-policy") ?? "").split(","); + let policy = ""; + if (policyHeader.length > 0) { + for (let i = policyHeader.length; i !== 0; i--) { + const token = policyHeader[i - 1].trim(); + if (referrerPolicyTokens.has(token)) { + policy = token; + break; + } + } + } + if (policy !== "") { + request.referrerPolicy = policy; + } + } + function crossOriginResourcePolicyCheck() { + return "allowed"; + } + function corsCheck() { + return "success"; + } + function TAOCheck() { + return "success"; + } + function appendFetchMetadata(httpRequest) { + let header = null; + header = httpRequest.mode; + httpRequest.headersList.set("sec-fetch-mode", header); + } + function appendRequestOriginHeader(request) { + let serializedOrigin = request.origin; + if (request.responseTainting === "cors" || request.mode === "websocket") { + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } else if (request.method !== "GET" && request.method !== "HEAD") { + switch (request.referrerPolicy) { + case "no-referrer": + serializedOrigin = null; + break; + case "no-referrer-when-downgrade": + case "strict-origin": + case "strict-origin-when-cross-origin": + if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + case "same-origin": + if (!sameOrigin(request, requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + default: + } + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } + } + function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) { + return performance2.now(); + } + function createOpaqueTimingInfo(timingInfo) { + return { + startTime: timingInfo.startTime ?? 0, + redirectStartTime: 0, + redirectEndTime: 0, + postRedirectStartTime: timingInfo.startTime ?? 0, + finalServiceWorkerStartTime: 0, + finalNetworkResponseStartTime: 0, + finalNetworkRequestStartTime: 0, + endTime: 0, + encodedBodySize: 0, + decodedBodySize: 0, + finalConnectionTimingInfo: null + }; + } + function makePolicyContainer() { + return { + referrerPolicy: "strict-origin-when-cross-origin" + }; + } + function clonePolicyContainer(policyContainer) { + return { + referrerPolicy: policyContainer.referrerPolicy + }; + } + function determineRequestsReferrer(request) { + const policy = request.referrerPolicy; + assert(policy); + let referrerSource = null; + if (request.referrer === "client") { + const globalOrigin = getGlobalOrigin(); + if (!globalOrigin || globalOrigin.origin === "null") { + return "no-referrer"; + } + referrerSource = new URL(globalOrigin); + } else if (request.referrer instanceof URL) { + referrerSource = request.referrer; + } + let referrerURL = stripURLForReferrer(referrerSource); + const referrerOrigin = stripURLForReferrer(referrerSource, true); + if (referrerURL.toString().length > 4096) { + referrerURL = referrerOrigin; + } + const areSameOrigin = sameOrigin(request, referrerURL); + const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url); + switch (policy) { + case "origin": + return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true); + case "unsafe-url": + return referrerURL; + case "same-origin": + return areSameOrigin ? referrerOrigin : "no-referrer"; + case "origin-when-cross-origin": + return areSameOrigin ? referrerURL : referrerOrigin; + case "strict-origin-when-cross-origin": { + const currentURL = requestCurrentURL(request); + if (sameOrigin(referrerURL, currentURL)) { + return referrerURL; + } + if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) { + return "no-referrer"; + } + return referrerOrigin; + } + case "strict-origin": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + case "no-referrer-when-downgrade": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + default: + return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin; + } + } + function stripURLForReferrer(url, originOnly) { + assert(url instanceof URL); + if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") { + return "no-referrer"; + } + url.username = ""; + url.password = ""; + url.hash = ""; + if (originOnly) { + url.pathname = ""; + url.search = ""; + } + return url; + } + function isURLPotentiallyTrustworthy(url) { + if (!(url instanceof URL)) { + return false; + } + if (url.href === "about:blank" || url.href === "about:srcdoc") { + return true; + } + if (url.protocol === "data:") return true; + if (url.protocol === "file:") return true; + return isOriginPotentiallyTrustworthy(url.origin); + function isOriginPotentiallyTrustworthy(origin) { + if (origin == null || origin === "null") return false; + const originAsURL = new URL(origin); + if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") { + return true; + } + if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) { + return true; + } + return false; + } + } + function bytesMatch(bytes, metadataList) { + if (crypto === void 0) { + return true; + } + const parsedMetadata = parseMetadata(metadataList); + if (parsedMetadata === "no metadata") { + return true; + } + if (parsedMetadata.length === 0) { + return true; + } + const strongest = getStrongestMetadata(parsedMetadata); + const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest); + for (const item of metadata) { + const algorithm = item.algo; + const expectedValue = item.hash; + let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64"); + if (actualValue[actualValue.length - 1] === "=") { + if (actualValue[actualValue.length - 2] === "=") { + actualValue = actualValue.slice(0, -2); + } else { + actualValue = actualValue.slice(0, -1); + } + } + if (compareBase64Mixed(actualValue, expectedValue)) { + return true; + } } - pos += this._occ[ch] + return false; } - - // No match. - - if (pos < 0) { - // There's too few data for Boyer-Moore-Horspool to run, - // so let's use a different algorithm to skip as much as - // we can. - // Forward pos until - // the trailing part of lookbehind + data - // looks like the beginning of the needle - // or until - // pos == 0 - while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { ++pos } + var parseHashWithOptions = /(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i; + function parseMetadata(metadata) { + const result = []; + let empty = true; + for (const token of metadata.split(" ")) { + empty = false; + const parsedToken = parseHashWithOptions.exec(token); + if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) { + continue; + } + const algorithm = parsedToken.groups.algo.toLowerCase(); + if (supportedHashes.includes(algorithm)) { + result.push(parsedToken.groups); + } + } + if (empty === true) { + return "no metadata"; + } + return result; } - - if (pos >= 0) { - // Discard lookbehind buffer. - this.emit('info', false, this._lookbehind, 0, this._lookbehind_size) - this._lookbehind_size = 0 - } else { - // Cut off part of the lookbehind buffer that has - // been processed and append the entire haystack - // into it. - const bytesToCutOff = this._lookbehind_size + pos - if (bytesToCutOff > 0) { - // The cut off data is guaranteed not to contain the needle. - this.emit('info', false, this._lookbehind, 0, bytesToCutOff) + function getStrongestMetadata(metadataList) { + let algorithm = metadataList[0].algo; + if (algorithm[3] === "5") { + return algorithm; } - - this._lookbehind.copy(this._lookbehind, 0, bytesToCutOff, - this._lookbehind_size - bytesToCutOff) - this._lookbehind_size -= bytesToCutOff - - data.copy(this._lookbehind, this._lookbehind_size) - this._lookbehind_size += len - - this._bufpos = len - return len + for (let i = 1; i < metadataList.length; ++i) { + const metadata = metadataList[i]; + if (metadata.algo[3] === "5") { + algorithm = "sha512"; + break; + } else if (algorithm[3] === "3") { + continue; + } else if (metadata.algo[3] === "3") { + algorithm = "sha384"; + } + } + return algorithm; } - } - - pos += (pos >= 0) * this._bufpos - - // Lookbehind buffer is now empty. We only need to check if the - // needle is in the haystack. - if (data.indexOf(needle, pos) !== -1) { - pos = data.indexOf(needle, pos) - ++this.matches - if (pos > 0) { this.emit('info', true, data, this._bufpos, pos) } else { this.emit('info', true) } - - return (this._bufpos = pos + needleLength) - } else { - pos = len - needleLength - } - - // There was no match. If there's trailing haystack data that we cannot - // match yet using the Boyer-Moore-Horspool algorithm (because the trailing - // data is less than the needle size) then match using a modified - // algorithm that starts matching from the beginning instead of the end. - // Whatever trailing data is left after running this algorithm is added to - // the lookbehind buffer. - while ( - pos < len && - ( - data[pos] !== needle[0] || - ( - (Buffer.compare( - data.subarray(pos, pos + len - pos), - needle.subarray(0, len - pos) - ) !== 0) - ) - ) - ) { - ++pos - } - if (pos < len) { - data.copy(this._lookbehind, 0, pos, pos + (len - pos)) - this._lookbehind_size = len - pos - } - - // Everything until pos is guaranteed not to contain needle data. - if (pos > 0) { this.emit('info', false, data, this._bufpos, pos < len ? pos : len) } - - this._bufpos = len - return len -} - -SBMH.prototype._sbmh_lookup_char = function (data, pos) { - return (pos < 0) - ? this._lookbehind[this._lookbehind_size + pos] - : data[pos] -} - -SBMH.prototype._sbmh_memcmp = function (data, pos, len) { - for (var i = 0; i < len; ++i) { // eslint-disable-line no-var - if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { return false } - } - return true -} - -module.exports = SBMH - - -/***/ }), - -/***/ 9581: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const WritableStream = (__nccwpck_require__(7075).Writable) -const { inherits } = __nccwpck_require__(7975) -const Dicer = __nccwpck_require__(7182) - -const MultipartParser = __nccwpck_require__(1192) -const UrlencodedParser = __nccwpck_require__(855) -const parseParams = __nccwpck_require__(8929) - -function Busboy (opts) { - if (!(this instanceof Busboy)) { return new Busboy(opts) } - - if (typeof opts !== 'object') { - throw new TypeError('Busboy expected an options-Object.') - } - if (typeof opts.headers !== 'object') { - throw new TypeError('Busboy expected an options-Object with headers-attribute.') - } - if (typeof opts.headers['content-type'] !== 'string') { - throw new TypeError('Missing Content-Type-header.') - } - - const { - headers, - ...streamOptions - } = opts - - this.opts = { - autoDestroy: false, - ...streamOptions - } - WritableStream.call(this, this.opts) - - this._done = false - this._parser = this.getParserByHeaders(headers) - this._finished = false -} -inherits(Busboy, WritableStream) - -Busboy.prototype.emit = function (ev) { - if (ev === 'finish') { - if (!this._done) { - this._parser?.end() - return - } else if (this._finished) { - return + function filterMetadataListByAlgorithm(metadataList, algorithm) { + if (metadataList.length === 1) { + return metadataList; + } + let pos = 0; + for (let i = 0; i < metadataList.length; ++i) { + if (metadataList[i].algo === algorithm) { + metadataList[pos++] = metadataList[i]; + } + } + metadataList.length = pos; + return metadataList; } - this._finished = true - } - WritableStream.prototype.emit.apply(this, arguments) -} - -Busboy.prototype.getParserByHeaders = function (headers) { - const parsed = parseParams(headers['content-type']) - - const cfg = { - defCharset: this.opts.defCharset, - fileHwm: this.opts.fileHwm, - headers, - highWaterMark: this.opts.highWaterMark, - isPartAFile: this.opts.isPartAFile, - limits: this.opts.limits, - parsedConType: parsed, - preservePath: this.opts.preservePath + function compareBase64Mixed(actualValue, expectedValue) { + if (actualValue.length !== expectedValue.length) { + return false; + } + for (let i = 0; i < actualValue.length; ++i) { + if (actualValue[i] !== expectedValue[i]) { + if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") { + continue; + } + return false; + } + } + return true; + } + function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) { + } + function sameOrigin(A, B) { + if (A.origin === B.origin && A.origin === "null") { + return true; + } + if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) { + return true; + } + return false; + } + function createDeferredPromise() { + let res; + let rej; + const promise = new Promise((resolve, reject) => { + res = resolve; + rej = reject; + }); + return { promise, resolve: res, reject: rej }; + } + function isAborted(fetchParams) { + return fetchParams.controller.state === "aborted"; + } + function isCancelled(fetchParams) { + return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated"; + } + var normalizeMethodRecord = { + delete: "DELETE", + DELETE: "DELETE", + get: "GET", + GET: "GET", + head: "HEAD", + HEAD: "HEAD", + options: "OPTIONS", + OPTIONS: "OPTIONS", + post: "POST", + POST: "POST", + put: "PUT", + PUT: "PUT" + }; + Object.setPrototypeOf(normalizeMethodRecord, null); + function normalizeMethod(method) { + return normalizeMethodRecord[method.toLowerCase()] ?? method; + } + function serializeJavascriptValueToJSONString(value) { + const result = JSON.stringify(value); + if (result === void 0) { + throw new TypeError("Value is not JSON serializable"); + } + assert(typeof result === "string"); + return result; + } + var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); + function makeIterator(iterator, name, kind) { + const object = { + index: 0, + kind, + target: iterator + }; + const i = { + next() { + if (Object.getPrototypeOf(this) !== i) { + throw new TypeError( + `'next' called on an object that does not implement interface ${name} Iterator.` + ); + } + const { index, kind: kind2, target } = object; + const values = target(); + const len = values.length; + if (index >= len) { + return { value: void 0, done: true }; + } + const pair = values[index]; + object.index = index + 1; + return iteratorResult(pair, kind2); + }, + // The class string of an iterator prototype object for a given interface is the + // result of concatenating the identifier of the interface and the string " Iterator". + [Symbol.toStringTag]: `${name} Iterator` + }; + Object.setPrototypeOf(i, esIteratorPrototype); + return Object.setPrototypeOf({}, i); + } + function iteratorResult(pair, kind) { + let result; + switch (kind) { + case "key": { + result = pair[0]; + break; + } + case "value": { + result = pair[1]; + break; + } + case "key+value": { + result = pair; + break; + } + } + return { value: result, done: false }; + } + async function fullyReadBody(body, processBody, processBodyError) { + const successSteps = processBody; + const errorSteps = processBodyError; + let reader; + try { + reader = body.stream.getReader(); + } catch (e) { + errorSteps(e); + return; + } + try { + const result = await readAllBytes(reader); + successSteps(result); + } catch (e) { + errorSteps(e); + } + } + var ReadableStream = globalThis.ReadableStream; + function isReadableStreamLike(stream) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function"; + } + var MAXIMUM_ARGUMENT_LENGTH = 65535; + function isomorphicDecode(input) { + if (input.length < MAXIMUM_ARGUMENT_LENGTH) { + return String.fromCharCode(...input); + } + return input.reduce((previous, current) => previous + String.fromCharCode(current), ""); + } + function readableStreamClose(controller) { + try { + controller.close(); + } catch (err) { + if (!err.message.includes("Controller is already closed")) { + throw err; + } + } + } + function isomorphicEncode(input) { + for (let i = 0; i < input.length; i++) { + assert(input.charCodeAt(i) <= 255); + } + return input; + } + async function readAllBytes(reader) { + const bytes = []; + let byteLength = 0; + while (true) { + const { done, value: chunk } = await reader.read(); + if (done) { + return Buffer.concat(bytes, byteLength); + } + if (!isUint8Array(chunk)) { + throw new TypeError("Received non-Uint8Array chunk"); + } + bytes.push(chunk); + byteLength += chunk.length; + } + } + function urlIsLocal(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "about:" || protocol === "blob:" || protocol === "data:"; + } + function urlHasHttpsScheme(url) { + if (typeof url === "string") { + return url.startsWith("https:"); + } + return url.protocol === "https:"; + } + function urlIsHttpHttpsScheme(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "http:" || protocol === "https:"; + } + var hasOwn2 = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key)); + module2.exports = { + isAborted, + isCancelled, + createDeferredPromise, + ReadableStreamFrom: ReadableStreamFrom2, + toUSVString, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + coarsenedSharedCurrentTime, + determineRequestsReferrer, + makePolicyContainer, + clonePolicyContainer, + appendFetchMetadata, + appendRequestOriginHeader, + TAOCheck, + corsCheck, + crossOriginResourcePolicyCheck, + createOpaqueTimingInfo, + setRequestReferrerPolicyOnRedirect, + isValidHTTPToken, + requestBadPort, + requestCurrentURL, + responseURL, + responseLocationURL, + isBlobLike: isBlobLike2, + isURLPotentiallyTrustworthy, + isValidReasonPhrase, + sameOrigin, + normalizeMethod, + serializeJavascriptValueToJSONString, + makeIterator, + isValidHeaderName, + isValidHeaderValue, + hasOwn: hasOwn2, + isErrorLike, + fullyReadBody, + bytesMatch, + isReadableStreamLike, + readableStreamClose, + isomorphicEncode, + isomorphicDecode, + urlIsLocal, + urlHasHttpsScheme, + urlIsHttpHttpsScheme, + readAllBytes, + normalizeMethodRecord, + parseMetadata + }; } +}); - if (MultipartParser.detect.test(parsed[0])) { - return new MultipartParser(this, cfg) - } - if (UrlencodedParser.detect.test(parsed[0])) { - return new UrlencodedParser(this, cfg) +// node_modules/undici/lib/fetch/symbols.js +var require_symbols2 = __commonJS({ + "node_modules/undici/lib/fetch/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kUrl: Symbol("url"), + kHeaders: Symbol("headers"), + kSignal: Symbol("signal"), + kState: Symbol("state"), + kGuard: Symbol("guard"), + kRealm: Symbol("realm") + }; } - throw new Error('Unsupported Content-Type.') -} - -Busboy.prototype._write = function (chunk, encoding, cb) { - this._parser.write(chunk, cb) -} - -module.exports = Busboy -module.exports["default"] = Busboy -module.exports.Busboy = Busboy - -module.exports.Dicer = Dicer - - -/***/ }), - -/***/ 1192: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -// TODO: -// * support 1 nested multipart level -// (see second multipart example here: -// http://www.w3.org/TR/html401/interact/forms.html#didx-multipartform-data) -// * support limits.fieldNameSize -// -- this will require modifications to utils.parseParams - -const { Readable } = __nccwpck_require__(7075) -const { inherits } = __nccwpck_require__(7975) - -const Dicer = __nccwpck_require__(7182) - -const parseParams = __nccwpck_require__(8929) -const decodeText = __nccwpck_require__(2747) -const basename = __nccwpck_require__(692) -const getLimit = __nccwpck_require__(2393) - -const RE_BOUNDARY = /^boundary$/i -const RE_FIELD = /^form-data$/i -const RE_CHARSET = /^charset$/i -const RE_FILENAME = /^filename$/i -const RE_NAME = /^name$/i - -Multipart.detect = /^multipart\/form-data/i -function Multipart (boy, cfg) { - let i - let len - const self = this - let boundary - const limits = cfg.limits - const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => (contentType === 'application/octet-stream' || fileName !== undefined)) - const parsedConType = cfg.parsedConType || [] - const defCharset = cfg.defCharset || 'utf8' - const preservePath = cfg.preservePath - const fileOpts = { highWaterMark: cfg.fileHwm } +}); - for (i = 0, len = parsedConType.length; i < len; ++i) { - if (Array.isArray(parsedConType[i]) && - RE_BOUNDARY.test(parsedConType[i][0])) { - boundary = parsedConType[i][1] - break - } +// node_modules/undici/lib/fetch/webidl.js +var require_webidl = __commonJS({ + "node_modules/undici/lib/fetch/webidl.js"(exports2, module2) { + "use strict"; + var { types } = require("util"); + var { hasOwn: hasOwn2, toUSVString } = require_util2(); + var webidl = {}; + webidl.converters = {}; + webidl.util = {}; + webidl.errors = {}; + webidl.errors.exception = function(message) { + return new TypeError(`${message.header}: ${message.message}`); + }; + webidl.errors.conversionFailed = function(context) { + const plural = context.types.length === 1 ? "" : " one of"; + const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`; + return webidl.errors.exception({ + header: context.prefix, + message + }); + }; + webidl.errors.invalidArgument = function(context) { + return webidl.errors.exception({ + header: context.prefix, + message: `"${context.value}" is an invalid ${context.type}.` + }); + }; + webidl.brandCheck = function(V, I, opts = void 0) { + if (opts?.strict !== false && !(V instanceof I)) { + throw new TypeError("Illegal invocation"); + } else { + return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag]; + } + }; + webidl.argumentLengthCheck = function({ length }, min, ctx) { + if (length < min) { + throw webidl.errors.exception({ + message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`, + ...ctx + }); + } + }; + webidl.illegalConstructor = function() { + throw webidl.errors.exception({ + header: "TypeError", + message: "Illegal constructor" + }); + }; + webidl.util.Type = function(V) { + switch (typeof V) { + case "undefined": + return "Undefined"; + case "boolean": + return "Boolean"; + case "string": + return "String"; + case "symbol": + return "Symbol"; + case "number": + return "Number"; + case "bigint": + return "BigInt"; + case "function": + case "object": { + if (V === null) { + return "Null"; + } + return "Object"; + } + } + }; + webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) { + let upperBound; + let lowerBound; + if (bitLength === 64) { + upperBound = Math.pow(2, 53) - 1; + if (signedness === "unsigned") { + lowerBound = 0; + } else { + lowerBound = Math.pow(-2, 53) + 1; + } + } else if (signedness === "unsigned") { + lowerBound = 0; + upperBound = Math.pow(2, bitLength) - 1; + } else { + lowerBound = Math.pow(-2, bitLength) - 1; + upperBound = Math.pow(2, bitLength - 1) - 1; + } + let x = Number(V); + if (x === 0) { + x = 0; + } + if (opts.enforceRange === true) { + if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Could not convert ${V} to an integer.` + }); + } + x = webidl.util.IntegerPart(x); + if (x < lowerBound || x > upperBound) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` + }); + } + return x; + } + if (!Number.isNaN(x) && opts.clamp === true) { + x = Math.min(Math.max(x, lowerBound), upperBound); + if (Math.floor(x) % 2 === 0) { + x = Math.floor(x); + } else { + x = Math.ceil(x); + } + return x; + } + if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + return 0; + } + x = webidl.util.IntegerPart(x); + x = x % Math.pow(2, bitLength); + if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) { + return x - Math.pow(2, bitLength); + } + return x; + }; + webidl.util.IntegerPart = function(n) { + const r = Math.floor(Math.abs(n)); + if (n < 0) { + return -1 * r; + } + return r; + }; + webidl.sequenceConverter = function(converter) { + return (V) => { + if (webidl.util.Type(V) !== "Object") { + throw webidl.errors.exception({ + header: "Sequence", + message: `Value of type ${webidl.util.Type(V)} is not an Object.` + }); + } + const method = V?.[Symbol.iterator]?.(); + const seq = []; + if (method === void 0 || typeof method.next !== "function") { + throw webidl.errors.exception({ + header: "Sequence", + message: "Object is not an iterator." + }); + } + while (true) { + const { done, value } = method.next(); + if (done) { + break; + } + seq.push(converter(value)); + } + return seq; + }; + }; + webidl.recordConverter = function(keyConverter, valueConverter) { + return (O) => { + if (webidl.util.Type(O) !== "Object") { + throw webidl.errors.exception({ + header: "Record", + message: `Value of type ${webidl.util.Type(O)} is not an Object.` + }); + } + const result = {}; + if (!types.isProxy(O)) { + const keys2 = Object.keys(O); + for (const key of keys2) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + return result; + } + const keys = Reflect.ownKeys(O); + for (const key of keys) { + const desc = Reflect.getOwnPropertyDescriptor(O, key); + if (desc?.enumerable) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + } + return result; + }; + }; + webidl.interfaceConverter = function(i) { + return (V, opts = {}) => { + if (opts.strict !== false && !(V instanceof i)) { + throw webidl.errors.exception({ + header: i.name, + message: `Expected ${V} to be an instance of ${i.name}.` + }); + } + return V; + }; + }; + webidl.dictionaryConverter = function(converters) { + return (dictionary) => { + const type = webidl.util.Type(dictionary); + const dict = {}; + if (type === "Null" || type === "Undefined") { + return dict; + } else if (type !== "Object") { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` + }); + } + for (const options of converters) { + const { key, defaultValue, required, converter } = options; + if (required === true) { + if (!hasOwn2(dictionary, key)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Missing required key "${key}".` + }); + } + } + let value = dictionary[key]; + const hasDefault = hasOwn2(options, "defaultValue"); + if (hasDefault && value !== null) { + value = value ?? defaultValue; + } + if (required || hasDefault || value !== void 0) { + value = converter(value); + if (options.allowedValues && !options.allowedValues.includes(value)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.` + }); + } + dict[key] = value; + } + } + return dict; + }; + }; + webidl.nullableConverter = function(converter) { + return (V) => { + if (V === null) { + return V; + } + return converter(V); + }; + }; + webidl.converters.DOMString = function(V, opts = {}) { + if (V === null && opts.legacyNullToEmptyString) { + return ""; + } + if (typeof V === "symbol") { + throw new TypeError("Could not convert argument of type symbol to string."); + } + return String(V); + }; + webidl.converters.ByteString = function(V) { + const x = webidl.converters.DOMString(V); + for (let index = 0; index < x.length; index++) { + if (x.charCodeAt(index) > 255) { + throw new TypeError( + `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.` + ); + } + } + return x; + }; + webidl.converters.USVString = toUSVString; + webidl.converters.boolean = function(V) { + const x = Boolean(V); + return x; + }; + webidl.converters.any = function(V) { + return V; + }; + webidl.converters["long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "signed"); + return x; + }; + webidl.converters["unsigned long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "unsigned"); + return x; + }; + webidl.converters["unsigned long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 32, "unsigned"); + return x; + }; + webidl.converters["unsigned short"] = function(V, opts) { + const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts); + return x; + }; + webidl.converters.ArrayBuffer = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) { + throw webidl.errors.conversionFailed({ + prefix: `${V}`, + argument: `${V}`, + types: ["ArrayBuffer"] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.TypedArray = function(V, T, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) { + throw webidl.errors.conversionFailed({ + prefix: `${T.name}`, + argument: `${V}`, + types: [T.name] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.DataView = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) { + throw webidl.errors.exception({ + header: "DataView", + message: "Object is not a DataView." + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.BufferSource = function(V, opts = {}) { + if (types.isAnyArrayBuffer(V)) { + return webidl.converters.ArrayBuffer(V, opts); + } + if (types.isTypedArray(V)) { + return webidl.converters.TypedArray(V, V.constructor); + } + if (types.isDataView(V)) { + return webidl.converters.DataView(V, opts); + } + throw new TypeError(`Could not convert ${V} to a BufferSource.`); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.ByteString + ); + webidl.converters["sequence>"] = webidl.sequenceConverter( + webidl.converters["sequence"] + ); + webidl.converters["record"] = webidl.recordConverter( + webidl.converters.ByteString, + webidl.converters.ByteString + ); + module2.exports = { + webidl + }; } +}); - function checkFinished () { - if (nends === 0 && finished && !boy._done) { - finished = false - self.end() +// node_modules/undici/lib/fetch/dataURL.js +var require_dataURL = __commonJS({ + "node_modules/undici/lib/fetch/dataURL.js"(exports2, module2) { + var assert = require("assert"); + var { atob: atob2 } = require("buffer"); + var { isomorphicDecode } = require_util2(); + var encoder = new TextEncoder(); + var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/; + var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/; + var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/; + function dataURLProcessor(dataURL) { + assert(dataURL.protocol === "data:"); + let input = URLSerializer(dataURL, true); + input = input.slice(5); + const position = { position: 0 }; + let mimeType = collectASequenceOfCodePointsFast( + ",", + input, + position + ); + const mimeTypeLength = mimeType.length; + mimeType = removeASCIIWhitespace(mimeType, true, true); + if (position.position >= input.length) { + return "failure"; + } + position.position++; + const encodedBody = input.slice(mimeTypeLength + 1); + let body = stringPercentDecode(encodedBody); + if (/;(\u0020){0,}base64$/i.test(mimeType)) { + const stringBody = isomorphicDecode(body); + body = forgivingBase64(stringBody); + if (body === "failure") { + return "failure"; + } + mimeType = mimeType.slice(0, -6); + mimeType = mimeType.replace(/(\u0020)+$/, ""); + mimeType = mimeType.slice(0, -1); + } + if (mimeType.startsWith(";")) { + mimeType = "text/plain" + mimeType; + } + let mimeTypeRecord = parseMIMEType(mimeType); + if (mimeTypeRecord === "failure") { + mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII"); + } + return { mimeType: mimeTypeRecord, body }; + } + function URLSerializer(url, excludeFragment = false) { + if (!excludeFragment) { + return url.href; + } + const href = url.href; + const hashLength = url.hash.length; + return hashLength === 0 ? href : href.substring(0, href.length - hashLength); + } + function collectASequenceOfCodePoints(condition, input, position) { + let result = ""; + while (position.position < input.length && condition(input[position.position])) { + result += input[position.position]; + position.position++; + } + return result; + } + function collectASequenceOfCodePointsFast(char, input, position) { + const idx = input.indexOf(char, position.position); + const start = position.position; + if (idx === -1) { + position.position = input.length; + return input.slice(start); + } + position.position = idx; + return input.slice(start, position.position); + } + function stringPercentDecode(input) { + const bytes = encoder.encode(input); + return percentDecode(bytes); + } + function percentDecode(input) { + const output = []; + for (let i = 0; i < input.length; i++) { + const byte = input[i]; + if (byte !== 37) { + output.push(byte); + } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) { + output.push(37); + } else { + const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]); + const bytePoint = Number.parseInt(nextTwoBytes, 16); + output.push(bytePoint); + i += 2; + } + } + return Uint8Array.from(output); } + function parseMIMEType(input) { + input = removeHTTPWhitespace(input, true, true); + const position = { position: 0 }; + const type = collectASequenceOfCodePointsFast( + "/", + input, + position + ); + if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) { + return "failure"; + } + if (position.position > input.length) { + return "failure"; + } + position.position++; + let subtype = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + subtype = removeHTTPWhitespace(subtype, false, true); + if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) { + return "failure"; + } + const typeLowercase = type.toLowerCase(); + const subtypeLowercase = subtype.toLowerCase(); + const mimeType = { + type: typeLowercase, + subtype: subtypeLowercase, + /** @type {Map} */ + parameters: /* @__PURE__ */ new Map(), + // https://mimesniff.spec.whatwg.org/#mime-type-essence + essence: `${typeLowercase}/${subtypeLowercase}` + }; + while (position.position < input.length) { + position.position++; + collectASequenceOfCodePoints( + // https://fetch.spec.whatwg.org/#http-whitespace + (char) => HTTP_WHITESPACE_REGEX.test(char), + input, + position + ); + let parameterName = collectASequenceOfCodePoints( + (char) => char !== ";" && char !== "=", + input, + position + ); + parameterName = parameterName.toLowerCase(); + if (position.position < input.length) { + if (input[position.position] === ";") { + continue; + } + position.position++; + } + if (position.position > input.length) { + break; + } + let parameterValue = null; + if (input[position.position] === '"') { + parameterValue = collectAnHTTPQuotedString(input, position, true); + collectASequenceOfCodePointsFast( + ";", + input, + position + ); + } else { + parameterValue = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + parameterValue = removeHTTPWhitespace(parameterValue, false, true); + if (parameterValue.length === 0) { + continue; + } + } + if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) { + mimeType.parameters.set(parameterName, parameterValue); + } + } + return mimeType; + } + function forgivingBase64(data) { + data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, ""); + if (data.length % 4 === 0) { + data = data.replace(/=?=$/, ""); + } + if (data.length % 4 === 1) { + return "failure"; + } + if (/[^+/0-9A-Za-z]/.test(data)) { + return "failure"; + } + const binary = atob2(data); + const bytes = new Uint8Array(binary.length); + for (let byte = 0; byte < binary.length; byte++) { + bytes[byte] = binary.charCodeAt(byte); + } + return bytes; + } + function collectAnHTTPQuotedString(input, position, extractValue) { + const positionStart = position.position; + let value = ""; + assert(input[position.position] === '"'); + position.position++; + while (true) { + value += collectASequenceOfCodePoints( + (char) => char !== '"' && char !== "\\", + input, + position + ); + if (position.position >= input.length) { + break; + } + const quoteOrBackslash = input[position.position]; + position.position++; + if (quoteOrBackslash === "\\") { + if (position.position >= input.length) { + value += "\\"; + break; + } + value += input[position.position]; + position.position++; + } else { + assert(quoteOrBackslash === '"'); + break; + } + } + if (extractValue) { + return value; + } + return input.slice(positionStart, position.position); + } + function serializeAMimeType(mimeType) { + assert(mimeType !== "failure"); + const { parameters, essence } = mimeType; + let serialization = essence; + for (let [name, value] of parameters.entries()) { + serialization += ";"; + serialization += name; + serialization += "="; + if (!HTTP_TOKEN_CODEPOINTS.test(value)) { + value = value.replace(/(\\|")/g, "\\$1"); + value = '"' + value; + value += '"'; + } + serialization += value; + } + return serialization; + } + function isHTTPWhiteSpace(char) { + return char === "\r" || char === "\n" || char === " " || char === " "; + } + function removeHTTPWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + function isASCIIWhitespace(char) { + return char === "\r" || char === "\n" || char === " " || char === "\f" || char === " "; + } + function removeASCIIWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + module2.exports = { + dataURLProcessor, + URLSerializer, + collectASequenceOfCodePoints, + collectASequenceOfCodePointsFast, + stringPercentDecode, + parseMIMEType, + collectAnHTTPQuotedString, + serializeAMimeType + }; } +}); - if (typeof boundary !== 'string') { throw new Error('Multipart: Boundary not found') } - - const fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024) - const fileSizeLimit = getLimit(limits, 'fileSize', Infinity) - const filesLimit = getLimit(limits, 'files', Infinity) - const fieldsLimit = getLimit(limits, 'fields', Infinity) - const partsLimit = getLimit(limits, 'parts', Infinity) - const headerPairsLimit = getLimit(limits, 'headerPairs', 2000) - const headerSizeLimit = getLimit(limits, 'headerSize', 80 * 1024) - - let nfiles = 0 - let nfields = 0 - let nends = 0 - let curFile - let curField - let finished = false - - this._needDrain = false - this._pause = false - this._cb = undefined - this._nparts = 0 - this._boy = boy - - const parserCfg = { - boundary, - maxHeaderPairs: headerPairsLimit, - maxHeaderSize: headerSizeLimit, - partHwm: fileOpts.highWaterMark, - highWaterMark: cfg.highWaterMark - } - - this.parser = new Dicer(parserCfg) - this.parser.on('drain', function () { - self._needDrain = false - if (self._cb && !self._pause) { - const cb = self._cb - self._cb = undefined - cb() - } - }).on('part', function onPart (part) { - if (++self._nparts > partsLimit) { - self.parser.removeListener('part', onPart) - self.parser.on('part', skipPart) - boy.hitPartsLimit = true - boy.emit('partsLimit') - return skipPart(part) - } - - // hack because streams2 _always_ doesn't emit 'end' until nextTick, so let - // us emit 'end' early since we know the part has ended if we are already - // seeing the next part - if (curField) { - const field = curField - field.emit('end') - field.removeAllListeners('end') - } - - part.on('header', function (header) { - let contype - let fieldname - let parsed - let charset - let encoding - let filename - let nsize = 0 - - if (header['content-type']) { - parsed = parseParams(header['content-type'][0]) - if (parsed[0]) { - contype = parsed[0].toLowerCase() - for (i = 0, len = parsed.length; i < len; ++i) { - if (RE_CHARSET.test(parsed[i][0])) { - charset = parsed[i][1].toLowerCase() - break +// node_modules/undici/lib/fetch/file.js +var require_file = __commonJS({ + "node_modules/undici/lib/fetch/file.js"(exports2, module2) { + "use strict"; + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { types } = require("util"); + var { kState } = require_symbols2(); + var { isBlobLike: isBlobLike2 } = require_util2(); + var { webidl } = require_webidl(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var { kEnumerableProperty } = require_util(); + var encoder = new TextEncoder(); + var File2 = class _File extends Blob2 { + constructor(fileBits, fileName, options = {}) { + webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" }); + fileBits = webidl.converters["sequence"](fileBits); + fileName = webidl.converters.USVString(fileName); + options = webidl.converters.FilePropertyBag(options); + const n = fileName; + let t = options.type; + let d; + substep: { + if (t) { + t = parseMIMEType(t); + if (t === "failure") { + t = ""; + break substep; } + t = serializeAMimeType(t).toLowerCase(); } + d = options.lastModified; } + super(processBlobParts(fileBits, options), { type: t }); + this[kState] = { + name: n, + lastModified: d, + type: t + }; } - - if (contype === undefined) { contype = 'text/plain' } - if (charset === undefined) { charset = defCharset } - - if (header['content-disposition']) { - parsed = parseParams(header['content-disposition'][0]) - if (!RE_FIELD.test(parsed[0])) { return skipPart(part) } - for (i = 0, len = parsed.length; i < len; ++i) { - if (RE_NAME.test(parsed[i][0])) { - fieldname = parsed[i][1] - } else if (RE_FILENAME.test(parsed[i][0])) { - filename = parsed[i][1] - if (!preservePath) { filename = basename(filename) } - } - } - } else { return skipPart(part) } - - if (header['content-transfer-encoding']) { encoding = header['content-transfer-encoding'][0].toLowerCase() } else { encoding = '7bit' } - - let onData, - onEnd - - if (isPartAFile(fieldname, contype, filename)) { - // file/binary field - if (nfiles === filesLimit) { - if (!boy.hitFilesLimit) { - boy.hitFilesLimit = true - boy.emit('filesLimit') - } - return skipPart(part) + get name() { + webidl.brandCheck(this, _File); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _File); + return this[kState].lastModified; + } + get type() { + webidl.brandCheck(this, _File); + return this[kState].type; + } + }; + var FileLike = class _FileLike { + constructor(blobLike, fileName, options = {}) { + const n = fileName; + const t = options.type; + const d = options.lastModified ?? Date.now(); + this[kState] = { + blobLike, + name: n, + type: t, + lastModified: d + }; + } + stream(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.stream(...args); + } + arrayBuffer(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.arrayBuffer(...args); + } + slice(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.slice(...args); + } + text(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.text(...args); + } + get size() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.size; + } + get type() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.type; + } + get name() { + webidl.brandCheck(this, _FileLike); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _FileLike); + return this[kState].lastModified; + } + get [Symbol.toStringTag]() { + return "File"; + } + }; + Object.defineProperties(File2.prototype, { + [Symbol.toStringTag]: { + value: "File", + configurable: true + }, + name: kEnumerableProperty, + lastModified: kEnumerableProperty + }); + webidl.converters.Blob = webidl.interfaceConverter(Blob2); + webidl.converters.BlobPart = function(V, opts) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); } - - ++nfiles - - if (boy.listenerCount('file') === 0) { - self.parser._ignore() - return + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V, opts); } - - ++nends - const file = new FileStream(fileOpts) - curFile = file - file.on('end', function () { - --nends - self._pause = false - checkFinished() - if (self._cb && !self._needDrain) { - const cb = self._cb - self._cb = undefined - cb() + } + return webidl.converters.USVString(V, opts); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.BlobPart + ); + webidl.converters.FilePropertyBag = webidl.dictionaryConverter([ + { + key: "lastModified", + converter: webidl.converters["long long"], + get defaultValue() { + return Date.now(); + } + }, + { + key: "type", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "endings", + converter: (value) => { + value = webidl.converters.DOMString(value); + value = value.toLowerCase(); + if (value !== "native") { + value = "transparent"; } - }) - file._read = function (n) { - if (!self._pause) { return } - self._pause = false - if (self._cb && !self._needDrain) { - const cb = self._cb - self._cb = undefined - cb() + return value; + }, + defaultValue: "transparent" + } + ]); + function processBlobParts(parts, options) { + const bytes = []; + for (const element of parts) { + if (typeof element === "string") { + let s = element; + if (options.endings === "native") { + s = convertLineEndingsNative(s); } - } - boy.emit('file', fieldname, file, filename, encoding, contype) - - onData = function (data) { - if ((nsize += data.length) > fileSizeLimit) { - const extralen = fileSizeLimit - nsize + data.length - if (extralen > 0) { file.push(data.slice(0, extralen)) } - file.truncated = true - file.bytesRead = fileSizeLimit - part.removeAllListeners('data') - file.emit('limit') - return - } else if (!file.push(data)) { self._pause = true } - - file.bytesRead = nsize - } - - onEnd = function () { - curFile = undefined - file.push(null) - } - } else { - // non-file field - if (nfields === fieldsLimit) { - if (!boy.hitFieldsLimit) { - boy.hitFieldsLimit = true - boy.emit('fieldsLimit') + bytes.push(encoder.encode(s)); + } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) { + if (!element.buffer) { + bytes.push(new Uint8Array(element)); + } else { + bytes.push( + new Uint8Array(element.buffer, element.byteOffset, element.byteLength) + ); } - return skipPart(part) - } - - ++nfields - ++nends - let buffer = '' - let truncated = false - curField = part - - onData = function (data) { - if ((nsize += data.length) > fieldSizeLimit) { - const extralen = (fieldSizeLimit - (nsize - data.length)) - buffer += data.toString('binary', 0, extralen) - truncated = true - part.removeAllListeners('data') - } else { buffer += data.toString('binary') } - } - - onEnd = function () { - curField = undefined - if (buffer.length) { buffer = decodeText(buffer, 'binary', charset) } - boy.emit('field', fieldname, buffer, false, truncated, encoding, contype) - --nends - checkFinished() + } else if (isBlobLike2(element)) { + bytes.push(element); } } - - /* As of node@2efe4ab761666 (v0.10.29+/v0.11.14+), busboy had become - broken. Streams2/streams3 is a huge black box of confusion, but - somehow overriding the sync state seems to fix things again (and still - seems to work for previous node versions). - */ - part._readableState.sync = false - - part.on('data', onData) - part.on('end', onEnd) - }).on('error', function (err) { - if (curFile) { curFile.emit('error', err) } - }) - }).on('error', function (err) { - boy.emit('error', err) - }).on('finish', function () { - finished = true - checkFinished() - }) -} - -Multipart.prototype.write = function (chunk, cb) { - const r = this.parser.write(chunk) - if (r && !this._pause) { - cb() - } else { - this._needDrain = !r - this._cb = cb - } -} - -Multipart.prototype.end = function () { - const self = this - - if (self.parser.writable) { - self.parser.end() - } else if (!self._boy._done) { - process.nextTick(function () { - self._boy._done = true - self._boy.emit('finish') - }) - } -} - -function skipPart (part) { - part.resume() -} - -function FileStream (opts) { - Readable.call(this, opts) - - this.bytesRead = 0 - - this.truncated = false -} - -inherits(FileStream, Readable) - -FileStream.prototype._read = function (n) {} - -module.exports = Multipart - - -/***/ }), - -/***/ 855: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; - - -const Decoder = __nccwpck_require__(1496) -const decodeText = __nccwpck_require__(2747) -const getLimit = __nccwpck_require__(2393) - -const RE_CHARSET = /^charset$/i - -UrlEncoded.detect = /^application\/x-www-form-urlencoded/i -function UrlEncoded (boy, cfg) { - const limits = cfg.limits - const parsedConType = cfg.parsedConType - this.boy = boy - - this.fieldSizeLimit = getLimit(limits, 'fieldSize', 1 * 1024 * 1024) - this.fieldNameSizeLimit = getLimit(limits, 'fieldNameSize', 100) - this.fieldsLimit = getLimit(limits, 'fields', Infinity) - - let charset - for (var i = 0, len = parsedConType.length; i < len; ++i) { // eslint-disable-line no-var - if (Array.isArray(parsedConType[i]) && - RE_CHARSET.test(parsedConType[i][0])) { - charset = parsedConType[i][1].toLowerCase() - break + return bytes; } - } - - if (charset === undefined) { charset = cfg.defCharset || 'utf8' } - - this.decoder = new Decoder() - this.charset = charset - this._fields = 0 - this._state = 'key' - this._checkingBytes = true - this._bytesKey = 0 - this._bytesVal = 0 - this._key = '' - this._val = '' - this._keyTrunc = false - this._valTrunc = false - this._hitLimit = false -} - -UrlEncoded.prototype.write = function (data, cb) { - if (this._fields === this.fieldsLimit) { - if (!this.boy.hitFieldsLimit) { - this.boy.hitFieldsLimit = true - this.boy.emit('fieldsLimit') + function convertLineEndingsNative(s) { + let nativeLineEnding = "\n"; + if (process.platform === "win32") { + nativeLineEnding = "\r\n"; + } + return s.replace(/\r?\n/g, nativeLineEnding); + } + function isFileLike2(object) { + return NativeFile && object instanceof NativeFile || object instanceof File2 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File"; } - return cb() + module2.exports = { File: File2, FileLike, isFileLike: isFileLike2 }; } +}); - let idxeq; let idxamp; let i; let p = 0; const len = data.length - - while (p < len) { - if (this._state === 'key') { - idxeq = idxamp = undefined - for (i = p; i < len; ++i) { - if (!this._checkingBytes) { ++p } - if (data[i] === 0x3D/* = */) { - idxeq = i - break - } else if (data[i] === 0x26/* & */) { - idxamp = i - break - } - if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) { - this._hitLimit = true - break - } else if (this._checkingBytes) { ++this._bytesKey } +// node_modules/undici/lib/fetch/formdata.js +var require_formdata = __commonJS({ + "node_modules/undici/lib/fetch/formdata.js"(exports2, module2) { + "use strict"; + var { isBlobLike: isBlobLike2, toUSVString, makeIterator } = require_util2(); + var { kState } = require_symbols2(); + var { File: UndiciFile, FileLike, isFileLike: isFileLike2 } = require_file(); + var { webidl } = require_webidl(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var File2 = NativeFile ?? UndiciFile; + var FormData2 = class _FormData { + constructor(form) { + if (form !== void 0) { + throw webidl.errors.conversionFailed({ + prefix: "FormData constructor", + argument: "Argument 1", + types: ["undefined"] + }); + } + this[kState] = []; + } + append(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + this[kState].push(entry); + } + delete(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" }); + name = webidl.converters.USVString(name); + this[kState] = this[kState].filter((entry) => entry.name !== name); + } + get(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" }); + name = webidl.converters.USVString(name); + const idx = this[kState].findIndex((entry) => entry.name === name); + if (idx === -1) { + return null; + } + return this[kState][idx].value; + } + getAll(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" }); + name = webidl.converters.USVString(name); + return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); + } + has(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" }); + name = webidl.converters.USVString(name); + return this[kState].findIndex((entry) => entry.name === name) !== -1; + } + set(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? toUSVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + const idx = this[kState].findIndex((entry2) => entry2.name === name); + if (idx !== -1) { + this[kState] = [ + ...this[kState].slice(0, idx), + entry, + ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name) + ]; + } else { + this[kState].push(entry); + } + } + entries() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key+value" + ); + } + keys() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key" + ); + } + values() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "value" + ); } - - if (idxeq !== undefined) { - // key with assignment - if (idxeq > p) { this._key += this.decoder.write(data.toString('binary', p, idxeq)) } - this._state = 'val' - - this._hitLimit = false - this._checkingBytes = true - this._val = '' - this._bytesVal = 0 - this._valTrunc = false - this.decoder.reset() - - p = idxeq + 1 - } else if (idxamp !== undefined) { - // key with no assignment - ++this._fields - let key; const keyTrunc = this._keyTrunc - if (idxamp > p) { key = (this._key += this.decoder.write(data.toString('binary', p, idxamp))) } else { key = this._key } - - this._hitLimit = false - this._checkingBytes = true - this._key = '' - this._bytesKey = 0 - this._keyTrunc = false - this.decoder.reset() - - if (key.length) { - this.boy.emit('field', decodeText(key, 'binary', this.charset), - '', - keyTrunc, - false) + /** + * @param {(value: string, key: string, self: FormData) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'." + ); } - - p = idxamp + 1 - if (this._fields === this.fieldsLimit) { return cb() } - } else if (this._hitLimit) { - // we may not have hit the actual limit if there are encoded bytes... - if (i > p) { this._key += this.decoder.write(data.toString('binary', p, i)) } - p = i - if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) { - // yep, we actually did hit the limit - this._checkingBytes = false - this._keyTrunc = true + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); } - } else { - if (p < len) { this._key += this.decoder.write(data.toString('binary', p)) } - p = len - } - } else { - idxamp = undefined - for (i = p; i < len; ++i) { - if (!this._checkingBytes) { ++p } - if (data[i] === 0x26/* & */) { - idxamp = i - break - } - if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) { - this._hitLimit = true - break - } else if (this._checkingBytes) { ++this._bytesVal } } - - if (idxamp !== undefined) { - ++this._fields - if (idxamp > p) { this._val += this.decoder.write(data.toString('binary', p, idxamp)) } - this.boy.emit('field', decodeText(this._key, 'binary', this.charset), - decodeText(this._val, 'binary', this.charset), - this._keyTrunc, - this._valTrunc) - this._state = 'key' - - this._hitLimit = false - this._checkingBytes = true - this._key = '' - this._bytesKey = 0 - this._keyTrunc = false - this.decoder.reset() - - p = idxamp + 1 - if (this._fields === this.fieldsLimit) { return cb() } - } else if (this._hitLimit) { - // we may not have hit the actual limit if there are encoded bytes... - if (i > p) { this._val += this.decoder.write(data.toString('binary', p, i)) } - p = i - if ((this._val === '' && this.fieldSizeLimit === 0) || - (this._bytesVal = this._val.length) === this.fieldSizeLimit) { - // yep, we actually did hit the limit - this._checkingBytes = false - this._valTrunc = true - } - } else { - if (p < len) { this._val += this.decoder.write(data.toString('binary', p)) } - p = len + }; + FormData2.prototype[Symbol.iterator] = FormData2.prototype.entries; + Object.defineProperties(FormData2.prototype, { + [Symbol.toStringTag]: { + value: "FormData", + configurable: true } - } - } - cb() -} - -UrlEncoded.prototype.end = function () { - if (this.boy._done) { return } - - if (this._state === 'key' && this._key.length > 0) { - this.boy.emit('field', decodeText(this._key, 'binary', this.charset), - '', - this._keyTrunc, - false) - } else if (this._state === 'val') { - this.boy.emit('field', decodeText(this._key, 'binary', this.charset), - decodeText(this._val, 'binary', this.charset), - this._keyTrunc, - this._valTrunc) - } - this.boy._done = true - this.boy.emit('finish') -} - -module.exports = UrlEncoded - - -/***/ }), - -/***/ 1496: -/***/ ((module) => { - -"use strict"; - - -const RE_PLUS = /\+/g - -const HEX = [ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, - 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -] - -function Decoder () { - this.buffer = undefined -} -Decoder.prototype.write = function (str) { - // Replace '+' with ' ' before decoding - str = str.replace(RE_PLUS, ' ') - let res = '' - let i = 0; let p = 0; const len = str.length - for (; i < len; ++i) { - if (this.buffer !== undefined) { - if (!HEX[str.charCodeAt(i)]) { - res += '%' + this.buffer - this.buffer = undefined - --i // retry character + }); + function makeEntry(name, value, filename) { + name = Buffer.from(name).toString("utf8"); + if (typeof value === "string") { + value = Buffer.from(value).toString("utf8"); } else { - this.buffer += str[i] - ++p - if (this.buffer.length === 2) { - res += String.fromCharCode(parseInt(this.buffer, 16)) - this.buffer = undefined + if (!isFileLike2(value)) { + value = value instanceof Blob2 ? new File2([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type }); + } + if (filename !== void 0) { + const options = { + type: value.type, + lastModified: value.lastModified + }; + value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File2([value], filename, options) : new FileLike(value, filename, options); } } - } else if (str[i] === '%') { - if (i > p) { - res += str.substring(p, i) - p = i - } - this.buffer = '' - ++p - } - } - if (p < len && this.buffer === undefined) { res += str.substring(p) } - return res -} -Decoder.prototype.reset = function () { - this.buffer = undefined -} - -module.exports = Decoder - - -/***/ }), - -/***/ 692: -/***/ ((module) => { - -"use strict"; - - -module.exports = function basename (path) { - if (typeof path !== 'string') { return '' } - for (var i = path.length - 1; i >= 0; --i) { // eslint-disable-line no-var - switch (path.charCodeAt(i)) { - case 0x2F: // '/' - case 0x5C: // '\' - path = path.slice(i + 1) - return (path === '..' || path === '.' ? '' : path) - } - } - return (path === '..' || path === '.' ? '' : path) -} - - -/***/ }), - -/***/ 2747: -/***/ (function(module) { - -"use strict"; - - -// Node has always utf-8 -const utf8Decoder = new TextDecoder('utf-8') -const textDecoders = new Map([ - ['utf-8', utf8Decoder], - ['utf8', utf8Decoder] -]) - -function getDecoder (charset) { - let lc - while (true) { - switch (charset) { - case 'utf-8': - case 'utf8': - return decoders.utf8 - case 'latin1': - case 'ascii': // TODO: Make these a separate, strict decoder? - case 'us-ascii': - case 'iso-8859-1': - case 'iso8859-1': - case 'iso88591': - case 'iso_8859-1': - case 'windows-1252': - case 'iso_8859-1:1987': - case 'cp1252': - case 'x-cp1252': - return decoders.latin1 - case 'utf16le': - case 'utf-16le': - case 'ucs2': - case 'ucs-2': - return decoders.utf16le - case 'base64': - return decoders.base64 - default: - if (lc === undefined) { - lc = true - charset = charset.toLowerCase() - continue - } - return decoders.other.bind(charset) - } - } -} - -const decoders = { - utf8: (data, sourceEncoding) => { - if (data.length === 0) { - return '' - } - if (typeof data === 'string') { - data = Buffer.from(data, sourceEncoding) - } - return data.utf8Slice(0, data.length) - }, - - latin1: (data, sourceEncoding) => { - if (data.length === 0) { - return '' - } - if (typeof data === 'string') { - return data - } - return data.latin1Slice(0, data.length) - }, - - utf16le: (data, sourceEncoding) => { - if (data.length === 0) { - return '' - } - if (typeof data === 'string') { - data = Buffer.from(data, sourceEncoding) - } - return data.ucs2Slice(0, data.length) - }, - - base64: (data, sourceEncoding) => { - if (data.length === 0) { - return '' - } - if (typeof data === 'string') { - data = Buffer.from(data, sourceEncoding) - } - return data.base64Slice(0, data.length) - }, - - other: (data, sourceEncoding) => { - if (data.length === 0) { - return '' - } - if (typeof data === 'string') { - data = Buffer.from(data, sourceEncoding) - } - - if (textDecoders.has(this.toString())) { - try { - return textDecoders.get(this).decode(data) - } catch {} + return { name, value }; } - return typeof data === 'string' - ? data - : data.toString() - } -} - -function decodeText (text, sourceEncoding, destEncoding) { - if (text) { - return getDecoder(destEncoding)(text, sourceEncoding) - } - return text -} - -module.exports = decodeText - - -/***/ }), - -/***/ 2393: -/***/ ((module) => { - -"use strict"; - - -module.exports = function getLimit (limits, name, defaultLimit) { - if ( - !limits || - limits[name] === undefined || - limits[name] === null - ) { return defaultLimit } - - if ( - typeof limits[name] !== 'number' || - isNaN(limits[name]) - ) { throw new TypeError('Limit ' + name + ' is not a valid number') } - - return limits[name] -} - - -/***/ }), - -/***/ 8929: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -"use strict"; -/* eslint-disable object-property-newline */ - - -const decodeText = __nccwpck_require__(2747) - -const RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g - -const EncodedLookup = { - '%00': '\x00', '%01': '\x01', '%02': '\x02', '%03': '\x03', '%04': '\x04', - '%05': '\x05', '%06': '\x06', '%07': '\x07', '%08': '\x08', '%09': '\x09', - '%0a': '\x0a', '%0A': '\x0a', '%0b': '\x0b', '%0B': '\x0b', '%0c': '\x0c', - '%0C': '\x0c', '%0d': '\x0d', '%0D': '\x0d', '%0e': '\x0e', '%0E': '\x0e', - '%0f': '\x0f', '%0F': '\x0f', '%10': '\x10', '%11': '\x11', '%12': '\x12', - '%13': '\x13', '%14': '\x14', '%15': '\x15', '%16': '\x16', '%17': '\x17', - '%18': '\x18', '%19': '\x19', '%1a': '\x1a', '%1A': '\x1a', '%1b': '\x1b', - '%1B': '\x1b', '%1c': '\x1c', '%1C': '\x1c', '%1d': '\x1d', '%1D': '\x1d', - '%1e': '\x1e', '%1E': '\x1e', '%1f': '\x1f', '%1F': '\x1f', '%20': '\x20', - '%21': '\x21', '%22': '\x22', '%23': '\x23', '%24': '\x24', '%25': '\x25', - '%26': '\x26', '%27': '\x27', '%28': '\x28', '%29': '\x29', '%2a': '\x2a', - '%2A': '\x2a', '%2b': '\x2b', '%2B': '\x2b', '%2c': '\x2c', '%2C': '\x2c', - '%2d': '\x2d', '%2D': '\x2d', '%2e': '\x2e', '%2E': '\x2e', '%2f': '\x2f', - '%2F': '\x2f', '%30': '\x30', '%31': '\x31', '%32': '\x32', '%33': '\x33', - '%34': '\x34', '%35': '\x35', '%36': '\x36', '%37': '\x37', '%38': '\x38', - '%39': '\x39', '%3a': '\x3a', '%3A': '\x3a', '%3b': '\x3b', '%3B': '\x3b', - '%3c': '\x3c', '%3C': '\x3c', '%3d': '\x3d', '%3D': '\x3d', '%3e': '\x3e', - '%3E': '\x3e', '%3f': '\x3f', '%3F': '\x3f', '%40': '\x40', '%41': '\x41', - '%42': '\x42', '%43': '\x43', '%44': '\x44', '%45': '\x45', '%46': '\x46', - '%47': '\x47', '%48': '\x48', '%49': '\x49', '%4a': '\x4a', '%4A': '\x4a', - '%4b': '\x4b', '%4B': '\x4b', '%4c': '\x4c', '%4C': '\x4c', '%4d': '\x4d', - '%4D': '\x4d', '%4e': '\x4e', '%4E': '\x4e', '%4f': '\x4f', '%4F': '\x4f', - '%50': '\x50', '%51': '\x51', '%52': '\x52', '%53': '\x53', '%54': '\x54', - '%55': '\x55', '%56': '\x56', '%57': '\x57', '%58': '\x58', '%59': '\x59', - '%5a': '\x5a', '%5A': '\x5a', '%5b': '\x5b', '%5B': '\x5b', '%5c': '\x5c', - '%5C': '\x5c', '%5d': '\x5d', '%5D': '\x5d', '%5e': '\x5e', '%5E': '\x5e', - '%5f': '\x5f', '%5F': '\x5f', '%60': '\x60', '%61': '\x61', '%62': '\x62', - '%63': '\x63', '%64': '\x64', '%65': '\x65', '%66': '\x66', '%67': '\x67', - '%68': '\x68', '%69': '\x69', '%6a': '\x6a', '%6A': '\x6a', '%6b': '\x6b', - '%6B': '\x6b', '%6c': '\x6c', '%6C': '\x6c', '%6d': '\x6d', '%6D': '\x6d', - '%6e': '\x6e', '%6E': '\x6e', '%6f': '\x6f', '%6F': '\x6f', '%70': '\x70', - '%71': '\x71', '%72': '\x72', '%73': '\x73', '%74': '\x74', '%75': '\x75', - '%76': '\x76', '%77': '\x77', '%78': '\x78', '%79': '\x79', '%7a': '\x7a', - '%7A': '\x7a', '%7b': '\x7b', '%7B': '\x7b', '%7c': '\x7c', '%7C': '\x7c', - '%7d': '\x7d', '%7D': '\x7d', '%7e': '\x7e', '%7E': '\x7e', '%7f': '\x7f', - '%7F': '\x7f', '%80': '\x80', '%81': '\x81', '%82': '\x82', '%83': '\x83', - '%84': '\x84', '%85': '\x85', '%86': '\x86', '%87': '\x87', '%88': '\x88', - '%89': '\x89', '%8a': '\x8a', '%8A': '\x8a', '%8b': '\x8b', '%8B': '\x8b', - '%8c': '\x8c', '%8C': '\x8c', '%8d': '\x8d', '%8D': '\x8d', '%8e': '\x8e', - '%8E': '\x8e', '%8f': '\x8f', '%8F': '\x8f', '%90': '\x90', '%91': '\x91', - '%92': '\x92', '%93': '\x93', '%94': '\x94', '%95': '\x95', '%96': '\x96', - '%97': '\x97', '%98': '\x98', '%99': '\x99', '%9a': '\x9a', '%9A': '\x9a', - '%9b': '\x9b', '%9B': '\x9b', '%9c': '\x9c', '%9C': '\x9c', '%9d': '\x9d', - '%9D': '\x9d', '%9e': '\x9e', '%9E': '\x9e', '%9f': '\x9f', '%9F': '\x9f', - '%a0': '\xa0', '%A0': '\xa0', '%a1': '\xa1', '%A1': '\xa1', '%a2': '\xa2', - '%A2': '\xa2', '%a3': '\xa3', '%A3': '\xa3', '%a4': '\xa4', '%A4': '\xa4', - '%a5': '\xa5', '%A5': '\xa5', '%a6': '\xa6', '%A6': '\xa6', '%a7': '\xa7', - '%A7': '\xa7', '%a8': '\xa8', '%A8': '\xa8', '%a9': '\xa9', '%A9': '\xa9', - '%aa': '\xaa', '%Aa': '\xaa', '%aA': '\xaa', '%AA': '\xaa', '%ab': '\xab', - '%Ab': '\xab', '%aB': '\xab', '%AB': '\xab', '%ac': '\xac', '%Ac': '\xac', - '%aC': '\xac', '%AC': '\xac', '%ad': '\xad', '%Ad': '\xad', '%aD': '\xad', - '%AD': '\xad', '%ae': '\xae', '%Ae': '\xae', '%aE': '\xae', '%AE': '\xae', - '%af': '\xaf', '%Af': '\xaf', '%aF': '\xaf', '%AF': '\xaf', '%b0': '\xb0', - '%B0': '\xb0', '%b1': '\xb1', '%B1': '\xb1', '%b2': '\xb2', '%B2': '\xb2', - '%b3': '\xb3', '%B3': '\xb3', '%b4': '\xb4', '%B4': '\xb4', '%b5': '\xb5', - '%B5': '\xb5', '%b6': '\xb6', '%B6': '\xb6', '%b7': '\xb7', '%B7': '\xb7', - '%b8': '\xb8', '%B8': '\xb8', '%b9': '\xb9', '%B9': '\xb9', '%ba': '\xba', - '%Ba': '\xba', '%bA': '\xba', '%BA': '\xba', '%bb': '\xbb', '%Bb': '\xbb', - '%bB': '\xbb', '%BB': '\xbb', '%bc': '\xbc', '%Bc': '\xbc', '%bC': '\xbc', - '%BC': '\xbc', '%bd': '\xbd', '%Bd': '\xbd', '%bD': '\xbd', '%BD': '\xbd', - '%be': '\xbe', '%Be': '\xbe', '%bE': '\xbe', '%BE': '\xbe', '%bf': '\xbf', - '%Bf': '\xbf', '%bF': '\xbf', '%BF': '\xbf', '%c0': '\xc0', '%C0': '\xc0', - '%c1': '\xc1', '%C1': '\xc1', '%c2': '\xc2', '%C2': '\xc2', '%c3': '\xc3', - '%C3': '\xc3', '%c4': '\xc4', '%C4': '\xc4', '%c5': '\xc5', '%C5': '\xc5', - '%c6': '\xc6', '%C6': '\xc6', '%c7': '\xc7', '%C7': '\xc7', '%c8': '\xc8', - '%C8': '\xc8', '%c9': '\xc9', '%C9': '\xc9', '%ca': '\xca', '%Ca': '\xca', - '%cA': '\xca', '%CA': '\xca', '%cb': '\xcb', '%Cb': '\xcb', '%cB': '\xcb', - '%CB': '\xcb', '%cc': '\xcc', '%Cc': '\xcc', '%cC': '\xcc', '%CC': '\xcc', - '%cd': '\xcd', '%Cd': '\xcd', '%cD': '\xcd', '%CD': '\xcd', '%ce': '\xce', - '%Ce': '\xce', '%cE': '\xce', '%CE': '\xce', '%cf': '\xcf', '%Cf': '\xcf', - '%cF': '\xcf', '%CF': '\xcf', '%d0': '\xd0', '%D0': '\xd0', '%d1': '\xd1', - '%D1': '\xd1', '%d2': '\xd2', '%D2': '\xd2', '%d3': '\xd3', '%D3': '\xd3', - '%d4': '\xd4', '%D4': '\xd4', '%d5': '\xd5', '%D5': '\xd5', '%d6': '\xd6', - '%D6': '\xd6', '%d7': '\xd7', '%D7': '\xd7', '%d8': '\xd8', '%D8': '\xd8', - '%d9': '\xd9', '%D9': '\xd9', '%da': '\xda', '%Da': '\xda', '%dA': '\xda', - '%DA': '\xda', '%db': '\xdb', '%Db': '\xdb', '%dB': '\xdb', '%DB': '\xdb', - '%dc': '\xdc', '%Dc': '\xdc', '%dC': '\xdc', '%DC': '\xdc', '%dd': '\xdd', - '%Dd': '\xdd', '%dD': '\xdd', '%DD': '\xdd', '%de': '\xde', '%De': '\xde', - '%dE': '\xde', '%DE': '\xde', '%df': '\xdf', '%Df': '\xdf', '%dF': '\xdf', - '%DF': '\xdf', '%e0': '\xe0', '%E0': '\xe0', '%e1': '\xe1', '%E1': '\xe1', - '%e2': '\xe2', '%E2': '\xe2', '%e3': '\xe3', '%E3': '\xe3', '%e4': '\xe4', - '%E4': '\xe4', '%e5': '\xe5', '%E5': '\xe5', '%e6': '\xe6', '%E6': '\xe6', - '%e7': '\xe7', '%E7': '\xe7', '%e8': '\xe8', '%E8': '\xe8', '%e9': '\xe9', - '%E9': '\xe9', '%ea': '\xea', '%Ea': '\xea', '%eA': '\xea', '%EA': '\xea', - '%eb': '\xeb', '%Eb': '\xeb', '%eB': '\xeb', '%EB': '\xeb', '%ec': '\xec', - '%Ec': '\xec', '%eC': '\xec', '%EC': '\xec', '%ed': '\xed', '%Ed': '\xed', - '%eD': '\xed', '%ED': '\xed', '%ee': '\xee', '%Ee': '\xee', '%eE': '\xee', - '%EE': '\xee', '%ef': '\xef', '%Ef': '\xef', '%eF': '\xef', '%EF': '\xef', - '%f0': '\xf0', '%F0': '\xf0', '%f1': '\xf1', '%F1': '\xf1', '%f2': '\xf2', - '%F2': '\xf2', '%f3': '\xf3', '%F3': '\xf3', '%f4': '\xf4', '%F4': '\xf4', - '%f5': '\xf5', '%F5': '\xf5', '%f6': '\xf6', '%F6': '\xf6', '%f7': '\xf7', - '%F7': '\xf7', '%f8': '\xf8', '%F8': '\xf8', '%f9': '\xf9', '%F9': '\xf9', - '%fa': '\xfa', '%Fa': '\xfa', '%fA': '\xfa', '%FA': '\xfa', '%fb': '\xfb', - '%Fb': '\xfb', '%fB': '\xfb', '%FB': '\xfb', '%fc': '\xfc', '%Fc': '\xfc', - '%fC': '\xfc', '%FC': '\xfc', '%fd': '\xfd', '%Fd': '\xfd', '%fD': '\xfd', - '%FD': '\xfd', '%fe': '\xfe', '%Fe': '\xfe', '%fE': '\xfe', '%FE': '\xfe', - '%ff': '\xff', '%Ff': '\xff', '%fF': '\xff', '%FF': '\xff' -} - -function encodedReplacer (match) { - return EncodedLookup[match] -} - -const STATE_KEY = 0 -const STATE_VALUE = 1 -const STATE_CHARSET = 2 -const STATE_LANG = 3 - -function parseParams (str) { - const res = [] - let state = STATE_KEY - let charset = '' - let inquote = false - let escaping = false - let p = 0 - let tmp = '' - const len = str.length - - for (var i = 0; i < len; ++i) { // eslint-disable-line no-var - const char = str[i] - if (char === '\\' && inquote) { - if (escaping) { escaping = false } else { - escaping = true - continue - } - } else if (char === '"') { - if (!escaping) { - if (inquote) { - inquote = false - state = STATE_KEY - } else { inquote = true } - continue - } else { escaping = false } - } else { - if (escaping && inquote) { tmp += '\\' } - escaping = false - if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") { - if (state === STATE_CHARSET) { - state = STATE_LANG - charset = tmp.substring(1) - } else { state = STATE_VALUE } - tmp = '' - continue - } else if (state === STATE_KEY && - (char === '*' || char === '=') && - res.length) { - state = char === '*' - ? STATE_CHARSET - : STATE_VALUE - res[p] = [tmp, undefined] - tmp = '' - continue - } else if (!inquote && char === ';') { - state = STATE_KEY - if (charset) { - if (tmp.length) { - tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer), - 'binary', - charset) - } - charset = '' - } else if (tmp.length) { - tmp = decodeText(tmp, 'binary', 'utf8') - } - if (res[p] === undefined) { res[p] = tmp } else { res[p][1] = tmp } - tmp = '' - ++p - continue - } else if (!inquote && (char === ' ' || char === '\t')) { continue } - } - tmp += char - } - if (charset && tmp.length) { - tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer), - 'binary', - charset) - } else if (tmp) { - tmp = decodeText(tmp, 'binary', 'utf8') + module2.exports = { FormData: FormData2 }; } +}); - if (res[p] === undefined) { - if (tmp) { res[p] = tmp } - } else { res[p][1] = tmp } - - return res -} - -module.exports = parseParams - - -/***/ }), - -/***/ 9596: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -var _Stainless_instances, _a, _Stainless_encoder, _Stainless_baseURLOverridden; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Stainless = void 0; -const tslib_1 = __nccwpck_require__(533); -const uuid_1 = __nccwpck_require__(7008); -const values_1 = __nccwpck_require__(5537); -const sleep_1 = __nccwpck_require__(3160); -const errors_1 = __nccwpck_require__(4838); -const detect_platform_1 = __nccwpck_require__(4728); -const Shims = tslib_1.__importStar(__nccwpck_require__(9019)); -const Opts = tslib_1.__importStar(__nccwpck_require__(6340)); -const qs = tslib_1.__importStar(__nccwpck_require__(5186)); -const version_1 = __nccwpck_require__(8027); -const Errors = tslib_1.__importStar(__nccwpck_require__(3801)); -const Pagination = tslib_1.__importStar(__nccwpck_require__(8575)); -const Uploads = tslib_1.__importStar(__nccwpck_require__(1305)); -const API = tslib_1.__importStar(__nccwpck_require__(9789)); -const api_promise_1 = __nccwpck_require__(147); -const generate_1 = __nccwpck_require__(786); -const orgs_1 = __nccwpck_require__(9366); -const builds_1 = __nccwpck_require__(5786); -const projects_1 = __nccwpck_require__(8120); -const headers_1 = __nccwpck_require__(9191); -const env_1 = __nccwpck_require__(3516); -const log_1 = __nccwpck_require__(277); -const values_2 = __nccwpck_require__(5537); -const unwrap_1 = __nccwpck_require__(7568); -/** - * API Client for interfacing with the Stainless API. - */ -class Stainless { - /** - * API Client for interfacing with the Stainless API. - * - * @param {string | null | undefined} [opts.apiKey=process.env['STAINLESS_API_KEY'] ?? null] - * @param {string | null | undefined} [opts.project] - * @param {string} [opts.baseURL=process.env['STAINLESS_BASE_URL'] ?? https://api.stainless.com] - Override the default base URL for the API. - * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out. - * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls. - * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation. - * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request. - * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API. - * @param {Record} opts.defaultQuery - Default query parameters to include with every request to the API. - */ - constructor({ baseURL = (0, env_1.readEnv)('STAINLESS_BASE_URL'), apiKey = (0, env_1.readEnv)('STAINLESS_API_KEY') ?? null, project = null, ...opts } = {}) { - _Stainless_instances.add(this); - _Stainless_encoder.set(this, void 0); - this.projects = new API.Projects(this); - this.builds = new API.Builds(this); - this.orgs = new API.Orgs(this); - this.generate = new API.Generate(this); - const options = { - apiKey, - project, - ...opts, - baseURL: baseURL || `https://api.stainless.com`, - }; - this.baseURL = options.baseURL; - this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT /* 1 minute */; - this.logger = options.logger ?? console; - const defaultLogLevel = 'warn'; - // Set default logLevel early so that we can log a warning in parseLogLevel. - this.logLevel = defaultLogLevel; - this.logLevel = - (0, log_1.parseLogLevel)(options.logLevel, 'ClientOptions.logLevel', this) ?? - (0, log_1.parseLogLevel)((0, env_1.readEnv)('STAINLESS_LOG'), "process.env['STAINLESS_LOG']", this) ?? - defaultLogLevel; - this.fetchOptions = options.fetchOptions; - this.maxRetries = options.maxRetries ?? 2; - this.fetch = options.fetch ?? Shims.getDefaultFetch(); - tslib_1.__classPrivateFieldSet(this, _Stainless_encoder, Opts.FallbackEncoder, "f"); - this._options = options; - this.apiKey = apiKey; - this.project = project; - } - /** - * Create a new client instance re-using the same options given to the current client with optional overriding. - */ - withOptions(options) { - return new this.constructor({ - ...this._options, - baseURL: this.baseURL, - maxRetries: this.maxRetries, - timeout: this.timeout, - logger: this.logger, - logLevel: this.logLevel, - fetch: this.fetch, - fetchOptions: this.fetchOptions, - apiKey: this.apiKey, - project: this.project, - ...options, +// node_modules/undici/lib/fetch/body.js +var require_body = __commonJS({ + "node_modules/undici/lib/fetch/body.js"(exports2, module2) { + "use strict"; + var Busboy = require_main(); + var util = require_util(); + var { + ReadableStreamFrom: ReadableStreamFrom2, + isBlobLike: isBlobLike2, + isReadableStreamLike, + readableStreamClose, + createDeferredPromise, + fullyReadBody + } = require_util2(); + var { FormData: FormData2 } = require_formdata(); + var { kState } = require_symbols2(); + var { webidl } = require_webidl(); + var { DOMException: DOMException2, structuredClone } = require_constants2(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { isErrored } = require_util(); + var { isUint8Array, isArrayBuffer } = require("util/types"); + var { File: UndiciFile } = require_file(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var random; + try { + const crypto = require("node:crypto"); + random = (max) => crypto.randomInt(0, max); + } catch { + random = (max) => Math.floor(Math.random(max)); + } + var ReadableStream = globalThis.ReadableStream; + var File2 = NativeFile ?? UndiciFile; + var textEncoder = new TextEncoder(); + var textDecoder = new TextDecoder(); + function extractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + let stream = null; + if (object instanceof ReadableStream) { + stream = object; + } else if (isBlobLike2(object)) { + stream = object.stream(); + } else { + stream = new ReadableStream({ + async pull(controller) { + controller.enqueue( + typeof source === "string" ? textEncoder.encode(source) : source + ); + queueMicrotask(() => readableStreamClose(controller)); + }, + start() { + }, + type: void 0 }); - } - defaultQuery() { - return this._options.defaultQuery; - } - validateHeaders({ values, nulls }) { - if (this.apiKey && values.get('authorization')) { - return; - } - if (nulls.has('authorization')) { - return; + } + assert(isReadableStreamLike(stream)); + let action = null; + let source = null; + let length = null; + let type = null; + if (typeof object === "string") { + source = object; + type = "text/plain;charset=UTF-8"; + } else if (object instanceof URLSearchParams) { + source = object.toString(); + type = "application/x-www-form-urlencoded;charset=UTF-8"; + } else if (isArrayBuffer(object)) { + source = new Uint8Array(object.slice()); + } else if (ArrayBuffer.isView(object)) { + source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)); + } else if (util.isFormDataLike(object)) { + const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`; + const prefix = `--${boundary}\r +Content-Disposition: form-data`; + const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); + const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n"); + const blobParts = []; + const rn = new Uint8Array([13, 10]); + length = 0; + let hasUnknownSizeValue = false; + for (const [name, value] of object) { + if (typeof value === "string") { + const chunk2 = textEncoder.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r +\r +${normalizeLinefeeds(value)}\r +`); + blobParts.push(chunk2); + length += chunk2.byteLength; + } else { + const chunk2 = textEncoder.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r +Content-Type: ${value.type || "application/octet-stream"}\r +\r +`); + blobParts.push(chunk2, value, rn); + if (typeof value.size === "number") { + length += chunk2.byteLength + value.size + rn.byteLength; + } else { + hasUnknownSizeValue = true; + } + } } - throw new Error('Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted'); - } - authHeaders(opts) { - if (this.apiKey == null) { - return undefined; + const chunk = textEncoder.encode(`--${boundary}--`); + blobParts.push(chunk); + length += chunk.byteLength; + if (hasUnknownSizeValue) { + length = null; + } + source = object; + action = async function* () { + for (const part of blobParts) { + if (part.stream) { + yield* part.stream(); + } else { + yield part; + } + } + }; + type = "multipart/form-data; boundary=" + boundary; + } else if (isBlobLike2(object)) { + source = object; + length = object.size; + if (object.type) { + type = object.type; + } + } else if (typeof object[Symbol.asyncIterator] === "function") { + if (keepalive) { + throw new TypeError("keepalive"); + } + if (util.isDisturbed(object) || object.locked) { + throw new TypeError( + "Response body object should not be disturbed or locked" + ); + } + stream = object instanceof ReadableStream ? object : ReadableStreamFrom2(object); + } + if (typeof source === "string" || util.isBuffer(source)) { + length = Buffer.byteLength(source); + } + if (action != null) { + let iterator; + stream = new ReadableStream({ + async start() { + iterator = action(object)[Symbol.asyncIterator](); + }, + async pull(controller) { + const { value, done } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + if (!isErrored(stream)) { + controller.enqueue(new Uint8Array(value)); + } + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: void 0 + }); + } + const body = { stream, source, length }; + return [body, type]; + } + function safelyExtractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (object instanceof ReadableStream) { + assert(!util.isDisturbed(object), "The body has already been consumed."); + assert(!object.locked, "The stream is locked."); + } + return extractBody(object, keepalive); + } + function cloneBody(body) { + const [out1, out2] = body.stream.tee(); + const out2Clone = structuredClone(out2, { transfer: [out2] }); + const [, finalClone] = out2Clone.tee(); + body.stream = out1; + return { + stream: finalClone, + length: body.length, + source: body.source + }; + } + async function* consumeBody(body) { + if (body) { + if (isUint8Array(body)) { + yield body; + } else { + const stream = body.stream; + if (util.isDisturbed(stream)) { + throw new TypeError("The body has already been consumed."); + } + if (stream.locked) { + throw new TypeError("The stream is locked."); + } + stream[kBodyUsed] = true; + yield* stream; } - return (0, headers_1.buildHeaders)([{ Authorization: `Bearer ${this.apiKey}` }]); - } - stringifyQuery(query) { - return qs.stringify(query, { arrayFormat: 'comma' }); - } - getUserAgent() { - return `${this.constructor.name}/JS ${version_1.VERSION}`; - } - defaultIdempotencyKey() { - return `stainless-node-retry-${(0, uuid_1.uuid4)()}`; + } } - makeStatusError(status, error, message, headers) { - return Errors.APIError.generate(status, error, message, headers); + function throwIfAborted(state) { + if (state.aborted) { + throw new DOMException2("The operation was aborted.", "AbortError"); + } } - buildURL(path, query, defaultBaseURL) { - const baseURL = (!tslib_1.__classPrivateFieldGet(this, _Stainless_instances, "m", _Stainless_baseURLOverridden).call(this) && defaultBaseURL) || this.baseURL; - const url = (0, values_1.isAbsoluteURL)(path) ? - new URL(path) - : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path)); - const defaultQuery = this.defaultQuery(); - if (!(0, values_2.isEmptyObj)(defaultQuery)) { - query = { ...defaultQuery, ...query }; - } - if (typeof query === 'object' && query && !Array.isArray(query)) { - url.search = this.stringifyQuery(query); + function bodyMixinMethods(instance) { + const methods = { + blob() { + return specConsumeBody(this, (bytes) => { + let mimeType = bodyMimeType(this); + if (mimeType === "failure") { + mimeType = ""; + } else if (mimeType) { + mimeType = serializeAMimeType(mimeType); + } + return new Blob2([bytes], { type: mimeType }); + }, instance); + }, + arrayBuffer() { + return specConsumeBody(this, (bytes) => { + return new Uint8Array(bytes).buffer; + }, instance); + }, + text() { + return specConsumeBody(this, utf8DecodeBytes, instance); + }, + json() { + return specConsumeBody(this, parseJSONFromBytes, instance); + }, + async formData() { + webidl.brandCheck(this, instance); + throwIfAborted(this[kState]); + const contentType = this.headers.get("Content-Type"); + if (/multipart\/form-data/.test(contentType)) { + const headers = {}; + for (const [key, value] of this.headers) headers[key.toLowerCase()] = value; + const responseFormData = new FormData2(); + let busboy; + try { + busboy = new Busboy({ + headers, + preservePath: true + }); + } catch (err) { + throw new DOMException2(`${err}`, "AbortError"); + } + busboy.on("field", (name, value) => { + responseFormData.append(name, value); + }); + busboy.on("file", (name, value, filename, encoding, mimeType) => { + const chunks = []; + if (encoding === "base64" || encoding.toLowerCase() === "base64") { + let base64chunk = ""; + value.on("data", (chunk) => { + base64chunk += chunk.toString().replace(/[\r\n]/gm, ""); + const end = base64chunk.length - base64chunk.length % 4; + chunks.push(Buffer.from(base64chunk.slice(0, end), "base64")); + base64chunk = base64chunk.slice(end); + }); + value.on("end", () => { + chunks.push(Buffer.from(base64chunk, "base64")); + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } else { + value.on("data", (chunk) => { + chunks.push(chunk); + }); + value.on("end", () => { + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } + }); + const busboyResolve = new Promise((resolve, reject) => { + busboy.on("finish", resolve); + busboy.on("error", (err) => reject(new TypeError(err))); + }); + if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk); + busboy.end(); + await busboyResolve; + return responseFormData; + } else if (/application\/x-www-form-urlencoded/.test(contentType)) { + let entries; + try { + let text = ""; + const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true }); + for await (const chunk of consumeBody(this[kState].body)) { + if (!isUint8Array(chunk)) { + throw new TypeError("Expected Uint8Array chunk"); + } + text += streamingDecoder.decode(chunk, { stream: true }); + } + text += streamingDecoder.decode(); + entries = new URLSearchParams(text); + } catch (err) { + throw Object.assign(new TypeError(), { cause: err }); + } + const formData = new FormData2(); + for (const [name, value] of entries) { + formData.append(name, value); + } + return formData; + } else { + await Promise.resolve(); + throwIfAborted(this[kState]); + throw webidl.errors.exception({ + header: `${instance.name}.formData`, + message: "Could not parse content as FormData." + }); + } } - return url.toString(); + }; + return methods; } - /** - * Used as a callback for mutating the given `FinalRequestOptions` object. - */ - async prepareOptions(options) { } - /** - * Used as a callback for mutating the given `RequestInit` object. - * - * This is useful for cases where you want to add certain headers based off of - * the request properties, e.g. `method` or `url`. - */ - async prepareRequest(request, { url, options }) { } - get(path, opts) { - return this.methodRequest('get', path, opts); + function mixinBody(prototype) { + Object.assign(prototype.prototype, bodyMixinMethods(prototype)); } - post(path, opts) { - return this.methodRequest('post', path, opts); + async function specConsumeBody(object, convertBytesToJSValue, instance) { + webidl.brandCheck(object, instance); + throwIfAborted(object[kState]); + if (bodyUnusable(object[kState].body)) { + throw new TypeError("Body is unusable"); + } + const promise = createDeferredPromise(); + const errorSteps = (error2) => promise.reject(error2); + const successSteps = (data) => { + try { + promise.resolve(convertBytesToJSValue(data)); + } catch (e) { + errorSteps(e); + } + }; + if (object[kState].body == null) { + successSteps(new Uint8Array()); + return promise.promise; + } + await fullyReadBody(object[kState].body, successSteps, errorSteps); + return promise.promise; } - patch(path, opts) { - return this.methodRequest('patch', path, opts); + function bodyUnusable(body) { + return body != null && (body.stream.locked || util.isDisturbed(body.stream)); } - put(path, opts) { - return this.methodRequest('put', path, opts); + function utf8DecodeBytes(buffer) { + if (buffer.length === 0) { + return ""; + } + if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) { + buffer = buffer.subarray(3); + } + const output = textDecoder.decode(buffer); + return output; } - delete(path, opts) { - return this.methodRequest('delete', path, opts); + function parseJSONFromBytes(bytes) { + return JSON.parse(utf8DecodeBytes(bytes)); } - methodRequest(method, path, opts) { - return this.request(Promise.resolve(opts).then((opts) => { - return { method, path, ...opts }; - })); + function bodyMimeType(object) { + const { headersList } = object[kState]; + const contentType = headersList.get("content-type"); + if (contentType === null) { + return "failure"; + } + return parseMIMEType(contentType); } - request(options, remainingRetries = null) { - return new api_promise_1.APIPromise(this, this.makeRequest(options, remainingRetries, undefined)); - } - async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { - const options = await optionsInput; - const maxRetries = options.maxRetries ?? this.maxRetries; - if (retriesRemaining == null) { - retriesRemaining = maxRetries; - } - await this.prepareOptions(options); - const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); - await this.prepareRequest(req, { url, options }); - /** Not an API request ID, just for correlating local log entries. */ - const requestLogID = 'log_' + ((Math.random() * (1 << 24)) | 0).toString(16).padStart(6, '0'); - const retryLogStr = retryOfRequestLogID === undefined ? '' : `, retryOf: ${retryOfRequestLogID}`; - const startTime = Date.now(); - (0, log_1.loggerFor)(this).debug(`[${requestLogID}] sending request`, (0, log_1.formatRequestDetails)({ - retryOfRequestLogID, - method: options.method, - url, - options, - headers: req.headers, - })); - if (options.signal?.aborted) { - throw new Errors.APIUserAbortError(); - } - const controller = new AbortController(); - const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(errors_1.castToError); - const headersTime = Date.now(); - if (response instanceof Error) { - const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; - if (options.signal?.aborted) { - throw new Errors.APIUserAbortError(); - } - // detect native connection timeout errors - // deno throws "TypeError: error sending request for url (https://example/): client error (Connect): tcp connect error: Operation timed out (os error 60): Operation timed out (os error 60)" - // undici throws "TypeError: fetch failed" with cause "ConnectTimeoutError: Connect Timeout Error (attempted address: example:443, timeout: 1ms)" - // others do not provide enough information to distinguish timeouts from other connection errors - const isTimeout = (0, errors_1.isAbortError)(response) || - /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : '')); - if (retriesRemaining) { - (0, log_1.loggerFor)(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`); - (0, log_1.loggerFor)(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`, (0, log_1.formatRequestDetails)({ - retryOfRequestLogID, - url, - durationMs: headersTime - startTime, - message: response.message, - })); - return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID); - } - (0, log_1.loggerFor)(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`); - (0, log_1.loggerFor)(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`, (0, log_1.formatRequestDetails)({ - retryOfRequestLogID, - url, - durationMs: headersTime - startTime, - message: response.message, - })); - if (isTimeout) { - throw new Errors.APIConnectionTimeoutError(); - } - throw new Errors.APIConnectionError({ cause: response }); - } - const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} with status ${response.status} in ${headersTime - startTime}ms`; - if (!response.ok) { - const shouldRetry = this.shouldRetry(response); - if (retriesRemaining && shouldRetry) { - const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; - // We don't need the body of this response. - await Shims.CancelReadableStream(response.body); - (0, log_1.loggerFor)(this).info(`${responseInfo} - ${retryMessage}`); - (0, log_1.loggerFor)(this).debug(`[${requestLogID}] response error (${retryMessage})`, (0, log_1.formatRequestDetails)({ - retryOfRequestLogID, - url: response.url, - status: response.status, - headers: response.headers, - durationMs: headersTime - startTime, - })); - return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers); + module2.exports = { + extractBody, + safelyExtractBody, + cloneBody, + mixinBody + }; + } +}); + +// node_modules/undici/lib/core/request.js +var require_request = __commonJS({ + "node_modules/undici/lib/core/request.js"(exports2, module2) { + "use strict"; + var { + InvalidArgumentError, + NotSupportedError + } = require_errors2(); + var assert = require("assert"); + var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols(); + var util = require_util(); + var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/; + var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; + var invalidPathRegex = /[^\u0021-\u00ff]/; + var kHandler = Symbol("handler"); + var channels = {}; + var extractBody; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.create = diagnosticsChannel.channel("undici:request:create"); + channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent"); + channels.headers = diagnosticsChannel.channel("undici:request:headers"); + channels.trailers = diagnosticsChannel.channel("undici:request:trailers"); + channels.error = diagnosticsChannel.channel("undici:request:error"); + } catch { + channels.create = { hasSubscribers: false }; + channels.bodySent = { hasSubscribers: false }; + channels.headers = { hasSubscribers: false }; + channels.trailers = { hasSubscribers: false }; + channels.error = { hasSubscribers: false }; + } + var Request = class _Request { + constructor(origin, { + path: path2, + method, + body, + headers, + query, + idempotent, + blocking, + upgrade, + headersTimeout, + bodyTimeout, + reset, + throwOnError, + expectContinue + }, handler) { + if (typeof path2 !== "string") { + throw new InvalidArgumentError("path must be a string"); + } else if (path2[0] !== "/" && !(path2.startsWith("http://") || path2.startsWith("https://")) && method !== "CONNECT") { + throw new InvalidArgumentError("path must be an absolute URL or start with a slash"); + } else if (invalidPathRegex.exec(path2) !== null) { + throw new InvalidArgumentError("invalid request path"); + } + if (typeof method !== "string") { + throw new InvalidArgumentError("method must be a string"); + } else if (tokenRegExp.exec(method) === null) { + throw new InvalidArgumentError("invalid request method"); + } + if (upgrade && typeof upgrade !== "string") { + throw new InvalidArgumentError("upgrade must be a string"); + } + if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("invalid headersTimeout"); + } + if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("invalid bodyTimeout"); + } + if (reset != null && typeof reset !== "boolean") { + throw new InvalidArgumentError("invalid reset"); + } + if (expectContinue != null && typeof expectContinue !== "boolean") { + throw new InvalidArgumentError("invalid expectContinue"); + } + this.headersTimeout = headersTimeout; + this.bodyTimeout = bodyTimeout; + this.throwOnError = throwOnError === true; + this.method = method; + this.abort = null; + if (body == null) { + this.body = null; + } else if (util.isStream(body)) { + this.body = body; + const rState = this.body._readableState; + if (!rState || !rState.autoDestroy) { + this.endHandler = function autoDestroy() { + util.destroy(this); + }; + this.body.on("end", this.endHandler); + } + this.errorHandler = (err) => { + if (this.abort) { + this.abort(err); + } else { + this.error = err; } - const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`; - (0, log_1.loggerFor)(this).info(`${responseInfo} - ${retryMessage}`); - const errText = await response.text().catch((err) => (0, errors_1.castToError)(err).message); - const errJSON = (0, values_1.safeJSON)(errText); - const errMessage = errJSON ? undefined : errText; - (0, log_1.loggerFor)(this).debug(`[${requestLogID}] response error (${retryMessage})`, (0, log_1.formatRequestDetails)({ - retryOfRequestLogID, - url: response.url, - status: response.status, - headers: response.headers, - message: errMessage, - durationMs: Date.now() - startTime, - })); - const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers); - throw err; + }; + this.body.on("error", this.errorHandler); + } else if (util.isBuffer(body)) { + this.body = body.byteLength ? body : null; + } else if (ArrayBuffer.isView(body)) { + this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null; + } else if (body instanceof ArrayBuffer) { + this.body = body.byteLength ? Buffer.from(body) : null; + } else if (typeof body === "string") { + this.body = body.length ? Buffer.from(body) : null; + } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) { + this.body = body; + } else { + throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable"); + } + this.completed = false; + this.aborted = false; + this.upgrade = upgrade || null; + this.path = query ? util.buildURL(path2, query) : path2; + this.origin = origin; + this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; + this.blocking = blocking == null ? false : blocking; + this.reset = reset == null ? null : reset; + this.host = null; + this.contentLength = null; + this.contentType = null; + this.headers = ""; + this.expectContinue = expectContinue != null ? expectContinue : false; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(this, headers[i], headers[i + 1]); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(this, key, headers[key]); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); } - (0, log_1.loggerFor)(this).info(responseInfo); - (0, log_1.loggerFor)(this).debug(`[${requestLogID}] response start`, (0, log_1.formatRequestDetails)({ - retryOfRequestLogID, - url: response.url, - status: response.status, - headers: response.headers, - durationMs: headersTime - startTime, - })); - return { response, options, controller, requestLogID, retryOfRequestLogID, startTime }; - } - getAPIList(path, Page, opts) { - return this.requestAPIList(Page, { method: 'get', path, ...opts }); - } - requestAPIList(Page, options) { - const request = this.makeRequest(options, null, undefined); - return new Pagination.PagePromise(this, request, Page); - } - async fetchWithTimeout(url, init, ms, controller) { - const { signal, method, ...options } = init || {}; - if (signal) - signal.addEventListener('abort', () => controller.abort()); - const timeout = setTimeout(() => controller.abort(), ms); - const isReadableBody = (globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream) || - (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body); - const fetchOptions = { - signal: controller.signal, - ...(isReadableBody ? { duplex: 'half' } : {}), - method: 'GET', - ...options, - }; - if (method) { - // Custom methods like 'patch' need to be uppercased - // See https://github.com/nodejs/undici/issues/2294 - fetchOptions.method = method.toUpperCase(); + if (util.isFormDataLike(this.body)) { + if (util.nodeMajor < 16 || util.nodeMajor === 16 && util.nodeMinor < 8) { + throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer."); + } + if (!extractBody) { + extractBody = require_body().extractBody; + } + const [bodyStream, contentType] = extractBody(body); + if (this.contentType == null) { + this.contentType = contentType; + this.headers += `content-type: ${contentType}\r +`; + } + this.body = bodyStream.stream; + this.contentLength = bodyStream.length; + } else if (util.isBlobLike(body) && this.contentType == null && body.type) { + this.contentType = body.type; + this.headers += `content-type: ${body.type}\r +`; + } + util.validateHandler(handler, method, upgrade); + this.servername = util.getServerName(this.host); + this[kHandler] = handler; + if (channels.create.hasSubscribers) { + channels.create.publish({ request: this }); + } + } + onBodySent(chunk) { + if (this[kHandler].onBodySent) { + try { + return this[kHandler].onBodySent(chunk); + } catch (err) { + this.abort(err); + } + } + } + onRequestSent() { + if (channels.bodySent.hasSubscribers) { + channels.bodySent.publish({ request: this }); + } + if (this[kHandler].onRequestSent) { + try { + return this[kHandler].onRequestSent(); + } catch (err) { + this.abort(err); + } + } + } + onConnect(abort) { + assert(!this.aborted); + assert(!this.completed); + if (this.error) { + abort(this.error); + } else { + this.abort = abort; + return this[kHandler].onConnect(abort); + } + } + onHeaders(statusCode, headers, resume, statusText) { + assert(!this.aborted); + assert(!this.completed); + if (channels.headers.hasSubscribers) { + channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }); } try { - // use undefined this binding; fetch errors if bound to something else in browser/cloudflare - return await this.fetch.call(undefined, url, fetchOptions); + return this[kHandler].onHeaders(statusCode, headers, resume, statusText); + } catch (err) { + this.abort(err); } - finally { - clearTimeout(timeout); + } + onData(chunk) { + assert(!this.aborted); + assert(!this.completed); + try { + return this[kHandler].onData(chunk); + } catch (err) { + this.abort(err); + return false; } + } + onUpgrade(statusCode, headers, socket) { + assert(!this.aborted); + assert(!this.completed); + return this[kHandler].onUpgrade(statusCode, headers, socket); + } + onComplete(trailers) { + this.onFinally(); + assert(!this.aborted); + this.completed = true; + if (channels.trailers.hasSubscribers) { + channels.trailers.publish({ request: this, trailers }); + } + try { + return this[kHandler].onComplete(trailers); + } catch (err) { + this.onError(err); + } + } + onError(error2) { + this.onFinally(); + if (channels.error.hasSubscribers) { + channels.error.publish({ request: this, error: error2 }); + } + if (this.aborted) { + return; + } + this.aborted = true; + return this[kHandler].onError(error2); + } + onFinally() { + if (this.errorHandler) { + this.body.off("error", this.errorHandler); + this.errorHandler = null; + } + if (this.endHandler) { + this.body.off("end", this.endHandler); + this.endHandler = null; + } + } + // TODO: adjust to support H2 + addHeader(key, value) { + processHeader(this, key, value); + return this; + } + static [kHTTP1BuildRequest](origin, opts, handler) { + return new _Request(origin, opts, handler); + } + static [kHTTP2BuildRequest](origin, opts, handler) { + const headers = opts.headers; + opts = { ...opts, headers: null }; + const request = new _Request(origin, opts, handler); + request.headers = {}; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(request, headers[i], headers[i + 1], true); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(request, key, headers[key], true); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + return request; + } + static [kHTTP2CopyHeaders](raw) { + const rawHeaders = raw.split("\r\n"); + const headers = {}; + for (const header of rawHeaders) { + const [key, value] = header.split(": "); + if (value == null || value.length === 0) continue; + if (headers[key]) headers[key] += `,${value}`; + else headers[key] = value; + } + return headers; + } + }; + function processHeaderValue(key, val, skipAppend) { + if (val && typeof val === "object") { + throw new InvalidArgumentError(`invalid ${key} header`); + } + val = val != null ? `${val}` : ""; + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + return skipAppend ? val : `${key}: ${val}\r +`; } - shouldRetry(response) { - // Note this is not a standard header. - const shouldRetryHeader = response.headers.get('x-should-retry'); - // If the server explicitly says whether or not to retry, obey. - if (shouldRetryHeader === 'true') - return true; - if (shouldRetryHeader === 'false') - return false; - // Retry on request timeouts. - if (response.status === 408) - return true; - // Retry on lock timeouts. - if (response.status === 409) - return true; - // Retry on rate limits. - if (response.status === 429) - return true; - // Retry internal errors. - if (response.status >= 500) - return true; - return false; - } - async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) { - let timeoutMillis; - // Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it. - const retryAfterMillisHeader = responseHeaders?.get('retry-after-ms'); - if (retryAfterMillisHeader) { - const timeoutMs = parseFloat(retryAfterMillisHeader); - if (!Number.isNaN(timeoutMs)) { - timeoutMillis = timeoutMs; + function processHeader(request, key, val, skipAppend = false) { + if (val && (typeof val === "object" && !Array.isArray(val))) { + throw new InvalidArgumentError(`invalid ${key} header`); + } else if (val === void 0) { + return; + } + if (request.host === null && key.length === 4 && key.toLowerCase() === "host") { + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + request.host = val; + } else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") { + request.contentLength = parseInt(val, 10); + if (!Number.isFinite(request.contentLength)) { + throw new InvalidArgumentError("invalid content-length header"); + } + } else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") { + request.contentType = val; + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); + } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") { + throw new InvalidArgumentError("invalid transfer-encoding header"); + } else if (key.length === 10 && key.toLowerCase() === "connection") { + const value = typeof val === "string" ? val.toLowerCase() : null; + if (value !== "close" && value !== "keep-alive") { + throw new InvalidArgumentError("invalid connection header"); + } else if (value === "close") { + request.reset = true; + } + } else if (key.length === 10 && key.toLowerCase() === "keep-alive") { + throw new InvalidArgumentError("invalid keep-alive header"); + } else if (key.length === 7 && key.toLowerCase() === "upgrade") { + throw new InvalidArgumentError("invalid upgrade header"); + } else if (key.length === 6 && key.toLowerCase() === "expect") { + throw new NotSupportedError("expect header not supported"); + } else if (tokenRegExp.exec(key) === null) { + throw new InvalidArgumentError("invalid header key"); + } else { + if (Array.isArray(val)) { + for (let i = 0; i < val.length; i++) { + if (skipAppend) { + if (request.headers[key]) request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`; + else request.headers[key] = processHeaderValue(key, val[i], skipAppend); + } else { + request.headers += processHeaderValue(key, val[i]); } + } + } else { + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); } - // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After - const retryAfterHeader = responseHeaders?.get('retry-after'); - if (retryAfterHeader && !timeoutMillis) { - const timeoutSeconds = parseFloat(retryAfterHeader); - if (!Number.isNaN(timeoutSeconds)) { - timeoutMillis = timeoutSeconds * 1000; - } - else { - timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + } + module2.exports = Request; + } +}); + +// node_modules/undici/lib/dispatcher.js +var require_dispatcher = __commonJS({ + "node_modules/undici/lib/dispatcher.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events"); + var Dispatcher = class extends EventEmitter { + dispatch() { + throw new Error("not implemented"); + } + close() { + throw new Error("not implemented"); + } + destroy() { + throw new Error("not implemented"); + } + }; + module2.exports = Dispatcher; + } +}); + +// node_modules/undici/lib/dispatcher-base.js +var require_dispatcher_base = __commonJS({ + "node_modules/undici/lib/dispatcher-base.js"(exports2, module2) { + "use strict"; + var Dispatcher = require_dispatcher(); + var { + ClientDestroyedError, + ClientClosedError, + InvalidArgumentError + } = require_errors2(); + var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols(); + var kDestroyed = Symbol("destroyed"); + var kClosed = Symbol("closed"); + var kOnDestroyed = Symbol("onDestroyed"); + var kOnClosed = Symbol("onClosed"); + var kInterceptedDispatch = Symbol("Intercepted Dispatch"); + var DispatcherBase = class extends Dispatcher { + constructor() { + super(); + this[kDestroyed] = false; + this[kOnDestroyed] = null; + this[kClosed] = false; + this[kOnClosed] = []; + } + get destroyed() { + return this[kDestroyed]; + } + get closed() { + return this[kClosed]; + } + get interceptors() { + return this[kInterceptors]; + } + set interceptors(newInterceptors) { + if (newInterceptors) { + for (let i = newInterceptors.length - 1; i >= 0; i--) { + const interceptor = this[kInterceptors][i]; + if (typeof interceptor !== "function") { + throw new InvalidArgumentError("interceptor must be an function"); } + } + } + this[kInterceptors] = newInterceptors; + } + close(callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.close((err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + queueMicrotask(() => callback(new ClientDestroyedError(), null)); + return; } - // If the API asks us to wait a certain amount of time (and it's a reasonable amount), - // just do what it says, but otherwise calculate a default - if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) { - const maxRetries = options.maxRetries ?? this.maxRetries; - timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); - } - await (0, sleep_1.sleep)(timeoutMillis); - return this.makeRequest(options, retriesRemaining - 1, requestLogID); - } - calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) { - const initialRetryDelay = 0.5; - const maxRetryDelay = 8.0; - const numRetries = maxRetries - retriesRemaining; - // Apply exponential backoff, but not more than the max. - const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay); - // Apply some jitter, take up to at most 25 percent of the retry time. - const jitter = 1 - Math.random() * 0.25; - return sleepSeconds * jitter * 1000; - } - buildRequest(inputOptions, { retryCount = 0 } = {}) { - const options = { ...inputOptions }; - const { method, path, query, defaultBaseURL } = options; - const url = this.buildURL(path, query, defaultBaseURL); - if ('timeout' in options) - (0, values_1.validatePositiveInteger)('timeout', options.timeout); - options.timeout = options.timeout ?? this.timeout; - const { bodyHeaders, body } = this.buildBody({ options }); - const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount }); - const req = { - method, - headers: reqHeaders, - ...(options.signal && { signal: options.signal }), - ...(globalThis.ReadableStream && - body instanceof globalThis.ReadableStream && { duplex: 'half' }), - ...(body && { body }), - ...(this.fetchOptions ?? {}), - ...(options.fetchOptions ?? {}), + if (this[kClosed]) { + if (this[kOnClosed]) { + this[kOnClosed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + this[kClosed] = true; + this[kOnClosed].push(callback); + const onClosed = () => { + const callbacks = this[kOnClosed]; + this[kOnClosed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } }; - return { req, url, timeout: options.timeout }; - } - buildHeaders({ options, method, bodyHeaders, retryCount, }) { - let idempotencyHeaders = {}; - if (this.idempotencyHeader && method !== 'get') { - if (!options.idempotencyKey) - options.idempotencyKey = this.defaultIdempotencyKey(); - idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; - } - const headers = (0, headers_1.buildHeaders)([ - idempotencyHeaders, - { - Accept: 'application/json', - 'User-Agent': this.getUserAgent(), - 'X-Stainless-Retry-Count': String(retryCount), - ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}), - ...(0, detect_platform_1.getPlatformHeaders)(), - }, - this.authHeaders(options), - this._options.defaultHeaders, - bodyHeaders, - options.headers, - ]); - this.validateHeaders(headers); - return headers.values; - } - buildBody({ options: { body, headers: rawHeaders } }) { - if (!body) { - return { bodyHeaders: undefined, body: undefined }; - } - const headers = (0, headers_1.buildHeaders)([rawHeaders]); - if ( - // Pass raw type verbatim - ArrayBuffer.isView(body) || - body instanceof ArrayBuffer || - body instanceof DataView || - (typeof body === 'string' && - // Preserve legacy string encoding behavior for now - headers.values.has('content-type')) || - // `Blob` is superset of `File` - body instanceof Blob || - // `FormData` -> `multipart/form-data` - body instanceof FormData || - // `URLSearchParams` -> `application/x-www-form-urlencoded` - body instanceof URLSearchParams || - // Send chunked stream (each chunk has own `length`) - (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) { - return { bodyHeaders: undefined, body: body }; - } - else if (typeof body === 'object' && - (Symbol.asyncIterator in body || - (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) { - return { bodyHeaders: undefined, body: Shims.ReadableStreamFrom(body) }; + this[kClose]().then(() => this.destroy()).then(() => { + queueMicrotask(onClosed); + }); + } + destroy(err, callback) { + if (typeof err === "function") { + callback = err; + err = null; + } + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.destroy(err, (err2, data) => { + return err2 ? ( + /* istanbul ignore next: should never error */ + reject(err2) + ) : resolve(data); + }); + }); } - else { - return tslib_1.__classPrivateFieldGet(this, _Stainless_encoder, "f").call(this, { body, headers }); + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); } - } -} -exports.Stainless = Stainless; -_a = Stainless, _Stainless_encoder = new WeakMap(), _Stainless_instances = new WeakSet(), _Stainless_baseURLOverridden = function _Stainless_baseURLOverridden() { - return this.baseURL !== 'https://api.stainless.com'; -}; -Stainless.Stainless = _a; -Stainless.DEFAULT_TIMEOUT = 60000; // 1 minute -Stainless.StainlessError = Errors.StainlessError; -Stainless.APIError = Errors.APIError; -Stainless.APIConnectionError = Errors.APIConnectionError; -Stainless.APIConnectionTimeoutError = Errors.APIConnectionTimeoutError; -Stainless.APIUserAbortError = Errors.APIUserAbortError; -Stainless.NotFoundError = Errors.NotFoundError; -Stainless.ConflictError = Errors.ConflictError; -Stainless.RateLimitError = Errors.RateLimitError; -Stainless.BadRequestError = Errors.BadRequestError; -Stainless.AuthenticationError = Errors.AuthenticationError; -Stainless.InternalServerError = Errors.InternalServerError; -Stainless.PermissionDeniedError = Errors.PermissionDeniedError; -Stainless.UnprocessableEntityError = Errors.UnprocessableEntityError; -Stainless.toFile = Uploads.toFile; -Stainless.unwrapFile = unwrap_1.unwrapFile; -Stainless.Projects = projects_1.Projects; -Stainless.Builds = builds_1.Builds; -Stainless.Orgs = orgs_1.Orgs; -Stainless.Generate = generate_1.Generate; -//# sourceMappingURL=client.js.map - -/***/ }), - -/***/ 147: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -var _APIPromise_client; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.APIPromise = void 0; -const tslib_1 = __nccwpck_require__(533); -const parse_1 = __nccwpck_require__(5702); -/** - * A subclass of `Promise` providing additional helper methods - * for interacting with the SDK. - */ -class APIPromise extends Promise { - constructor(client, responsePromise, parseResponse = parse_1.defaultParseResponse) { - super((resolve) => { - // this is maybe a bit weird but this has to be a no-op to not implicitly - // parse the response body; instead .then, .catch, .finally are overridden - // to parse the response - resolve(null); + if (this[kDestroyed]) { + if (this[kOnDestroyed]) { + this[kOnDestroyed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + if (!err) { + err = new ClientDestroyedError(); + } + this[kDestroyed] = true; + this[kOnDestroyed] = this[kOnDestroyed] || []; + this[kOnDestroyed].push(callback); + const onDestroyed = () => { + const callbacks = this[kOnDestroyed]; + this[kOnDestroyed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kDestroy](err).then(() => { + queueMicrotask(onDestroyed); }); - this.responsePromise = responsePromise; - this.parseResponse = parseResponse; - _APIPromise_client.set(this, void 0); - tslib_1.__classPrivateFieldSet(this, _APIPromise_client, client, "f"); - } - _thenUnwrap(transform) { - return new APIPromise(tslib_1.__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props)); - } - /** - * Gets the raw `Response` instance instead of parsing the response - * data. - * - * If you want to parse the response body but still get the `Response` - * instance, you can use {@link withResponse()}. - * - * 👋 Getting the wrong TypeScript type for `Response`? - * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` - * to your `tsconfig.json`. - */ - asResponse() { - return this.responsePromise.then((p) => p.response); - } - /** - * Gets the parsed response data and the raw `Response` instance. - * - * If you just want to get the raw `Response` instance without parsing it, - * you can use {@link asResponse()}. - * - * 👋 Getting the wrong TypeScript type for `Response`? - * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` - * to your `tsconfig.json`. - */ - async withResponse() { - const [data, response] = await Promise.all([this.parse(), this.asResponse()]); - return { data, response }; - } - parse() { - if (!this.parsedPromise) { - this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(tslib_1.__classPrivateFieldGet(this, _APIPromise_client, "f"), data)); - } - return this.parsedPromise; - } - then(onfulfilled, onrejected) { - return this.parse().then(onfulfilled, onrejected); - } - catch(onrejected) { - return this.parse().catch(onrejected); - } - finally(onfinally) { - return this.parse().finally(onfinally); - } -} -exports.APIPromise = APIPromise; -_APIPromise_client = new WeakMap(); -//# sourceMappingURL=api-promise.js.map - -/***/ }), - -/***/ 3801: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; + } + [kInterceptedDispatch](opts, handler) { + if (!this[kInterceptors] || this[kInterceptors].length === 0) { + this[kInterceptedDispatch] = this[kDispatch]; + return this[kDispatch](opts, handler); + } + let dispatch = this[kDispatch].bind(this); + for (let i = this[kInterceptors].length - 1; i >= 0; i--) { + dispatch = this[kInterceptors][i](dispatch); + } + this[kInterceptedDispatch] = dispatch; + return dispatch(opts, handler); + } + dispatch(opts, handler) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + try { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object."); + } + if (this[kDestroyed] || this[kOnDestroyed]) { + throw new ClientDestroyedError(); + } + if (this[kClosed]) { + throw new ClientClosedError(); + } + return this[kInterceptedDispatch](opts, handler); + } catch (err) { + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + handler.onError(err); + return false; + } + } + }; + module2.exports = DispatcherBase; + } +}); -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.InternalServerError = exports.RateLimitError = exports.UnprocessableEntityError = exports.ConflictError = exports.NotFoundError = exports.PermissionDeniedError = exports.AuthenticationError = exports.BadRequestError = exports.APIConnectionTimeoutError = exports.APIConnectionError = exports.APIUserAbortError = exports.APIError = exports.StainlessError = void 0; -const errors_1 = __nccwpck_require__(4838); -class StainlessError extends Error { -} -exports.StainlessError = StainlessError; -class APIError extends StainlessError { - constructor(status, error, message, headers) { - super(`${APIError.makeMessage(status, error, message)}`); - this.status = status; - this.headers = headers; - this.error = error; - } - static makeMessage(status, error, message) { - const msg = error?.message ? - typeof error.message === 'string' ? - error.message - : JSON.stringify(error.message) - : error ? JSON.stringify(error) - : message; - if (status && msg) { - return `${status} ${msg}`; +// node_modules/undici/lib/core/connect.js +var require_connect = __commonJS({ + "node_modules/undici/lib/core/connect.js"(exports2, module2) { + "use strict"; + var net = require("net"); + var assert = require("assert"); + var util = require_util(); + var { InvalidArgumentError, ConnectTimeoutError } = require_errors2(); + var tls; + var SessionCache; + if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) { + SessionCache = class WeakSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + this._sessionRegistry = new global.FinalizationRegistry((key) => { + if (this._sessionCache.size < this._maxCachedSessions) { + return; + } + const ref = this._sessionCache.get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this._sessionCache.delete(key); + } + }); } - if (status) { - return `${status} status code (no body)`; + get(sessionKey) { + const ref = this._sessionCache.get(sessionKey); + return ref ? ref.deref() : null; } - if (msg) { - return msg; + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + this._sessionCache.set(sessionKey, new WeakRef(session)); + this._sessionRegistry.register(session, sessionKey); } - return '(no status code or body)'; - } - static generate(status, errorResponse, message, headers) { - if (!status || !headers) { - return new APIConnectionError({ message, cause: (0, errors_1.castToError)(errorResponse) }); + }; + } else { + SessionCache = class SimpleSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + } + get(sessionKey) { + return this._sessionCache.get(sessionKey); } - const error = errorResponse; - if (status === 400) { - return new BadRequestError(status, error, message, headers); + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + if (this._sessionCache.size >= this._maxCachedSessions) { + const { value: oldestKey } = this._sessionCache.keys().next(); + this._sessionCache.delete(oldestKey); + } + this._sessionCache.set(sessionKey, session); } - if (status === 401) { - return new AuthenticationError(status, error, message, headers); + }; + } + function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) { + if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { + throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero"); + } + const options = { path: socketPath, ...opts }; + const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions); + timeout = timeout == null ? 1e4 : timeout; + allowH2 = allowH2 != null ? allowH2 : false; + return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { + let socket; + if (protocol === "https:") { + if (!tls) { + tls = require("tls"); + } + servername = servername || options.servername || util.getServerName(host) || null; + const sessionKey = servername || hostname; + const session = sessionCache.get(sessionKey) || null; + assert(sessionKey); + socket = tls.connect({ + highWaterMark: 16384, + // TLS in node can't have bigger HWM anyway... + ...options, + servername, + session, + localAddress, + // TODO(HTTP/2): Add support for h2c + ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"], + socket: httpSocket, + // upgrade socket connection + port: port || 443, + host: hostname + }); + socket.on("session", function(session2) { + sessionCache.set(sessionKey, session2); + }); + } else { + assert(!httpSocket, "httpSocket can only be sent on TLS update"); + socket = net.connect({ + highWaterMark: 64 * 1024, + // Same as nodejs fs streams. + ...options, + localAddress, + port: port || 80, + host: hostname + }); + } + if (options.keepAlive == null || options.keepAlive) { + const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay; + socket.setKeepAlive(true, keepAliveInitialDelay); + } + const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout); + socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(null, this); + } + }).on("error", function(err) { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(err); + } + }); + return socket; + }; + } + function setupTimeout(onConnectTimeout2, timeout) { + if (!timeout) { + return () => { + }; + } + let s1 = null; + let s2 = null; + const timeoutId = setTimeout(() => { + s1 = setImmediate(() => { + if (process.platform === "win32") { + s2 = setImmediate(() => onConnectTimeout2()); + } else { + onConnectTimeout2(); + } + }); + }, timeout); + return () => { + clearTimeout(timeoutId); + clearImmediate(s1); + clearImmediate(s2); + }; + } + function onConnectTimeout(socket) { + util.destroy(socket, new ConnectTimeoutError()); + } + module2.exports = buildConnector; + } +}); + +// node_modules/undici/lib/llhttp/utils.js +var require_utils2 = __commonJS({ + "node_modules/undici/lib/llhttp/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.enumToMap = void 0; + function enumToMap(obj) { + const res = {}; + Object.keys(obj).forEach((key) => { + const value = obj[key]; + if (typeof value === "number") { + res[key] = value; } - if (status === 403) { - return new PermissionDeniedError(status, error, message, headers); + }); + return res; + } + exports2.enumToMap = enumToMap; + } +}); + +// node_modules/undici/lib/llhttp/constants.js +var require_constants3 = __commonJS({ + "node_modules/undici/lib/llhttp/constants.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0; + var utils_1 = require_utils2(); + var ERROR; + (function(ERROR2) { + ERROR2[ERROR2["OK"] = 0] = "OK"; + ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL"; + ERROR2[ERROR2["STRICT"] = 2] = "STRICT"; + ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED"; + ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; + ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; + ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD"; + ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL"; + ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; + ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION"; + ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; + ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; + ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; + ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS"; + ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; + ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; + ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; + ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; + ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; + ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; + ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; + ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED"; + ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; + ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; + ERROR2[ERROR2["USER"] = 24] = "USER"; + })(ERROR = exports2.ERROR || (exports2.ERROR = {})); + var TYPE; + (function(TYPE2) { + TYPE2[TYPE2["BOTH"] = 0] = "BOTH"; + TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST"; + TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE"; + })(TYPE = exports2.TYPE || (exports2.TYPE = {})); + var FLAGS; + (function(FLAGS2) { + FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; + FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; + FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; + FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED"; + FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE"; + FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; + FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY"; + FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING"; + FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; + })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {})); + var LENIENT_FLAGS; + (function(LENIENT_FLAGS2) { + LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS"; + LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; + LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; + })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {})); + var METHODS; + (function(METHODS2) { + METHODS2[METHODS2["DELETE"] = 0] = "DELETE"; + METHODS2[METHODS2["GET"] = 1] = "GET"; + METHODS2[METHODS2["HEAD"] = 2] = "HEAD"; + METHODS2[METHODS2["POST"] = 3] = "POST"; + METHODS2[METHODS2["PUT"] = 4] = "PUT"; + METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT"; + METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS"; + METHODS2[METHODS2["TRACE"] = 7] = "TRACE"; + METHODS2[METHODS2["COPY"] = 8] = "COPY"; + METHODS2[METHODS2["LOCK"] = 9] = "LOCK"; + METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL"; + METHODS2[METHODS2["MOVE"] = 11] = "MOVE"; + METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND"; + METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH"; + METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH"; + METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK"; + METHODS2[METHODS2["BIND"] = 16] = "BIND"; + METHODS2[METHODS2["REBIND"] = 17] = "REBIND"; + METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND"; + METHODS2[METHODS2["ACL"] = 19] = "ACL"; + METHODS2[METHODS2["REPORT"] = 20] = "REPORT"; + METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY"; + METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT"; + METHODS2[METHODS2["MERGE"] = 23] = "MERGE"; + METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH"; + METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY"; + METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE"; + METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; + METHODS2[METHODS2["PATCH"] = 28] = "PATCH"; + METHODS2[METHODS2["PURGE"] = 29] = "PURGE"; + METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR"; + METHODS2[METHODS2["LINK"] = 31] = "LINK"; + METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK"; + METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE"; + METHODS2[METHODS2["PRI"] = 34] = "PRI"; + METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE"; + METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE"; + METHODS2[METHODS2["SETUP"] = 37] = "SETUP"; + METHODS2[METHODS2["PLAY"] = 38] = "PLAY"; + METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE"; + METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN"; + METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER"; + METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER"; + METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT"; + METHODS2[METHODS2["RECORD"] = 44] = "RECORD"; + METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH"; + })(METHODS = exports2.METHODS || (exports2.METHODS = {})); + exports2.METHODS_HTTP = [ + METHODS.DELETE, + METHODS.GET, + METHODS.HEAD, + METHODS.POST, + METHODS.PUT, + METHODS.CONNECT, + METHODS.OPTIONS, + METHODS.TRACE, + METHODS.COPY, + METHODS.LOCK, + METHODS.MKCOL, + METHODS.MOVE, + METHODS.PROPFIND, + METHODS.PROPPATCH, + METHODS.SEARCH, + METHODS.UNLOCK, + METHODS.BIND, + METHODS.REBIND, + METHODS.UNBIND, + METHODS.ACL, + METHODS.REPORT, + METHODS.MKACTIVITY, + METHODS.CHECKOUT, + METHODS.MERGE, + METHODS["M-SEARCH"], + METHODS.NOTIFY, + METHODS.SUBSCRIBE, + METHODS.UNSUBSCRIBE, + METHODS.PATCH, + METHODS.PURGE, + METHODS.MKCALENDAR, + METHODS.LINK, + METHODS.UNLINK, + METHODS.PRI, + // TODO(indutny): should we allow it with HTTP? + METHODS.SOURCE + ]; + exports2.METHODS_ICE = [ + METHODS.SOURCE + ]; + exports2.METHODS_RTSP = [ + METHODS.OPTIONS, + METHODS.DESCRIBE, + METHODS.ANNOUNCE, + METHODS.SETUP, + METHODS.PLAY, + METHODS.PAUSE, + METHODS.TEARDOWN, + METHODS.GET_PARAMETER, + METHODS.SET_PARAMETER, + METHODS.REDIRECT, + METHODS.RECORD, + METHODS.FLUSH, + // For AirPlay + METHODS.GET, + METHODS.POST + ]; + exports2.METHOD_MAP = utils_1.enumToMap(METHODS); + exports2.H_METHOD_MAP = {}; + Object.keys(exports2.METHOD_MAP).forEach((key) => { + if (/^H/.test(key)) { + exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key]; + } + }); + var FINISH; + (function(FINISH2) { + FINISH2[FINISH2["SAFE"] = 0] = "SAFE"; + FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; + FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE"; + })(FINISH = exports2.FINISH || (exports2.FINISH = {})); + exports2.ALPHA = []; + for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) { + exports2.ALPHA.push(String.fromCharCode(i)); + exports2.ALPHA.push(String.fromCharCode(i + 32)); + } + exports2.NUM_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9 + }; + exports2.HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15 + }; + exports2.NUM = [ + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9" + ]; + exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM); + exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"]; + exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]); + exports2.STRICT_URL_CHAR = [ + "!", + '"', + "$", + "%", + "&", + "'", + "(", + ")", + "*", + "+", + ",", + "-", + ".", + "/", + ":", + ";", + "<", + "=", + ">", + "@", + "[", + "\\", + "]", + "^", + "_", + "`", + "{", + "|", + "}", + "~" + ].concat(exports2.ALPHANUM); + exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]); + for (let i = 128; i <= 255; i++) { + exports2.URL_CHAR.push(i); + } + exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]); + exports2.STRICT_TOKEN = [ + "!", + "#", + "$", + "%", + "&", + "'", + "*", + "+", + "-", + ".", + "^", + "_", + "`", + "|", + "~" + ].concat(exports2.ALPHANUM); + exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]); + exports2.HEADER_CHARS = [" "]; + for (let i = 32; i <= 255; i++) { + if (i !== 127) { + exports2.HEADER_CHARS.push(i); + } + } + exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44); + exports2.MAJOR = exports2.NUM_MAP; + exports2.MINOR = exports2.MAJOR; + var HEADER_STATE; + (function(HEADER_STATE2) { + HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL"; + HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION"; + HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; + HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; + })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {})); + exports2.SPECIAL_HEADERS = { + "connection": HEADER_STATE.CONNECTION, + "content-length": HEADER_STATE.CONTENT_LENGTH, + "proxy-connection": HEADER_STATE.CONNECTION, + "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING, + "upgrade": HEADER_STATE.UPGRADE + }; + } +}); + +// node_modules/undici/lib/handler/RedirectHandler.js +var require_RedirectHandler = __commonJS({ + "node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) { + "use strict"; + var util = require_util(); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { InvalidArgumentError } = require_errors2(); + var EE = require("events"); + var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; + var kBody = Symbol("body"); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + var RedirectHandler = class { + constructor(dispatch, maxRedirections, opts, handler) { + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + util.validateHandler(handler, opts.method, opts.upgrade); + this.dispatch = dispatch; + this.location = null; + this.abort = null; + this.opts = { ...opts, maxRedirections: 0 }; + this.maxRedirections = maxRedirections; + this.handler = handler; + this.history = []; + if (util.isStream(this.opts.body)) { + if (util.bodyLength(this.opts.body) === 0) { + this.opts.body.on("data", function() { + assert(false); + }); + } + if (typeof this.opts.body.readableDidRead !== "boolean") { + this.opts.body[kBodyUsed] = false; + EE.prototype.on.call(this.opts.body, "data", function() { + this[kBodyUsed] = true; + }); + } + } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) { + this.opts.body = new BodyAsyncIterable(this.opts.body); } - if (status === 404) { - return new NotFoundError(status, error, message, headers); + } + onConnect(abort) { + this.abort = abort; + this.handler.onConnect(abort, { history: this.history }); + } + onUpgrade(statusCode, headers, socket) { + this.handler.onUpgrade(statusCode, headers, socket); + } + onError(error2) { + this.handler.onError(error2); + } + onHeaders(statusCode, headers, resume, statusText) { + this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers); + if (this.opts.origin) { + this.history.push(new URL(this.opts.path, this.opts.origin)); } - if (status === 409) { - return new ConflictError(status, error, message, headers); + if (!this.location) { + return this.handler.onHeaders(statusCode, headers, resume, statusText); } - if (status === 422) { - return new UnprocessableEntityError(status, error, message, headers); + const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); + const path2 = search ? `${pathname}${search}` : pathname; + this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); + this.opts.path = path2; + this.opts.origin = origin; + this.opts.maxRedirections = 0; + this.opts.query = null; + if (statusCode === 303 && this.opts.method !== "HEAD") { + this.opts.method = "GET"; + this.opts.body = null; } - if (status === 429) { - return new RateLimitError(status, error, message, headers); + } + onData(chunk) { + if (this.location) { + } else { + return this.handler.onData(chunk); } - if (status >= 500) { - return new InternalServerError(status, error, message, headers); + } + onComplete(trailers) { + if (this.location) { + this.location = null; + this.abort = null; + this.dispatch(this.opts, this); + } else { + this.handler.onComplete(trailers); } - return new APIError(status, error, message, headers); - } -} -exports.APIError = APIError; -class APIUserAbortError extends APIError { - constructor({ message } = {}) { - super(undefined, undefined, message || 'Request was aborted.', undefined); - } -} -exports.APIUserAbortError = APIUserAbortError; -class APIConnectionError extends APIError { - constructor({ message, cause }) { - super(undefined, undefined, message || 'Connection error.', undefined); - // in some environments the 'cause' property is already declared - // @ts-ignore - if (cause) - this.cause = cause; - } -} -exports.APIConnectionError = APIConnectionError; -class APIConnectionTimeoutError extends APIConnectionError { - constructor({ message } = {}) { - super({ message: message ?? 'Request timed out.' }); - } -} -exports.APIConnectionTimeoutError = APIConnectionTimeoutError; -class BadRequestError extends APIError { -} -exports.BadRequestError = BadRequestError; -class AuthenticationError extends APIError { -} -exports.AuthenticationError = AuthenticationError; -class PermissionDeniedError extends APIError { -} -exports.PermissionDeniedError = PermissionDeniedError; -class NotFoundError extends APIError { -} -exports.NotFoundError = NotFoundError; -class ConflictError extends APIError { -} -exports.ConflictError = ConflictError; -class UnprocessableEntityError extends APIError { -} -exports.UnprocessableEntityError = UnprocessableEntityError; -class RateLimitError extends APIError { -} -exports.RateLimitError = RateLimitError; -class InternalServerError extends APIError { -} -exports.InternalServerError = InternalServerError; -//# sourceMappingURL=error.js.map - -/***/ }), - -/***/ 8575: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -var _AbstractPage_client; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Page = exports.PagePromise = exports.AbstractPage = void 0; -const tslib_1 = __nccwpck_require__(533); -const error_1 = __nccwpck_require__(3801); -const parse_1 = __nccwpck_require__(5702); -const api_promise_1 = __nccwpck_require__(147); -const values_1 = __nccwpck_require__(5537); -class AbstractPage { - constructor(client, response, body, options) { - _AbstractPage_client.set(this, void 0); - tslib_1.__classPrivateFieldSet(this, _AbstractPage_client, client, "f"); - this.options = options; - this.response = response; - this.body = body; - } - hasNextPage() { - const items = this.getPaginatedItems(); - if (!items.length) - return false; - return this.nextPageRequestOptions() != null; - } - async getNextPage() { - const nextOptions = this.nextPageRequestOptions(); - if (!nextOptions) { - throw new error_1.StainlessError('No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.'); + } + onBodySent(chunk) { + if (this.handler.onBodySent) { + this.handler.onBodySent(chunk); } - return await tslib_1.__classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions); - } - async *iterPages() { - let page = this; - yield page; - while (page.hasNextPage()) { - page = await page.getNextPage(); - yield page; + } + }; + function parseLocation(statusCode, headers) { + if (redirectableStatusCodes.indexOf(statusCode) === -1) { + return null; + } + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toString().toLowerCase() === "location") { + return headers[i + 1]; } + } } - async *[(_AbstractPage_client = new WeakMap(), Symbol.asyncIterator)]() { - for await (const page of this.iterPages()) { - for (const item of page.getPaginatedItems()) { - yield item; - } - } + function shouldRemoveHeader(header, removeContent, unknownOrigin) { + if (header.length === 4) { + return util.headerNameToString(header) === "host"; + } + if (removeContent && util.headerNameToString(header).startsWith("content-")) { + return true; + } + if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { + const name = util.headerNameToString(header); + return name === "authorization" || name === "cookie" || name === "proxy-authorization"; + } + return false; } -} -exports.AbstractPage = AbstractPage; -/** - * This subclass of Promise will resolve to an instantiated Page once the request completes. - * - * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg: - * - * for await (const item of client.items.list()) { - * console.log(item) - * } - */ -class PagePromise extends api_promise_1.APIPromise { - constructor(client, request, Page) { - super(client, request, async (client, props) => new Page(client, props.response, await (0, parse_1.defaultParseResponse)(client, props), props.options)); - } - /** - * Allow auto-paginating iteration on an unawaited list call, eg: - * - * for await (const item of client.items.list()) { - * console.log(item) - * } - */ - async *[Symbol.asyncIterator]() { - const page = await this; - for await (const item of page) { - yield item; + function cleanRequestHeaders(headers, removeContent, unknownOrigin) { + const ret = []; + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) { + ret.push(headers[i], headers[i + 1]); + } } - } -} -exports.PagePromise = PagePromise; -class Page extends AbstractPage { - constructor(client, response, body, options) { - super(client, response, body, options); - this.data = body.data || []; - this.next_cursor = body.next_cursor || ''; - } - getPaginatedItems() { - return this.data ?? []; - } - nextPageRequestOptions() { - const cursor = this.next_cursor; - if (!cursor) { - return null; + } else if (headers && typeof headers === "object") { + for (const key of Object.keys(headers)) { + if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) { + ret.push(key, headers[key]); + } } - return { - ...this.options, - query: { - ...(0, values_1.maybeObj)(this.options.query), - cursor, - }, - }; + } else { + assert(headers == null, "headers must be an object or an array"); + } + return ret; } -} -exports.Page = Page; -//# sourceMappingURL=pagination.js.map - -/***/ }), - -/***/ 283: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; + module2.exports = RedirectHandler; + } +}); -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.APIResource = void 0; -class APIResource { - constructor(client) { - this._client = client; +// node_modules/undici/lib/interceptor/redirectInterceptor.js +var require_redirectInterceptor = __commonJS({ + "node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) { + "use strict"; + var RedirectHandler = require_RedirectHandler(); + function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { maxRedirections = defaultMaxRedirections } = opts; + if (!maxRedirections) { + return dispatch(opts, handler); + } + const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler); + opts = { ...opts, maxRedirections: 0 }; + return dispatch(opts, redirectHandler); + }; + }; } -} -exports.APIResource = APIResource; -//# sourceMappingURL=resource.js.map - -/***/ }), - -/***/ 1305: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.toFile = void 0; -var to_file_1 = __nccwpck_require__(8719); -Object.defineProperty(exports, "toFile", ({ enumerable: true, get: function () { return to_file_1.toFile; } })); -//# sourceMappingURL=uploads.js.map - -/***/ }), - -/***/ 6563: -/***/ ((module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -exports = module.exports = function (...args) { - return new exports.default(...args) -} -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.UnprocessableEntityError = exports.PermissionDeniedError = exports.InternalServerError = exports.AuthenticationError = exports.BadRequestError = exports.RateLimitError = exports.ConflictError = exports.NotFoundError = exports.APIUserAbortError = exports.APIConnectionTimeoutError = exports.APIConnectionError = exports.APIError = exports.StainlessError = exports.PagePromise = exports.Stainless = exports.APIPromise = exports.toFile = exports["default"] = void 0; -var client_1 = __nccwpck_require__(9596); -Object.defineProperty(exports, "default", ({ enumerable: true, get: function () { return client_1.Stainless; } })); -var uploads_1 = __nccwpck_require__(1305); -Object.defineProperty(exports, "toFile", ({ enumerable: true, get: function () { return uploads_1.toFile; } })); -var api_promise_1 = __nccwpck_require__(147); -Object.defineProperty(exports, "APIPromise", ({ enumerable: true, get: function () { return api_promise_1.APIPromise; } })); -var client_2 = __nccwpck_require__(9596); -Object.defineProperty(exports, "Stainless", ({ enumerable: true, get: function () { return client_2.Stainless; } })); -var pagination_1 = __nccwpck_require__(8575); -Object.defineProperty(exports, "PagePromise", ({ enumerable: true, get: function () { return pagination_1.PagePromise; } })); -var error_1 = __nccwpck_require__(3801); -Object.defineProperty(exports, "StainlessError", ({ enumerable: true, get: function () { return error_1.StainlessError; } })); -Object.defineProperty(exports, "APIError", ({ enumerable: true, get: function () { return error_1.APIError; } })); -Object.defineProperty(exports, "APIConnectionError", ({ enumerable: true, get: function () { return error_1.APIConnectionError; } })); -Object.defineProperty(exports, "APIConnectionTimeoutError", ({ enumerable: true, get: function () { return error_1.APIConnectionTimeoutError; } })); -Object.defineProperty(exports, "APIUserAbortError", ({ enumerable: true, get: function () { return error_1.APIUserAbortError; } })); -Object.defineProperty(exports, "NotFoundError", ({ enumerable: true, get: function () { return error_1.NotFoundError; } })); -Object.defineProperty(exports, "ConflictError", ({ enumerable: true, get: function () { return error_1.ConflictError; } })); -Object.defineProperty(exports, "RateLimitError", ({ enumerable: true, get: function () { return error_1.RateLimitError; } })); -Object.defineProperty(exports, "BadRequestError", ({ enumerable: true, get: function () { return error_1.BadRequestError; } })); -Object.defineProperty(exports, "AuthenticationError", ({ enumerable: true, get: function () { return error_1.AuthenticationError; } })); -Object.defineProperty(exports, "InternalServerError", ({ enumerable: true, get: function () { return error_1.InternalServerError; } })); -Object.defineProperty(exports, "PermissionDeniedError", ({ enumerable: true, get: function () { return error_1.PermissionDeniedError; } })); -Object.defineProperty(exports, "UnprocessableEntityError", ({ enumerable: true, get: function () { return error_1.UnprocessableEntityError; } })); -//# sourceMappingURL=index.js.map - -/***/ }), + module2.exports = createRedirectInterceptor; + } +}); -/***/ 4728: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +// node_modules/undici/lib/llhttp/llhttp-wasm.js +var require_llhttp_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { + module2.exports = "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"; + } +}); -"use strict"; +// node_modules/undici/lib/llhttp/llhttp_simd-wasm.js +var require_llhttp_simd_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { + module2.exports = "AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGADf39/AGABfwBgAn9/AGAGf39/f39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQACA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAA0ZFAwMEAAAFAAAAAAAABQEFAAUFBQAABgAAAAAGBgYGAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAAABAQcAAAUFAwABBAUBcAESEgUDAQACBggBfwFBgNQECwfRBSIGbWVtb3J5AgALX2luaXRpYWxpemUACRlfX2luZGlyZWN0X2Z1bmN0aW9uX3RhYmxlAQALbGxodHRwX2luaXQAChhsbGh0dHBfc2hvdWxkX2tlZXBfYWxpdmUAQQxsbGh0dHBfYWxsb2MADAZtYWxsb2MARgtsbGh0dHBfZnJlZQANBGZyZWUASA9sbGh0dHBfZ2V0X3R5cGUADhVsbGh0dHBfZ2V0X2h0dHBfbWFqb3IADxVsbGh0dHBfZ2V0X2h0dHBfbWlub3IAEBFsbGh0dHBfZ2V0X21ldGhvZAARFmxsaHR0cF9nZXRfc3RhdHVzX2NvZGUAEhJsbGh0dHBfZ2V0X3VwZ3JhZGUAEwxsbGh0dHBfcmVzZXQAFA5sbGh0dHBfZXhlY3V0ZQAVFGxsaHR0cF9zZXR0aW5nc19pbml0ABYNbGxodHRwX2ZpbmlzaAAXDGxsaHR0cF9wYXVzZQAYDWxsaHR0cF9yZXN1bWUAGRtsbGh0dHBfcmVzdW1lX2FmdGVyX3VwZ3JhZGUAGhBsbGh0dHBfZ2V0X2Vycm5vABsXbGxodHRwX2dldF9lcnJvcl9yZWFzb24AHBdsbGh0dHBfc2V0X2Vycm9yX3JlYXNvbgAdFGxsaHR0cF9nZXRfZXJyb3JfcG9zAB4RbGxodHRwX2Vycm5vX25hbWUAHxJsbGh0dHBfbWV0aG9kX25hbWUAIBJsbGh0dHBfc3RhdHVzX25hbWUAIRpsbGh0dHBfc2V0X2xlbmllbnRfaGVhZGVycwAiIWxsaHR0cF9zZXRfbGVuaWVudF9jaHVua2VkX2xlbmd0aAAjHWxsaHR0cF9zZXRfbGVuaWVudF9rZWVwX2FsaXZlACQkbGxodHRwX3NldF9sZW5pZW50X3RyYW5zZmVyX2VuY29kaW5nACUYbGxodHRwX21lc3NhZ2VfbmVlZHNfZW9mAD8JFwEAQQELEQECAwQFCwYHNTk3MS8tJyspCrLgAkUCAAsIABCIgICAAAsZACAAEMKAgIAAGiAAIAI2AjggACABOgAoCxwAIAAgAC8BMiAALQAuIAAQwYCAgAAQgICAgAALKgEBf0HAABDGgICAACIBEMKAgIAAGiABQYCIgIAANgI4IAEgADoAKCABCwoAIAAQyICAgAALBwAgAC0AKAsHACAALQAqCwcAIAAtACsLBwAgAC0AKQsHACAALwEyCwcAIAAtAC4LRQEEfyAAKAIYIQEgAC0ALSECIAAtACghAyAAKAI4IQQgABDCgICAABogACAENgI4IAAgAzoAKCAAIAI6AC0gACABNgIYCxEAIAAgASABIAJqEMOAgIAACxAAIABBAEHcABDMgICAABoLZwEBf0EAIQECQCAAKAIMDQACQAJAAkACQCAALQAvDgMBAAMCCyAAKAI4IgFFDQAgASgCLCIBRQ0AIAAgARGAgICAAAAiAQ0DC0EADwsQyoCAgAAACyAAQcOWgIAANgIQQQ4hAQsgAQseAAJAIAAoAgwNACAAQdGbgIAANgIQIABBFTYCDAsLFgACQCAAKAIMQRVHDQAgAEEANgIMCwsWAAJAIAAoAgxBFkcNACAAQQA2AgwLCwcAIAAoAgwLBwAgACgCEAsJACAAIAE2AhALBwAgACgCFAsiAAJAIABBJEkNABDKgICAAAALIABBAnRBoLOAgABqKAIACyIAAkAgAEEuSQ0AEMqAgIAAAAsgAEECdEGwtICAAGooAgAL7gsBAX9B66iAgAAhAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABBnH9qDvQDY2IAAWFhYWFhYQIDBAVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhBgcICQoLDA0OD2FhYWFhEGFhYWFhYWFhYWFhEWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRITFBUWFxgZGhthYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2YTc4OTphYWFhYWFhYTthYWE8YWFhYT0+P2FhYWFhYWFhQGFhQWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYUJDREVGR0hJSktMTU5PUFFSU2FhYWFhYWFhVFVWV1hZWlthXF1hYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFeYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhX2BhC0Hhp4CAAA8LQaShgIAADwtBy6yAgAAPC0H+sYCAAA8LQcCkgIAADwtBq6SAgAAPC0GNqICAAA8LQeKmgIAADwtBgLCAgAAPC0G5r4CAAA8LQdekgIAADwtB75+AgAAPC0Hhn4CAAA8LQfqfgIAADwtB8qCAgAAPC0Gor4CAAA8LQa6ygIAADwtBiLCAgAAPC0Hsp4CAAA8LQYKigIAADwtBjp2AgAAPC0HQroCAAA8LQcqjgIAADwtBxbKAgAAPC0HfnICAAA8LQdKcgIAADwtBxKCAgAAPC0HXoICAAA8LQaKfgIAADwtB7a6AgAAPC0GrsICAAA8LQdSlgIAADwtBzK6AgAAPC0H6roCAAA8LQfyrgIAADwtB0rCAgAAPC0HxnYCAAA8LQbuggIAADwtB96uAgAAPC0GQsYCAAA8LQdexgIAADwtBoq2AgAAPC0HUp4CAAA8LQeCrgIAADwtBn6yAgAAPC0HrsYCAAA8LQdWfgIAADwtByrGAgAAPC0HepYCAAA8LQdSegIAADwtB9JyAgAAPC0GnsoCAAA8LQbGdgIAADwtBoJ2AgAAPC0G5sYCAAA8LQbywgIAADwtBkqGAgAAPC0GzpoCAAA8LQemsgIAADwtBrJ6AgAAPC0HUq4CAAA8LQfemgIAADwtBgKaAgAAPC0GwoYCAAA8LQf6egIAADwtBjaOAgAAPC0GJrYCAAA8LQfeigIAADwtBoLGAgAAPC0Gun4CAAA8LQcalgIAADwtB6J6AgAAPC0GTooCAAA8LQcKvgIAADwtBw52AgAAPC0GLrICAAA8LQeGdgIAADwtBja+AgAAPC0HqoYCAAA8LQbStgIAADwtB0q+AgAAPC0HfsoCAAA8LQdKygIAADwtB8LCAgAAPC0GpooCAAA8LQfmjgIAADwtBmZ6AgAAPC0G1rICAAA8LQZuwgIAADwtBkrKAgAAPC0G2q4CAAA8LQcKigIAADwtB+LKAgAAPC0GepYCAAA8LQdCigIAADwtBup6AgAAPC0GBnoCAAA8LEMqAgIAAAAtB1qGAgAAhAQsgAQsWACAAIAAtAC1B/gFxIAFBAEdyOgAtCxkAIAAgAC0ALUH9AXEgAUEAR0EBdHI6AC0LGQAgACAALQAtQfsBcSABQQBHQQJ0cjoALQsZACAAIAAtAC1B9wFxIAFBAEdBA3RyOgAtCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAgAiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCBCIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQcaRgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIwIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAggiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2ioCAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCNCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIMIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZqAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAjgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCECIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZWQgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAI8IgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAhQiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEGqm4CAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCQCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIYIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZOAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCJCIERQ0AIAAgBBGAgICAAAAhAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIsIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAigiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2iICAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCUCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIcIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABBwpmAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCICIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZSUgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAJMIgRFDQAgACAEEYCAgIAAACEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAlQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCWCIERQ0AIAAgBBGAgICAAAAhAwsgAwtFAQF/AkACQCAALwEwQRRxQRRHDQBBASEDIAAtAChBAUYNASAALwEyQeUARiEDDAELIAAtAClBBUYhAwsgACADOgAuQQAL/gEBA39BASEDAkAgAC8BMCIEQQhxDQAgACkDIEIAUiEDCwJAAkAgAC0ALkUNAEEBIQUgAC0AKUEFRg0BQQEhBSAEQcAAcUUgA3FBAUcNAQtBACEFIARBwABxDQBBAiEFIARB//8DcSIDQQhxDQACQCADQYAEcUUNAAJAIAAtAChBAUcNACAALQAtQQpxDQBBBQ8LQQQPCwJAIANBIHENAAJAIAAtAChBAUYNACAALwEyQf//A3EiAEGcf2pB5ABJDQAgAEHMAUYNACAAQbACRg0AQQQhBSAEQShxRQ0CIANBiARxQYAERg0CC0EADwtBAEEDIAApAyBQGyEFCyAFC2IBAn9BACEBAkAgAC0AKEEBRg0AIAAvATJB//8DcSICQZx/akHkAEkNACACQcwBRg0AIAJBsAJGDQAgAC8BMCIAQcAAcQ0AQQEhASAAQYgEcUGABEYNACAAQShxRSEBCyABC6cBAQN/AkACQAJAIAAtACpFDQAgAC0AK0UNAEEAIQMgAC8BMCIEQQJxRQ0BDAILQQAhAyAALwEwIgRBAXFFDQELQQEhAyAALQAoQQFGDQAgAC8BMkH//wNxIgVBnH9qQeQASQ0AIAVBzAFGDQAgBUGwAkYNACAEQcAAcQ0AQQAhAyAEQYgEcUGABEYNACAEQShxQQBHIQMLIABBADsBMCAAQQA6AC8gAwuZAQECfwJAAkACQCAALQAqRQ0AIAAtACtFDQBBACEBIAAvATAiAkECcUUNAQwCC0EAIQEgAC8BMCICQQFxRQ0BC0EBIQEgAC0AKEEBRg0AIAAvATJB//8DcSIAQZx/akHkAEkNACAAQcwBRg0AIABBsAJGDQAgAkHAAHENAEEAIQEgAkGIBHFBgARGDQAgAkEocUEARyEBCyABC0kBAXsgAEEQav0MAAAAAAAAAAAAAAAAAAAAACIB/QsDACAAIAH9CwMAIABBMGogAf0LAwAgAEEgaiAB/QsDACAAQd0BNgIcQQALewEBfwJAIAAoAgwiAw0AAkAgACgCBEUNACAAIAE2AgQLAkAgACABIAIQxICAgAAiAw0AIAAoAgwPCyAAIAM2AhxBACEDIAAoAgQiAUUNACAAIAEgAiAAKAIIEYGAgIAAACIBRQ0AIAAgAjYCFCAAIAE2AgwgASEDCyADC+TzAQMOfwN+BH8jgICAgABBEGsiAySAgICAACABIQQgASEFIAEhBiABIQcgASEIIAEhCSABIQogASELIAEhDCABIQ0gASEOIAEhDwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIcIhBBf2oO3QHaAQHZAQIDBAUGBwgJCgsMDQ7YAQ8Q1wEREtYBExQVFhcYGRob4AHfARwdHtUBHyAhIiMkJdQBJicoKSorLNMB0gEtLtEB0AEvMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUbbAUdISUrPAc4BS80BTMwBTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gAGBAYIBgwGEAYUBhgGHAYgBiQGKAYsBjAGNAY4BjwGQAZEBkgGTAZQBlQGWAZcBmAGZAZoBmwGcAZ0BngGfAaABoQGiAaMBpAGlAaYBpwGoAakBqgGrAawBrQGuAa8BsAGxAbIBswG0AbUBtgG3AcsBygG4AckBuQHIAboBuwG8Ab0BvgG/AcABwQHCAcMBxAHFAcYBANwBC0EAIRAMxgELQQ4hEAzFAQtBDSEQDMQBC0EPIRAMwwELQRAhEAzCAQtBEyEQDMEBC0EUIRAMwAELQRUhEAy/AQtBFiEQDL4BC0EXIRAMvQELQRghEAy8AQtBGSEQDLsBC0EaIRAMugELQRshEAy5AQtBHCEQDLgBC0EIIRAMtwELQR0hEAy2AQtBICEQDLUBC0EfIRAMtAELQQchEAyzAQtBISEQDLIBC0EiIRAMsQELQR4hEAywAQtBIyEQDK8BC0ESIRAMrgELQREhEAytAQtBJCEQDKwBC0ElIRAMqwELQSYhEAyqAQtBJyEQDKkBC0HDASEQDKgBC0EpIRAMpwELQSshEAymAQtBLCEQDKUBC0EtIRAMpAELQS4hEAyjAQtBLyEQDKIBC0HEASEQDKEBC0EwIRAMoAELQTQhEAyfAQtBDCEQDJ4BC0ExIRAMnQELQTIhEAycAQtBMyEQDJsBC0E5IRAMmgELQTUhEAyZAQtBxQEhEAyYAQtBCyEQDJcBC0E6IRAMlgELQTYhEAyVAQtBCiEQDJQBC0E3IRAMkwELQTghEAySAQtBPCEQDJEBC0E7IRAMkAELQT0hEAyPAQtBCSEQDI4BC0EoIRAMjQELQT4hEAyMAQtBPyEQDIsBC0HAACEQDIoBC0HBACEQDIkBC0HCACEQDIgBC0HDACEQDIcBC0HEACEQDIYBC0HFACEQDIUBC0HGACEQDIQBC0EqIRAMgwELQccAIRAMggELQcgAIRAMgQELQckAIRAMgAELQcoAIRAMfwtBywAhEAx+C0HNACEQDH0LQcwAIRAMfAtBzgAhEAx7C0HPACEQDHoLQdAAIRAMeQtB0QAhEAx4C0HSACEQDHcLQdMAIRAMdgtB1AAhEAx1C0HWACEQDHQLQdUAIRAMcwtBBiEQDHILQdcAIRAMcQtBBSEQDHALQdgAIRAMbwtBBCEQDG4LQdkAIRAMbQtB2gAhEAxsC0HbACEQDGsLQdwAIRAMagtBAyEQDGkLQd0AIRAMaAtB3gAhEAxnC0HfACEQDGYLQeEAIRAMZQtB4AAhEAxkC0HiACEQDGMLQeMAIRAMYgtBAiEQDGELQeQAIRAMYAtB5QAhEAxfC0HmACEQDF4LQecAIRAMXQtB6AAhEAxcC0HpACEQDFsLQeoAIRAMWgtB6wAhEAxZC0HsACEQDFgLQe0AIRAMVwtB7gAhEAxWC0HvACEQDFULQfAAIRAMVAtB8QAhEAxTC0HyACEQDFILQfMAIRAMUQtB9AAhEAxQC0H1ACEQDE8LQfYAIRAMTgtB9wAhEAxNC0H4ACEQDEwLQfkAIRAMSwtB+gAhEAxKC0H7ACEQDEkLQfwAIRAMSAtB/QAhEAxHC0H+ACEQDEYLQf8AIRAMRQtBgAEhEAxEC0GBASEQDEMLQYIBIRAMQgtBgwEhEAxBC0GEASEQDEALQYUBIRAMPwtBhgEhEAw+C0GHASEQDD0LQYgBIRAMPAtBiQEhEAw7C0GKASEQDDoLQYsBIRAMOQtBjAEhEAw4C0GNASEQDDcLQY4BIRAMNgtBjwEhEAw1C0GQASEQDDQLQZEBIRAMMwtBkgEhEAwyC0GTASEQDDELQZQBIRAMMAtBlQEhEAwvC0GWASEQDC4LQZcBIRAMLQtBmAEhEAwsC0GZASEQDCsLQZoBIRAMKgtBmwEhEAwpC0GcASEQDCgLQZ0BIRAMJwtBngEhEAwmC0GfASEQDCULQaABIRAMJAtBoQEhEAwjC0GiASEQDCILQaMBIRAMIQtBpAEhEAwgC0GlASEQDB8LQaYBIRAMHgtBpwEhEAwdC0GoASEQDBwLQakBIRAMGwtBqgEhEAwaC0GrASEQDBkLQawBIRAMGAtBrQEhEAwXC0GuASEQDBYLQQEhEAwVC0GvASEQDBQLQbABIRAMEwtBsQEhEAwSC0GzASEQDBELQbIBIRAMEAtBtAEhEAwPC0G1ASEQDA4LQbYBIRAMDQtBtwEhEAwMC0G4ASEQDAsLQbkBIRAMCgtBugEhEAwJC0G7ASEQDAgLQcYBIRAMBwtBvAEhEAwGC0G9ASEQDAULQb4BIRAMBAtBvwEhEAwDC0HAASEQDAILQcIBIRAMAQtBwQEhEAsDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBAOxwEAAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB4fICEjJSg/QEFERUZHSElKS0xNT1BRUlPeA1dZW1xdYGJlZmdoaWprbG1vcHFyc3R1dnd4eXp7fH1+gAGCAYUBhgGHAYkBiwGMAY0BjgGPAZABkQGUAZUBlgGXAZgBmQGaAZsBnAGdAZ4BnwGgAaEBogGjAaQBpQGmAacBqAGpAaoBqwGsAa0BrgGvAbABsQGyAbMBtAG1AbYBtwG4AbkBugG7AbwBvQG+Ab8BwAHBAcIBwwHEAcUBxgHHAcgByQHKAcsBzAHNAc4BzwHQAdEB0gHTAdQB1QHWAdcB2AHZAdoB2wHcAd0B3gHgAeEB4gHjAeQB5QHmAecB6AHpAeoB6wHsAe0B7gHvAfAB8QHyAfMBmQKkArAC/gL+AgsgASIEIAJHDfMBQd0BIRAM/wMLIAEiECACRw3dAUHDASEQDP4DCyABIgEgAkcNkAFB9wAhEAz9AwsgASIBIAJHDYYBQe8AIRAM/AMLIAEiASACRw1/QeoAIRAM+wMLIAEiASACRw17QegAIRAM+gMLIAEiASACRw14QeYAIRAM+QMLIAEiASACRw0aQRghEAz4AwsgASIBIAJHDRRBEiEQDPcDCyABIgEgAkcNWUHFACEQDPYDCyABIgEgAkcNSkE/IRAM9QMLIAEiASACRw1IQTwhEAz0AwsgASIBIAJHDUFBMSEQDPMDCyAALQAuQQFGDesDDIcCCyAAIAEiASACEMCAgIAAQQFHDeYBIABCADcDIAznAQsgACABIgEgAhC0gICAACIQDecBIAEhAQz1AgsCQCABIgEgAkcNAEEGIRAM8AMLIAAgAUEBaiIBIAIQu4CAgAAiEA3oASABIQEMMQsgAEIANwMgQRIhEAzVAwsgASIQIAJHDStBHSEQDO0DCwJAIAEiASACRg0AIAFBAWohAUEQIRAM1AMLQQchEAzsAwsgAEIAIAApAyAiESACIAEiEGutIhJ9IhMgEyARVhs3AyAgESASViIURQ3lAUEIIRAM6wMLAkAgASIBIAJGDQAgAEGJgICAADYCCCAAIAE2AgQgASEBQRQhEAzSAwtBCSEQDOoDCyABIQEgACkDIFAN5AEgASEBDPICCwJAIAEiASACRw0AQQshEAzpAwsgACABQQFqIgEgAhC2gICAACIQDeUBIAEhAQzyAgsgACABIgEgAhC4gICAACIQDeUBIAEhAQzyAgsgACABIgEgAhC4gICAACIQDeYBIAEhAQwNCyAAIAEiASACELqAgIAAIhAN5wEgASEBDPACCwJAIAEiASACRw0AQQ8hEAzlAwsgAS0AACIQQTtGDQggEEENRw3oASABQQFqIQEM7wILIAAgASIBIAIQuoCAgAAiEA3oASABIQEM8gILA0ACQCABLQAAQfC1gIAAai0AACIQQQFGDQAgEEECRw3rASAAKAIEIRAgAEEANgIEIAAgECABQQFqIgEQuYCAgAAiEA3qASABIQEM9AILIAFBAWoiASACRw0AC0ESIRAM4gMLIAAgASIBIAIQuoCAgAAiEA3pASABIQEMCgsgASIBIAJHDQZBGyEQDOADCwJAIAEiASACRw0AQRYhEAzgAwsgAEGKgICAADYCCCAAIAE2AgQgACABIAIQuICAgAAiEA3qASABIQFBICEQDMYDCwJAIAEiASACRg0AA0ACQCABLQAAQfC3gIAAai0AACIQQQJGDQACQCAQQX9qDgTlAewBAOsB7AELIAFBAWohAUEIIRAMyAMLIAFBAWoiASACRw0AC0EVIRAM3wMLQRUhEAzeAwsDQAJAIAEtAABB8LmAgABqLQAAIhBBAkYNACAQQX9qDgTeAewB4AHrAewBCyABQQFqIgEgAkcNAAtBGCEQDN0DCwJAIAEiASACRg0AIABBi4CAgAA2AgggACABNgIEIAEhAUEHIRAMxAMLQRkhEAzcAwsgAUEBaiEBDAILAkAgASIUIAJHDQBBGiEQDNsDCyAUIQECQCAULQAAQXNqDhTdAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAgDuAgtBACEQIABBADYCHCAAQa+LgIAANgIQIABBAjYCDCAAIBRBAWo2AhQM2gMLAkAgAS0AACIQQTtGDQAgEEENRw3oASABQQFqIQEM5QILIAFBAWohAQtBIiEQDL8DCwJAIAEiECACRw0AQRwhEAzYAwtCACERIBAhASAQLQAAQVBqDjfnAeYBAQIDBAUGBwgAAAAAAAAACQoLDA0OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPEBESExQAC0EeIRAMvQMLQgIhEQzlAQtCAyERDOQBC0IEIREM4wELQgUhEQziAQtCBiERDOEBC0IHIREM4AELQgghEQzfAQtCCSERDN4BC0IKIREM3QELQgshEQzcAQtCDCERDNsBC0INIREM2gELQg4hEQzZAQtCDyERDNgBC0IKIREM1wELQgshEQzWAQtCDCERDNUBC0INIREM1AELQg4hEQzTAQtCDyERDNIBC0IAIRECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIBAtAABBUGoON+UB5AEAAQIDBAUGB+YB5gHmAeYB5gHmAeYBCAkKCwwN5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAQ4PEBESE+YBC0ICIREM5AELQgMhEQzjAQtCBCERDOIBC0IFIREM4QELQgYhEQzgAQtCByERDN8BC0IIIREM3gELQgkhEQzdAQtCCiERDNwBC0ILIREM2wELQgwhEQzaAQtCDSERDNkBC0IOIREM2AELQg8hEQzXAQtCCiERDNYBC0ILIREM1QELQgwhEQzUAQtCDSERDNMBC0IOIREM0gELQg8hEQzRAQsgAEIAIAApAyAiESACIAEiEGutIhJ9IhMgEyARVhs3AyAgESASViIURQ3SAUEfIRAMwAMLAkAgASIBIAJGDQAgAEGJgICAADYCCCAAIAE2AgQgASEBQSQhEAynAwtBICEQDL8DCyAAIAEiECACEL6AgIAAQX9qDgW2AQDFAgHRAdIBC0ERIRAMpAMLIABBAToALyAQIQEMuwMLIAEiASACRw3SAUEkIRAMuwMLIAEiDSACRw0eQcYAIRAMugMLIAAgASIBIAIQsoCAgAAiEA3UASABIQEMtQELIAEiECACRw0mQdAAIRAMuAMLAkAgASIBIAJHDQBBKCEQDLgDCyAAQQA2AgQgAEGMgICAADYCCCAAIAEgARCxgICAACIQDdMBIAEhAQzYAQsCQCABIhAgAkcNAEEpIRAMtwMLIBAtAAAiAUEgRg0UIAFBCUcN0wEgEEEBaiEBDBULAkAgASIBIAJGDQAgAUEBaiEBDBcLQSohEAy1AwsCQCABIhAgAkcNAEErIRAMtQMLAkAgEC0AACIBQQlGDQAgAUEgRw3VAQsgAC0ALEEIRg3TASAQIQEMkQMLAkAgASIBIAJHDQBBLCEQDLQDCyABLQAAQQpHDdUBIAFBAWohAQzJAgsgASIOIAJHDdUBQS8hEAyyAwsDQAJAIAEtAAAiEEEgRg0AAkAgEEF2ag4EANwB3AEA2gELIAEhAQzgAQsgAUEBaiIBIAJHDQALQTEhEAyxAwtBMiEQIAEiFCACRg2wAyACIBRrIAAoAgAiAWohFSAUIAFrQQNqIRYCQANAIBQtAAAiF0EgciAXIBdBv39qQf8BcUEaSRtB/wFxIAFB8LuAgABqLQAARw0BAkAgAUEDRw0AQQYhAQyWAwsgAUEBaiEBIBRBAWoiFCACRw0ACyAAIBU2AgAMsQMLIABBADYCACAUIQEM2QELQTMhECABIhQgAkYNrwMgAiAUayAAKAIAIgFqIRUgFCABa0EIaiEWAkADQCAULQAAIhdBIHIgFyAXQb9/akH/AXFBGkkbQf8BcSABQfS7gIAAai0AAEcNAQJAIAFBCEcNAEEFIQEMlQMLIAFBAWohASAUQQFqIhQgAkcNAAsgACAVNgIADLADCyAAQQA2AgAgFCEBDNgBC0E0IRAgASIUIAJGDa4DIAIgFGsgACgCACIBaiEVIBQgAWtBBWohFgJAA0AgFC0AACIXQSByIBcgF0G/f2pB/wFxQRpJG0H/AXEgAUHQwoCAAGotAABHDQECQCABQQVHDQBBByEBDJQDCyABQQFqIQEgFEEBaiIUIAJHDQALIAAgFTYCAAyvAwsgAEEANgIAIBQhAQzXAQsCQCABIgEgAkYNAANAAkAgAS0AAEGAvoCAAGotAAAiEEEBRg0AIBBBAkYNCiABIQEM3QELIAFBAWoiASACRw0AC0EwIRAMrgMLQTAhEAytAwsCQCABIgEgAkYNAANAAkAgAS0AACIQQSBGDQAgEEF2ag4E2QHaAdoB2QHaAQsgAUEBaiIBIAJHDQALQTghEAytAwtBOCEQDKwDCwNAAkAgAS0AACIQQSBGDQAgEEEJRw0DCyABQQFqIgEgAkcNAAtBPCEQDKsDCwNAAkAgAS0AACIQQSBGDQACQAJAIBBBdmoOBNoBAQHaAQALIBBBLEYN2wELIAEhAQwECyABQQFqIgEgAkcNAAtBPyEQDKoDCyABIQEM2wELQcAAIRAgASIUIAJGDagDIAIgFGsgACgCACIBaiEWIBQgAWtBBmohFwJAA0AgFC0AAEEgciABQYDAgIAAai0AAEcNASABQQZGDY4DIAFBAWohASAUQQFqIhQgAkcNAAsgACAWNgIADKkDCyAAQQA2AgAgFCEBC0E2IRAMjgMLAkAgASIPIAJHDQBBwQAhEAynAwsgAEGMgICAADYCCCAAIA82AgQgDyEBIAAtACxBf2oOBM0B1QHXAdkBhwMLIAFBAWohAQzMAQsCQCABIgEgAkYNAANAAkAgAS0AACIQQSByIBAgEEG/f2pB/wFxQRpJG0H/AXEiEEEJRg0AIBBBIEYNAAJAAkACQAJAIBBBnX9qDhMAAwMDAwMDAwEDAwMDAwMDAwMCAwsgAUEBaiEBQTEhEAyRAwsgAUEBaiEBQTIhEAyQAwsgAUEBaiEBQTMhEAyPAwsgASEBDNABCyABQQFqIgEgAkcNAAtBNSEQDKUDC0E1IRAMpAMLAkAgASIBIAJGDQADQAJAIAEtAABBgLyAgABqLQAAQQFGDQAgASEBDNMBCyABQQFqIgEgAkcNAAtBPSEQDKQDC0E9IRAMowMLIAAgASIBIAIQsICAgAAiEA3WASABIQEMAQsgEEEBaiEBC0E8IRAMhwMLAkAgASIBIAJHDQBBwgAhEAygAwsCQANAAkAgAS0AAEF3ag4YAAL+Av4ChAP+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gIA/gILIAFBAWoiASACRw0AC0HCACEQDKADCyABQQFqIQEgAC0ALUEBcUUNvQEgASEBC0EsIRAMhQMLIAEiASACRw3TAUHEACEQDJ0DCwNAAkAgAS0AAEGQwICAAGotAABBAUYNACABIQEMtwILIAFBAWoiASACRw0AC0HFACEQDJwDCyANLQAAIhBBIEYNswEgEEE6Rw2BAyAAKAIEIQEgAEEANgIEIAAgASANEK+AgIAAIgEN0AEgDUEBaiEBDLMCC0HHACEQIAEiDSACRg2aAyACIA1rIAAoAgAiAWohFiANIAFrQQVqIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQZDCgIAAai0AAEcNgAMgAUEFRg30AiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyaAwtByAAhECABIg0gAkYNmQMgAiANayAAKAIAIgFqIRYgDSABa0EJaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUGWwoCAAGotAABHDf8CAkAgAUEJRw0AQQIhAQz1AgsgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMmQMLAkAgASINIAJHDQBByQAhEAyZAwsCQAJAIA0tAAAiAUEgciABIAFBv39qQf8BcUEaSRtB/wFxQZJ/ag4HAIADgAOAA4ADgAMBgAMLIA1BAWohAUE+IRAMgAMLIA1BAWohAUE/IRAM/wILQcoAIRAgASINIAJGDZcDIAIgDWsgACgCACIBaiEWIA0gAWtBAWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFBoMKAgABqLQAARw39AiABQQFGDfACIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJcDC0HLACEQIAEiDSACRg2WAyACIA1rIAAoAgAiAWohFiANIAFrQQ5qIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQaLCgIAAai0AAEcN/AIgAUEORg3wAiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyWAwtBzAAhECABIg0gAkYNlQMgAiANayAAKAIAIgFqIRYgDSABa0EPaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUHAwoCAAGotAABHDfsCAkAgAUEPRw0AQQMhAQzxAgsgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMlQMLQc0AIRAgASINIAJGDZQDIAIgDWsgACgCACIBaiEWIA0gAWtBBWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFB0MKAgABqLQAARw36AgJAIAFBBUcNAEEEIQEM8AILIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJQDCwJAIAEiDSACRw0AQc4AIRAMlAMLAkACQAJAAkAgDS0AACIBQSByIAEgAUG/f2pB/wFxQRpJG0H/AXFBnX9qDhMA/QL9Av0C/QL9Av0C/QL9Av0C/QL9Av0CAf0C/QL9AgID/QILIA1BAWohAUHBACEQDP0CCyANQQFqIQFBwgAhEAz8AgsgDUEBaiEBQcMAIRAM+wILIA1BAWohAUHEACEQDPoCCwJAIAEiASACRg0AIABBjYCAgAA2AgggACABNgIEIAEhAUHFACEQDPoCC0HPACEQDJIDCyAQIQECQAJAIBAtAABBdmoOBAGoAqgCAKgCCyAQQQFqIQELQSchEAz4AgsCQCABIgEgAkcNAEHRACEQDJEDCwJAIAEtAABBIEYNACABIQEMjQELIAFBAWohASAALQAtQQFxRQ3HASABIQEMjAELIAEiFyACRw3IAUHSACEQDI8DC0HTACEQIAEiFCACRg2OAyACIBRrIAAoAgAiAWohFiAUIAFrQQFqIRcDQCAULQAAIAFB1sKAgABqLQAARw3MASABQQFGDccBIAFBAWohASAUQQFqIhQgAkcNAAsgACAWNgIADI4DCwJAIAEiASACRw0AQdUAIRAMjgMLIAEtAABBCkcNzAEgAUEBaiEBDMcBCwJAIAEiASACRw0AQdYAIRAMjQMLAkACQCABLQAAQXZqDgQAzQHNAQHNAQsgAUEBaiEBDMcBCyABQQFqIQFBygAhEAzzAgsgACABIgEgAhCugICAACIQDcsBIAEhAUHNACEQDPICCyAALQApQSJGDYUDDKYCCwJAIAEiASACRw0AQdsAIRAMigMLQQAhFEEBIRdBASEWQQAhEAJAAkACQAJAAkACQAJAAkACQCABLQAAQVBqDgrUAdMBAAECAwQFBgjVAQtBAiEQDAYLQQMhEAwFC0EEIRAMBAtBBSEQDAMLQQYhEAwCC0EHIRAMAQtBCCEQC0EAIRdBACEWQQAhFAzMAQtBCSEQQQEhFEEAIRdBACEWDMsBCwJAIAEiASACRw0AQd0AIRAMiQMLIAEtAABBLkcNzAEgAUEBaiEBDKYCCyABIgEgAkcNzAFB3wAhEAyHAwsCQCABIgEgAkYNACAAQY6AgIAANgIIIAAgATYCBCABIQFB0AAhEAzuAgtB4AAhEAyGAwtB4QAhECABIgEgAkYNhQMgAiABayAAKAIAIhRqIRYgASAUa0EDaiEXA0AgAS0AACAUQeLCgIAAai0AAEcNzQEgFEEDRg3MASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyFAwtB4gAhECABIgEgAkYNhAMgAiABayAAKAIAIhRqIRYgASAUa0ECaiEXA0AgAS0AACAUQebCgIAAai0AAEcNzAEgFEECRg3OASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyEAwtB4wAhECABIgEgAkYNgwMgAiABayAAKAIAIhRqIRYgASAUa0EDaiEXA0AgAS0AACAUQenCgIAAai0AAEcNywEgFEEDRg3OASAUQQFqIRQgAUEBaiIBIAJHDQALIAAgFjYCAAyDAwsCQCABIgEgAkcNAEHlACEQDIMDCyAAIAFBAWoiASACEKiAgIAAIhANzQEgASEBQdYAIRAM6QILAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgRg0AAkACQAJAIBBBuH9qDgsAAc8BzwHPAc8BzwHPAc8BzwECzwELIAFBAWohAUHSACEQDO0CCyABQQFqIQFB0wAhEAzsAgsgAUEBaiEBQdQAIRAM6wILIAFBAWoiASACRw0AC0HkACEQDIIDC0HkACEQDIEDCwNAAkAgAS0AAEHwwoCAAGotAAAiEEEBRg0AIBBBfmoOA88B0AHRAdIBCyABQQFqIgEgAkcNAAtB5gAhEAyAAwsCQCABIgEgAkYNACABQQFqIQEMAwtB5wAhEAz/AgsDQAJAIAEtAABB8MSAgABqLQAAIhBBAUYNAAJAIBBBfmoOBNIB0wHUAQDVAQsgASEBQdcAIRAM5wILIAFBAWoiASACRw0AC0HoACEQDP4CCwJAIAEiASACRw0AQekAIRAM/gILAkAgAS0AACIQQXZqDhq6AdUB1QG8AdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAcoB1QHVAQDTAQsgAUEBaiEBC0EGIRAM4wILA0ACQCABLQAAQfDGgIAAai0AAEEBRg0AIAEhAQyeAgsgAUEBaiIBIAJHDQALQeoAIRAM+wILAkAgASIBIAJGDQAgAUEBaiEBDAMLQesAIRAM+gILAkAgASIBIAJHDQBB7AAhEAz6AgsgAUEBaiEBDAELAkAgASIBIAJHDQBB7QAhEAz5AgsgAUEBaiEBC0EEIRAM3gILAkAgASIUIAJHDQBB7gAhEAz3AgsgFCEBAkACQAJAIBQtAABB8MiAgABqLQAAQX9qDgfUAdUB1gEAnAIBAtcBCyAUQQFqIQEMCgsgFEEBaiEBDM0BC0EAIRAgAEEANgIcIABBm5KAgAA2AhAgAEEHNgIMIAAgFEEBajYCFAz2AgsCQANAAkAgAS0AAEHwyICAAGotAAAiEEEERg0AAkACQCAQQX9qDgfSAdMB1AHZAQAEAdkBCyABIQFB2gAhEAzgAgsgAUEBaiEBQdwAIRAM3wILIAFBAWoiASACRw0AC0HvACEQDPYCCyABQQFqIQEMywELAkAgASIUIAJHDQBB8AAhEAz1AgsgFC0AAEEvRw3UASAUQQFqIQEMBgsCQCABIhQgAkcNAEHxACEQDPQCCwJAIBQtAAAiAUEvRw0AIBRBAWohAUHdACEQDNsCCyABQXZqIgRBFksN0wFBASAEdEGJgIACcUUN0wEMygILAkAgASIBIAJGDQAgAUEBaiEBQd4AIRAM2gILQfIAIRAM8gILAkAgASIUIAJHDQBB9AAhEAzyAgsgFCEBAkAgFC0AAEHwzICAAGotAABBf2oOA8kClAIA1AELQeEAIRAM2AILAkAgASIUIAJGDQADQAJAIBQtAABB8MqAgABqLQAAIgFBA0YNAAJAIAFBf2oOAssCANUBCyAUIQFB3wAhEAzaAgsgFEEBaiIUIAJHDQALQfMAIRAM8QILQfMAIRAM8AILAkAgASIBIAJGDQAgAEGPgICAADYCCCAAIAE2AgQgASEBQeAAIRAM1wILQfUAIRAM7wILAkAgASIBIAJHDQBB9gAhEAzvAgsgAEGPgICAADYCCCAAIAE2AgQgASEBC0EDIRAM1AILA0AgAS0AAEEgRw3DAiABQQFqIgEgAkcNAAtB9wAhEAzsAgsCQCABIgEgAkcNAEH4ACEQDOwCCyABLQAAQSBHDc4BIAFBAWohAQzvAQsgACABIgEgAhCsgICAACIQDc4BIAEhAQyOAgsCQCABIgQgAkcNAEH6ACEQDOoCCyAELQAAQcwARw3RASAEQQFqIQFBEyEQDM8BCwJAIAEiBCACRw0AQfsAIRAM6QILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEANAIAQtAAAgAUHwzoCAAGotAABHDdABIAFBBUYNzgEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBB+wAhEAzoAgsCQCABIgQgAkcNAEH8ACEQDOgCCwJAAkAgBC0AAEG9f2oODADRAdEB0QHRAdEB0QHRAdEB0QHRAQHRAQsgBEEBaiEBQeYAIRAMzwILIARBAWohAUHnACEQDM4CCwJAIAEiBCACRw0AQf0AIRAM5wILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNzwEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf0AIRAM5wILIABBADYCACAQQQFqIQFBECEQDMwBCwJAIAEiBCACRw0AQf4AIRAM5gILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQfbOgIAAai0AAEcNzgEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf4AIRAM5gILIABBADYCACAQQQFqIQFBFiEQDMsBCwJAIAEiBCACRw0AQf8AIRAM5QILIAIgBGsgACgCACIBaiEUIAQgAWtBA2ohEAJAA0AgBC0AACABQfzOgIAAai0AAEcNzQEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQf8AIRAM5QILIABBADYCACAQQQFqIQFBBSEQDMoBCwJAIAEiBCACRw0AQYABIRAM5AILIAQtAABB2QBHDcsBIARBAWohAUEIIRAMyQELAkAgASIEIAJHDQBBgQEhEAzjAgsCQAJAIAQtAABBsn9qDgMAzAEBzAELIARBAWohAUHrACEQDMoCCyAEQQFqIQFB7AAhEAzJAgsCQCABIgQgAkcNAEGCASEQDOICCwJAAkAgBC0AAEG4f2oOCADLAcsBywHLAcsBywEBywELIARBAWohAUHqACEQDMkCCyAEQQFqIQFB7QAhEAzIAgsCQCABIgQgAkcNAEGDASEQDOECCyACIARrIAAoAgAiAWohECAEIAFrQQJqIRQCQANAIAQtAAAgAUGAz4CAAGotAABHDckBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgEDYCAEGDASEQDOECC0EAIRAgAEEANgIAIBRBAWohAQzGAQsCQCABIgQgAkcNAEGEASEQDOACCyACIARrIAAoAgAiAWohFCAEIAFrQQRqIRACQANAIAQtAAAgAUGDz4CAAGotAABHDcgBIAFBBEYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGEASEQDOACCyAAQQA2AgAgEEEBaiEBQSMhEAzFAQsCQCABIgQgAkcNAEGFASEQDN8CCwJAAkAgBC0AAEG0f2oOCADIAcgByAHIAcgByAEByAELIARBAWohAUHvACEQDMYCCyAEQQFqIQFB8AAhEAzFAgsCQCABIgQgAkcNAEGGASEQDN4CCyAELQAAQcUARw3FASAEQQFqIQEMgwILAkAgASIEIAJHDQBBhwEhEAzdAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFBiM+AgABqLQAARw3FASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBhwEhEAzdAgsgAEEANgIAIBBBAWohAUEtIRAMwgELAkAgASIEIAJHDQBBiAEhEAzcAgsgAiAEayAAKAIAIgFqIRQgBCABa0EIaiEQAkADQCAELQAAIAFB0M+AgABqLQAARw3EASABQQhGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBiAEhEAzcAgsgAEEANgIAIBBBAWohAUEpIRAMwQELAkAgASIBIAJHDQBBiQEhEAzbAgtBASEQIAEtAABB3wBHDcABIAFBAWohAQyBAgsCQCABIgQgAkcNAEGKASEQDNoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRADQCAELQAAIAFBjM+AgABqLQAARw3BASABQQFGDa8CIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYoBIRAM2QILAkAgASIEIAJHDQBBiwEhEAzZAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFBjs+AgABqLQAARw3BASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBiwEhEAzZAgsgAEEANgIAIBBBAWohAUECIRAMvgELAkAgASIEIAJHDQBBjAEhEAzYAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8M+AgABqLQAARw3AASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBjAEhEAzYAgsgAEEANgIAIBBBAWohAUEfIRAMvQELAkAgASIEIAJHDQBBjQEhEAzXAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8s+AgABqLQAARw2/ASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBjQEhEAzXAgsgAEEANgIAIBBBAWohAUEJIRAMvAELAkAgASIEIAJHDQBBjgEhEAzWAgsCQAJAIAQtAABBt39qDgcAvwG/Ab8BvwG/AQG/AQsgBEEBaiEBQfgAIRAMvQILIARBAWohAUH5ACEQDLwCCwJAIAEiBCACRw0AQY8BIRAM1QILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQZHPgIAAai0AAEcNvQEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQY8BIRAM1QILIABBADYCACAQQQFqIQFBGCEQDLoBCwJAIAEiBCACRw0AQZABIRAM1AILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQZfPgIAAai0AAEcNvAEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZABIRAM1AILIABBADYCACAQQQFqIQFBFyEQDLkBCwJAIAEiBCACRw0AQZEBIRAM0wILIAIgBGsgACgCACIBaiEUIAQgAWtBBmohEAJAA0AgBC0AACABQZrPgIAAai0AAEcNuwEgAUEGRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZEBIRAM0wILIABBADYCACAQQQFqIQFBFSEQDLgBCwJAIAEiBCACRw0AQZIBIRAM0gILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQaHPgIAAai0AAEcNugEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZIBIRAM0gILIABBADYCACAQQQFqIQFBHiEQDLcBCwJAIAEiBCACRw0AQZMBIRAM0QILIAQtAABBzABHDbgBIARBAWohAUEKIRAMtgELAkAgBCACRw0AQZQBIRAM0AILAkACQCAELQAAQb9/ag4PALkBuQG5AbkBuQG5AbkBuQG5AbkBuQG5AbkBAbkBCyAEQQFqIQFB/gAhEAy3AgsgBEEBaiEBQf8AIRAMtgILAkAgBCACRw0AQZUBIRAMzwILAkACQCAELQAAQb9/ag4DALgBAbgBCyAEQQFqIQFB/QAhEAy2AgsgBEEBaiEEQYABIRAMtQILAkAgBCACRw0AQZYBIRAMzgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQafPgIAAai0AAEcNtgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZYBIRAMzgILIABBADYCACAQQQFqIQFBCyEQDLMBCwJAIAQgAkcNAEGXASEQDM0CCwJAAkACQAJAIAQtAABBU2oOIwC4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBAbgBuAG4AbgBuAECuAG4AbgBA7gBCyAEQQFqIQFB+wAhEAy2AgsgBEEBaiEBQfwAIRAMtQILIARBAWohBEGBASEQDLQCCyAEQQFqIQRBggEhEAyzAgsCQCAEIAJHDQBBmAEhEAzMAgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBqc+AgABqLQAARw20ASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmAEhEAzMAgsgAEEANgIAIBBBAWohAUEZIRAMsQELAkAgBCACRw0AQZkBIRAMywILIAIgBGsgACgCACIBaiEUIAQgAWtBBWohEAJAA0AgBC0AACABQa7PgIAAai0AAEcNswEgAUEFRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZkBIRAMywILIABBADYCACAQQQFqIQFBBiEQDLABCwJAIAQgAkcNAEGaASEQDMoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUG0z4CAAGotAABHDbIBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGaASEQDMoCCyAAQQA2AgAgEEEBaiEBQRwhEAyvAQsCQCAEIAJHDQBBmwEhEAzJAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBts+AgABqLQAARw2xASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmwEhEAzJAgsgAEEANgIAIBBBAWohAUEnIRAMrgELAkAgBCACRw0AQZwBIRAMyAILAkACQCAELQAAQax/ag4CAAGxAQsgBEEBaiEEQYYBIRAMrwILIARBAWohBEGHASEQDK4CCwJAIAQgAkcNAEGdASEQDMcCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUG4z4CAAGotAABHDa8BIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGdASEQDMcCCyAAQQA2AgAgEEEBaiEBQSYhEAysAQsCQCAEIAJHDQBBngEhEAzGAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBus+AgABqLQAARw2uASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBngEhEAzGAgsgAEEANgIAIBBBAWohAUEDIRAMqwELAkAgBCACRw0AQZ8BIRAMxQILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNrQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZ8BIRAMxQILIABBADYCACAQQQFqIQFBDCEQDKoBCwJAIAQgAkcNAEGgASEQDMQCCyACIARrIAAoAgAiAWohFCAEIAFrQQNqIRACQANAIAQtAAAgAUG8z4CAAGotAABHDawBIAFBA0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGgASEQDMQCCyAAQQA2AgAgEEEBaiEBQQ0hEAypAQsCQCAEIAJHDQBBoQEhEAzDAgsCQAJAIAQtAABBun9qDgsArAGsAawBrAGsAawBrAGsAawBAawBCyAEQQFqIQRBiwEhEAyqAgsgBEEBaiEEQYwBIRAMqQILAkAgBCACRw0AQaIBIRAMwgILIAQtAABB0ABHDakBIARBAWohBAzpAQsCQCAEIAJHDQBBowEhEAzBAgsCQAJAIAQtAABBt39qDgcBqgGqAaoBqgGqAQCqAQsgBEEBaiEEQY4BIRAMqAILIARBAWohAUEiIRAMpgELAkAgBCACRw0AQaQBIRAMwAILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQcDPgIAAai0AAEcNqAEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQaQBIRAMwAILIABBADYCACAQQQFqIQFBHSEQDKUBCwJAIAQgAkcNAEGlASEQDL8CCwJAAkAgBC0AAEGuf2oOAwCoAQGoAQsgBEEBaiEEQZABIRAMpgILIARBAWohAUEEIRAMpAELAkAgBCACRw0AQaYBIRAMvgILAkACQAJAAkACQCAELQAAQb9/ag4VAKoBqgGqAaoBqgGqAaoBqgGqAaoBAaoBqgECqgGqAQOqAaoBBKoBCyAEQQFqIQRBiAEhEAyoAgsgBEEBaiEEQYkBIRAMpwILIARBAWohBEGKASEQDKYCCyAEQQFqIQRBjwEhEAylAgsgBEEBaiEEQZEBIRAMpAILAkAgBCACRw0AQacBIRAMvQILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQe3PgIAAai0AAEcNpQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQacBIRAMvQILIABBADYCACAQQQFqIQFBESEQDKIBCwJAIAQgAkcNAEGoASEQDLwCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHCz4CAAGotAABHDaQBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGoASEQDLwCCyAAQQA2AgAgEEEBaiEBQSwhEAyhAQsCQCAEIAJHDQBBqQEhEAy7AgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBxc+AgABqLQAARw2jASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBqQEhEAy7AgsgAEEANgIAIBBBAWohAUErIRAMoAELAkAgBCACRw0AQaoBIRAMugILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQcrPgIAAai0AAEcNogEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQaoBIRAMugILIABBADYCACAQQQFqIQFBFCEQDJ8BCwJAIAQgAkcNAEGrASEQDLkCCwJAAkACQAJAIAQtAABBvn9qDg8AAQKkAaQBpAGkAaQBpAGkAaQBpAGkAaQBA6QBCyAEQQFqIQRBkwEhEAyiAgsgBEEBaiEEQZQBIRAMoQILIARBAWohBEGVASEQDKACCyAEQQFqIQRBlgEhEAyfAgsCQCAEIAJHDQBBrAEhEAy4AgsgBC0AAEHFAEcNnwEgBEEBaiEEDOABCwJAIAQgAkcNAEGtASEQDLcCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHNz4CAAGotAABHDZ8BIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGtASEQDLcCCyAAQQA2AgAgEEEBaiEBQQ4hEAycAQsCQCAEIAJHDQBBrgEhEAy2AgsgBC0AAEHQAEcNnQEgBEEBaiEBQSUhEAybAQsCQCAEIAJHDQBBrwEhEAy1AgsgAiAEayAAKAIAIgFqIRQgBCABa0EIaiEQAkADQCAELQAAIAFB0M+AgABqLQAARw2dASABQQhGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBrwEhEAy1AgsgAEEANgIAIBBBAWohAUEqIRAMmgELAkAgBCACRw0AQbABIRAMtAILAkACQCAELQAAQat/ag4LAJ0BnQGdAZ0BnQGdAZ0BnQGdAQGdAQsgBEEBaiEEQZoBIRAMmwILIARBAWohBEGbASEQDJoCCwJAIAQgAkcNAEGxASEQDLMCCwJAAkAgBC0AAEG/f2oOFACcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAEBnAELIARBAWohBEGZASEQDJoCCyAEQQFqIQRBnAEhEAyZAgsCQCAEIAJHDQBBsgEhEAyyAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFB2c+AgABqLQAARw2aASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBsgEhEAyyAgsgAEEANgIAIBBBAWohAUEhIRAMlwELAkAgBCACRw0AQbMBIRAMsQILIAIgBGsgACgCACIBaiEUIAQgAWtBBmohEAJAA0AgBC0AACABQd3PgIAAai0AAEcNmQEgAUEGRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbMBIRAMsQILIABBADYCACAQQQFqIQFBGiEQDJYBCwJAIAQgAkcNAEG0ASEQDLACCwJAAkACQCAELQAAQbt/ag4RAJoBmgGaAZoBmgGaAZoBmgGaAQGaAZoBmgGaAZoBApoBCyAEQQFqIQRBnQEhEAyYAgsgBEEBaiEEQZ4BIRAMlwILIARBAWohBEGfASEQDJYCCwJAIAQgAkcNAEG1ASEQDK8CCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUHkz4CAAGotAABHDZcBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG1ASEQDK8CCyAAQQA2AgAgEEEBaiEBQSghEAyUAQsCQCAEIAJHDQBBtgEhEAyuAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFB6s+AgABqLQAARw2WASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBtgEhEAyuAgsgAEEANgIAIBBBAWohAUEHIRAMkwELAkAgBCACRw0AQbcBIRAMrQILAkACQCAELQAAQbt/ag4OAJYBlgGWAZYBlgGWAZYBlgGWAZYBlgGWAQGWAQsgBEEBaiEEQaEBIRAMlAILIARBAWohBEGiASEQDJMCCwJAIAQgAkcNAEG4ASEQDKwCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDZQBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG4ASEQDKwCCyAAQQA2AgAgEEEBaiEBQRIhEAyRAQsCQCAEIAJHDQBBuQEhEAyrAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFB8M+AgABqLQAARw2TASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBuQEhEAyrAgsgAEEANgIAIBBBAWohAUEgIRAMkAELAkAgBCACRw0AQboBIRAMqgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfLPgIAAai0AAEcNkgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQboBIRAMqgILIABBADYCACAQQQFqIQFBDyEQDI8BCwJAIAQgAkcNAEG7ASEQDKkCCwJAAkAgBC0AAEG3f2oOBwCSAZIBkgGSAZIBAZIBCyAEQQFqIQRBpQEhEAyQAgsgBEEBaiEEQaYBIRAMjwILAkAgBCACRw0AQbwBIRAMqAILIAIgBGsgACgCACIBaiEUIAQgAWtBB2ohEAJAA0AgBC0AACABQfTPgIAAai0AAEcNkAEgAUEHRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbwBIRAMqAILIABBADYCACAQQQFqIQFBGyEQDI0BCwJAIAQgAkcNAEG9ASEQDKcCCwJAAkACQCAELQAAQb5/ag4SAJEBkQGRAZEBkQGRAZEBkQGRAQGRAZEBkQGRAZEBkQECkQELIARBAWohBEGkASEQDI8CCyAEQQFqIQRBpwEhEAyOAgsgBEEBaiEEQagBIRAMjQILAkAgBCACRw0AQb4BIRAMpgILIAQtAABBzgBHDY0BIARBAWohBAzPAQsCQCAEIAJHDQBBvwEhEAylAgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAELQAAQb9/ag4VAAECA5wBBAUGnAGcAZwBBwgJCgucAQwNDg+cAQsgBEEBaiEBQegAIRAMmgILIARBAWohAUHpACEQDJkCCyAEQQFqIQFB7gAhEAyYAgsgBEEBaiEBQfIAIRAMlwILIARBAWohAUHzACEQDJYCCyAEQQFqIQFB9gAhEAyVAgsgBEEBaiEBQfcAIRAMlAILIARBAWohAUH6ACEQDJMCCyAEQQFqIQRBgwEhEAySAgsgBEEBaiEEQYQBIRAMkQILIARBAWohBEGFASEQDJACCyAEQQFqIQRBkgEhEAyPAgsgBEEBaiEEQZgBIRAMjgILIARBAWohBEGgASEQDI0CCyAEQQFqIQRBowEhEAyMAgsgBEEBaiEEQaoBIRAMiwILAkAgBCACRg0AIABBkICAgAA2AgggACAENgIEQasBIRAMiwILQcABIRAMowILIAAgBSACEKqAgIAAIgENiwEgBSEBDFwLAkAgBiACRg0AIAZBAWohBQyNAQtBwgEhEAyhAgsDQAJAIBAtAABBdmoOBIwBAACPAQALIBBBAWoiECACRw0AC0HDASEQDKACCwJAIAcgAkYNACAAQZGAgIAANgIIIAAgBzYCBCAHIQFBASEQDIcCC0HEASEQDJ8CCwJAIAcgAkcNAEHFASEQDJ8CCwJAAkAgBy0AAEF2ag4EAc4BzgEAzgELIAdBAWohBgyNAQsgB0EBaiEFDIkBCwJAIAcgAkcNAEHGASEQDJ4CCwJAAkAgBy0AAEF2ag4XAY8BjwEBjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BAI8BCyAHQQFqIQcLQbABIRAMhAILAkAgCCACRw0AQcgBIRAMnQILIAgtAABBIEcNjQEgAEEAOwEyIAhBAWohAUGzASEQDIMCCyABIRcCQANAIBciByACRg0BIActAABBUGpB/wFxIhBBCk8NzAECQCAALwEyIhRBmTNLDQAgACAUQQpsIhQ7ATIgEEH//wNzIBRB/v8DcUkNACAHQQFqIRcgACAUIBBqIhA7ATIgEEH//wNxQegHSQ0BCwtBACEQIABBADYCHCAAQcGJgIAANgIQIABBDTYCDCAAIAdBAWo2AhQMnAILQccBIRAMmwILIAAgCCACEK6AgIAAIhBFDcoBIBBBFUcNjAEgAEHIATYCHCAAIAg2AhQgAEHJl4CAADYCECAAQRU2AgxBACEQDJoCCwJAIAkgAkcNAEHMASEQDJoCC0EAIRRBASEXQQEhFkEAIRACQAJAAkACQAJAAkACQAJAAkAgCS0AAEFQag4KlgGVAQABAgMEBQYIlwELQQIhEAwGC0EDIRAMBQtBBCEQDAQLQQUhEAwDC0EGIRAMAgtBByEQDAELQQghEAtBACEXQQAhFkEAIRQMjgELQQkhEEEBIRRBACEXQQAhFgyNAQsCQCAKIAJHDQBBzgEhEAyZAgsgCi0AAEEuRw2OASAKQQFqIQkMygELIAsgAkcNjgFB0AEhEAyXAgsCQCALIAJGDQAgAEGOgICAADYCCCAAIAs2AgRBtwEhEAz+AQtB0QEhEAyWAgsCQCAEIAJHDQBB0gEhEAyWAgsgAiAEayAAKAIAIhBqIRQgBCAQa0EEaiELA0AgBC0AACAQQfzPgIAAai0AAEcNjgEgEEEERg3pASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHSASEQDJUCCyAAIAwgAhCsgICAACIBDY0BIAwhAQy4AQsCQCAEIAJHDQBB1AEhEAyUAgsgAiAEayAAKAIAIhBqIRQgBCAQa0EBaiEMA0AgBC0AACAQQYHQgIAAai0AAEcNjwEgEEEBRg2OASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHUASEQDJMCCwJAIAQgAkcNAEHWASEQDJMCCyACIARrIAAoAgAiEGohFCAEIBBrQQJqIQsDQCAELQAAIBBBg9CAgABqLQAARw2OASAQQQJGDZABIBBBAWohECAEQQFqIgQgAkcNAAsgACAUNgIAQdYBIRAMkgILAkAgBCACRw0AQdcBIRAMkgILAkACQCAELQAAQbt/ag4QAI8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwEBjwELIARBAWohBEG7ASEQDPkBCyAEQQFqIQRBvAEhEAz4AQsCQCAEIAJHDQBB2AEhEAyRAgsgBC0AAEHIAEcNjAEgBEEBaiEEDMQBCwJAIAQgAkYNACAAQZCAgIAANgIIIAAgBDYCBEG+ASEQDPcBC0HZASEQDI8CCwJAIAQgAkcNAEHaASEQDI8CCyAELQAAQcgARg3DASAAQQE6ACgMuQELIABBAjoALyAAIAQgAhCmgICAACIQDY0BQcIBIRAM9AELIAAtAChBf2oOArcBuQG4AQsDQAJAIAQtAABBdmoOBACOAY4BAI4BCyAEQQFqIgQgAkcNAAtB3QEhEAyLAgsgAEEAOgAvIAAtAC1BBHFFDYQCCyAAQQA6AC8gAEEBOgA0IAEhAQyMAQsgEEEVRg3aASAAQQA2AhwgACABNgIUIABBp46AgAA2AhAgAEESNgIMQQAhEAyIAgsCQCAAIBAgAhC0gICAACIEDQAgECEBDIECCwJAIARBFUcNACAAQQM2AhwgACAQNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAyIAgsgAEEANgIcIAAgEDYCFCAAQaeOgIAANgIQIABBEjYCDEEAIRAMhwILIBBBFUYN1gEgAEEANgIcIAAgATYCFCAAQdqNgIAANgIQIABBFDYCDEEAIRAMhgILIAAoAgQhFyAAQQA2AgQgECARp2oiFiEBIAAgFyAQIBYgFBsiEBC1gICAACIURQ2NASAAQQc2AhwgACAQNgIUIAAgFDYCDEEAIRAMhQILIAAgAC8BMEGAAXI7ATAgASEBC0EqIRAM6gELIBBBFUYN0QEgAEEANgIcIAAgATYCFCAAQYOMgIAANgIQIABBEzYCDEEAIRAMggILIBBBFUYNzwEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAMgQILIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDI0BCyAAQQw2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAMgAILIBBBFUYNzAEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAM/wELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDIwBCyAAQQ02AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM/gELIBBBFUYNyQEgAEEANgIcIAAgATYCFCAAQcaMgIAANgIQIABBIzYCDEEAIRAM/QELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC5gICAACIQDQAgAUEBaiEBDIsBCyAAQQ42AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM/AELIABBADYCHCAAIAE2AhQgAEHAlYCAADYCECAAQQI2AgxBACEQDPsBCyAQQRVGDcUBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAAQSM2AgxBACEQDPoBCyAAQRA2AhwgACABNgIUIAAgEDYCDEEAIRAM+QELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC5gICAACIEDQAgAUEBaiEBDPEBCyAAQRE2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM+AELIBBBFUYNwQEgAEEANgIcIAAgATYCFCAAQcaMgIAANgIQIABBIzYCDEEAIRAM9wELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC5gICAACIQDQAgAUEBaiEBDIgBCyAAQRM2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM9gELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC5gICAACIEDQAgAUEBaiEBDO0BCyAAQRQ2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM9QELIBBBFUYNvQEgAEEANgIcIAAgATYCFCAAQZqPgIAANgIQIABBIjYCDEEAIRAM9AELIAAoAgQhECAAQQA2AgQCQCAAIBAgARC3gICAACIQDQAgAUEBaiEBDIYBCyAAQRY2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAM8wELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARC3gICAACIEDQAgAUEBaiEBDOkBCyAAQRc2AhwgACAENgIMIAAgAUEBajYCFEEAIRAM8gELIABBADYCHCAAIAE2AhQgAEHNk4CAADYCECAAQQw2AgxBACEQDPEBC0IBIRELIBBBAWohAQJAIAApAyAiEkL//////////w9WDQAgACASQgSGIBGENwMgIAEhAQyEAQsgAEEANgIcIAAgATYCFCAAQa2JgIAANgIQIABBDDYCDEEAIRAM7wELIABBADYCHCAAIBA2AhQgAEHNk4CAADYCECAAQQw2AgxBACEQDO4BCyAAKAIEIRcgAEEANgIEIBAgEadqIhYhASAAIBcgECAWIBQbIhAQtYCAgAAiFEUNcyAAQQU2AhwgACAQNgIUIAAgFDYCDEEAIRAM7QELIABBADYCHCAAIBA2AhQgAEGqnICAADYCECAAQQ82AgxBACEQDOwBCyAAIBAgAhC0gICAACIBDQEgECEBC0EOIRAM0QELAkAgAUEVRw0AIABBAjYCHCAAIBA2AhQgAEGwmICAADYCECAAQRU2AgxBACEQDOoBCyAAQQA2AhwgACAQNgIUIABBp46AgAA2AhAgAEESNgIMQQAhEAzpAQsgAUEBaiEQAkAgAC8BMCIBQYABcUUNAAJAIAAgECACELuAgIAAIgENACAQIQEMcAsgAUEVRw26ASAAQQU2AhwgACAQNgIUIABB+ZeAgAA2AhAgAEEVNgIMQQAhEAzpAQsCQCABQaAEcUGgBEcNACAALQAtQQJxDQAgAEEANgIcIAAgEDYCFCAAQZaTgIAANgIQIABBBDYCDEEAIRAM6QELIAAgECACEL2AgIAAGiAQIQECQAJAAkACQAJAIAAgECACELOAgIAADhYCAQAEBAQEBAQEBAQEBAQEBAQEBAQDBAsgAEEBOgAuCyAAIAAvATBBwAByOwEwIBAhAQtBJiEQDNEBCyAAQSM2AhwgACAQNgIUIABBpZaAgAA2AhAgAEEVNgIMQQAhEAzpAQsgAEEANgIcIAAgEDYCFCAAQdWLgIAANgIQIABBETYCDEEAIRAM6AELIAAtAC1BAXFFDQFBwwEhEAzOAQsCQCANIAJGDQADQAJAIA0tAABBIEYNACANIQEMxAELIA1BAWoiDSACRw0AC0ElIRAM5wELQSUhEAzmAQsgACgCBCEEIABBADYCBCAAIAQgDRCvgICAACIERQ2tASAAQSY2AhwgACAENgIMIAAgDUEBajYCFEEAIRAM5QELIBBBFUYNqwEgAEEANgIcIAAgATYCFCAAQf2NgIAANgIQIABBHTYCDEEAIRAM5AELIABBJzYCHCAAIAE2AhQgACAQNgIMQQAhEAzjAQsgECEBQQEhFAJAAkACQAJAAkACQAJAIAAtACxBfmoOBwYFBQMBAgAFCyAAIAAvATBBCHI7ATAMAwtBAiEUDAELQQQhFAsgAEEBOgAsIAAgAC8BMCAUcjsBMAsgECEBC0ErIRAMygELIABBADYCHCAAIBA2AhQgAEGrkoCAADYCECAAQQs2AgxBACEQDOIBCyAAQQA2AhwgACABNgIUIABB4Y+AgAA2AhAgAEEKNgIMQQAhEAzhAQsgAEEAOgAsIBAhAQy9AQsgECEBQQEhFAJAAkACQAJAAkAgAC0ALEF7ag4EAwECAAULIAAgAC8BMEEIcjsBMAwDC0ECIRQMAQtBBCEUCyAAQQE6ACwgACAALwEwIBRyOwEwCyAQIQELQSkhEAzFAQsgAEEANgIcIAAgATYCFCAAQfCUgIAANgIQIABBAzYCDEEAIRAM3QELAkAgDi0AAEENRw0AIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDkEBaiEBDHULIABBLDYCHCAAIAE2AgwgACAOQQFqNgIUQQAhEAzdAQsgAC0ALUEBcUUNAUHEASEQDMMBCwJAIA4gAkcNAEEtIRAM3AELAkACQANAAkAgDi0AAEF2ag4EAgAAAwALIA5BAWoiDiACRw0AC0EtIRAM3QELIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDiEBDHQLIABBLDYCHCAAIA42AhQgACABNgIMQQAhEAzcAQsgACgCBCEBIABBADYCBAJAIAAgASAOELGAgIAAIgENACAOQQFqIQEMcwsgAEEsNgIcIAAgATYCDCAAIA5BAWo2AhRBACEQDNsBCyAAKAIEIQQgAEEANgIEIAAgBCAOELGAgIAAIgQNoAEgDiEBDM4BCyAQQSxHDQEgAUEBaiEQQQEhAQJAAkACQAJAAkAgAC0ALEF7ag4EAwECBAALIBAhAQwEC0ECIQEMAQtBBCEBCyAAQQE6ACwgACAALwEwIAFyOwEwIBAhAQwBCyAAIAAvATBBCHI7ATAgECEBC0E5IRAMvwELIABBADoALCABIQELQTQhEAy9AQsgACAALwEwQSByOwEwIAEhAQwCCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQsYCAgAAiBA0AIAEhAQzHAQsgAEE3NgIcIAAgATYCFCAAIAQ2AgxBACEQDNQBCyAAQQg6ACwgASEBC0EwIRAMuQELAkAgAC0AKEEBRg0AIAEhAQwECyAALQAtQQhxRQ2TASABIQEMAwsgAC0AMEEgcQ2UAUHFASEQDLcBCwJAIA8gAkYNAAJAA0ACQCAPLQAAQVBqIgFB/wFxQQpJDQAgDyEBQTUhEAy6AQsgACkDICIRQpmz5syZs+bMGVYNASAAIBFCCn4iETcDICARIAGtQv8BgyISQn+FVg0BIAAgESASfDcDICAPQQFqIg8gAkcNAAtBOSEQDNEBCyAAKAIEIQIgAEEANgIEIAAgAiAPQQFqIgQQsYCAgAAiAg2VASAEIQEMwwELQTkhEAzPAQsCQCAALwEwIgFBCHFFDQAgAC0AKEEBRw0AIAAtAC1BCHFFDZABCyAAIAFB9/sDcUGABHI7ATAgDyEBC0E3IRAMtAELIAAgAC8BMEEQcjsBMAyrAQsgEEEVRg2LASAAQQA2AhwgACABNgIUIABB8I6AgAA2AhAgAEEcNgIMQQAhEAzLAQsgAEHDADYCHCAAIAE2AgwgACANQQFqNgIUQQAhEAzKAQsCQCABLQAAQTpHDQAgACgCBCEQIABBADYCBAJAIAAgECABEK+AgIAAIhANACABQQFqIQEMYwsgAEHDADYCHCAAIBA2AgwgACABQQFqNgIUQQAhEAzKAQsgAEEANgIcIAAgATYCFCAAQbGRgIAANgIQIABBCjYCDEEAIRAMyQELIABBADYCHCAAIAE2AhQgAEGgmYCAADYCECAAQR42AgxBACEQDMgBCyAAQQA2AgALIABBgBI7ASogACAXQQFqIgEgAhCogICAACIQDQEgASEBC0HHACEQDKwBCyAQQRVHDYMBIABB0QA2AhwgACABNgIUIABB45eAgAA2AhAgAEEVNgIMQQAhEAzEAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMXgsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAzDAQsgAEEANgIcIAAgFDYCFCAAQcGogIAANgIQIABBBzYCDCAAQQA2AgBBACEQDMIBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxdCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDMEBC0EAIRAgAEEANgIcIAAgATYCFCAAQYCRgIAANgIQIABBCTYCDAzAAQsgEEEVRg19IABBADYCHCAAIAE2AhQgAEGUjYCAADYCECAAQSE2AgxBACEQDL8BC0EBIRZBACEXQQAhFEEBIRALIAAgEDoAKyABQQFqIQECQAJAIAAtAC1BEHENAAJAAkACQCAALQAqDgMBAAIECyAWRQ0DDAILIBQNAQwCCyAXRQ0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQrYCAgAAiEA0AIAEhAQxcCyAAQdgANgIcIAAgATYCFCAAIBA2AgxBACEQDL4BCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQrYCAgAAiBA0AIAEhAQytAQsgAEHZADYCHCAAIAE2AhQgACAENgIMQQAhEAy9AQsgACgCBCEEIABBADYCBAJAIAAgBCABEK2AgIAAIgQNACABIQEMqwELIABB2gA2AhwgACABNgIUIAAgBDYCDEEAIRAMvAELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKkBCyAAQdwANgIcIAAgATYCFCAAIAQ2AgxBACEQDLsBCwJAIAEtAABBUGoiEEH/AXFBCk8NACAAIBA6ACogAUEBaiEBQc8AIRAMogELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKcBCyAAQd4ANgIcIAAgATYCFCAAIAQ2AgxBACEQDLoBCyAAQQA2AgAgF0EBaiEBAkAgAC0AKUEjTw0AIAEhAQxZCyAAQQA2AhwgACABNgIUIABB04mAgAA2AhAgAEEINgIMQQAhEAy5AQsgAEEANgIAC0EAIRAgAEEANgIcIAAgATYCFCAAQZCzgIAANgIQIABBCDYCDAy3AQsgAEEANgIAIBdBAWohAQJAIAAtAClBIUcNACABIQEMVgsgAEEANgIcIAAgATYCFCAAQZuKgIAANgIQIABBCDYCDEEAIRAMtgELIABBADYCACAXQQFqIQECQCAALQApIhBBXWpBC08NACABIQEMVQsCQCAQQQZLDQBBASAQdEHKAHFFDQAgASEBDFULQQAhECAAQQA2AhwgACABNgIUIABB94mAgAA2AhAgAEEINgIMDLUBCyAQQRVGDXEgAEEANgIcIAAgATYCFCAAQbmNgIAANgIQIABBGjYCDEEAIRAMtAELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDFQLIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMswELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDE0LIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMsgELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDE0LIABB0wA2AhwgACABNgIUIAAgEDYCDEEAIRAMsQELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDFELIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMsAELIABBADYCHCAAIAE2AhQgAEHGioCAADYCECAAQQc2AgxBACEQDK8BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxJCyAAQdIANgIcIAAgATYCFCAAIBA2AgxBACEQDK4BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxJCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDK0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxNCyAAQeUANgIcIAAgATYCFCAAIBA2AgxBACEQDKwBCyAAQQA2AhwgACABNgIUIABB3IiAgAA2AhAgAEEHNgIMQQAhEAyrAQsgEEE/Rw0BIAFBAWohAQtBBSEQDJABC0EAIRAgAEEANgIcIAAgATYCFCAAQf2SgIAANgIQIABBBzYCDAyoAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMQgsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAynAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMQgsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAymAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMRgsgAEHlADYCHCAAIAE2AhQgACAQNgIMQQAhEAylAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMPwsgAEHSADYCHCAAIBQ2AhQgACABNgIMQQAhEAykAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMPwsgAEHTADYCHCAAIBQ2AhQgACABNgIMQQAhEAyjAQsgACgCBCEBIABBADYCBAJAIAAgASAUEKeAgIAAIgENACAUIQEMQwsgAEHlADYCHCAAIBQ2AhQgACABNgIMQQAhEAyiAQsgAEEANgIcIAAgFDYCFCAAQcOPgIAANgIQIABBBzYCDEEAIRAMoQELIABBADYCHCAAIAE2AhQgAEHDj4CAADYCECAAQQc2AgxBACEQDKABC0EAIRAgAEEANgIcIAAgFDYCFCAAQYycgIAANgIQIABBBzYCDAyfAQsgAEEANgIcIAAgFDYCFCAAQYycgIAANgIQIABBBzYCDEEAIRAMngELIABBADYCHCAAIBQ2AhQgAEH+kYCAADYCECAAQQc2AgxBACEQDJ0BCyAAQQA2AhwgACABNgIUIABBjpuAgAA2AhAgAEEGNgIMQQAhEAycAQsgEEEVRg1XIABBADYCHCAAIAE2AhQgAEHMjoCAADYCECAAQSA2AgxBACEQDJsBCyAAQQA2AgAgEEEBaiEBQSQhEAsgACAQOgApIAAoAgQhECAAQQA2AgQgACAQIAEQq4CAgAAiEA1UIAEhAQw+CyAAQQA2AgALQQAhECAAQQA2AhwgACAENgIUIABB8ZuAgAA2AhAgAEEGNgIMDJcBCyABQRVGDVAgAEEANgIcIAAgBTYCFCAAQfCMgIAANgIQIABBGzYCDEEAIRAMlgELIAAoAgQhBSAAQQA2AgQgACAFIBAQqYCAgAAiBQ0BIBBBAWohBQtBrQEhEAx7CyAAQcEBNgIcIAAgBTYCDCAAIBBBAWo2AhRBACEQDJMBCyAAKAIEIQYgAEEANgIEIAAgBiAQEKmAgIAAIgYNASAQQQFqIQYLQa4BIRAMeAsgAEHCATYCHCAAIAY2AgwgACAQQQFqNgIUQQAhEAyQAQsgAEEANgIcIAAgBzYCFCAAQZeLgIAANgIQIABBDTYCDEEAIRAMjwELIABBADYCHCAAIAg2AhQgAEHjkICAADYCECAAQQk2AgxBACEQDI4BCyAAQQA2AhwgACAINgIUIABBlI2AgAA2AhAgAEEhNgIMQQAhEAyNAQtBASEWQQAhF0EAIRRBASEQCyAAIBA6ACsgCUEBaiEIAkACQCAALQAtQRBxDQACQAJAAkAgAC0AKg4DAQACBAsgFkUNAwwCCyAUDQEMAgsgF0UNAQsgACgCBCEQIABBADYCBCAAIBAgCBCtgICAACIQRQ09IABByQE2AhwgACAINgIUIAAgEDYCDEEAIRAMjAELIAAoAgQhBCAAQQA2AgQgACAEIAgQrYCAgAAiBEUNdiAAQcoBNgIcIAAgCDYCFCAAIAQ2AgxBACEQDIsBCyAAKAIEIQQgAEEANgIEIAAgBCAJEK2AgIAAIgRFDXQgAEHLATYCHCAAIAk2AhQgACAENgIMQQAhEAyKAQsgACgCBCEEIABBADYCBCAAIAQgChCtgICAACIERQ1yIABBzQE2AhwgACAKNgIUIAAgBDYCDEEAIRAMiQELAkAgCy0AAEFQaiIQQf8BcUEKTw0AIAAgEDoAKiALQQFqIQpBtgEhEAxwCyAAKAIEIQQgAEEANgIEIAAgBCALEK2AgIAAIgRFDXAgAEHPATYCHCAAIAs2AhQgACAENgIMQQAhEAyIAQsgAEEANgIcIAAgBDYCFCAAQZCzgIAANgIQIABBCDYCDCAAQQA2AgBBACEQDIcBCyABQRVGDT8gAEEANgIcIAAgDDYCFCAAQcyOgIAANgIQIABBIDYCDEEAIRAMhgELIABBgQQ7ASggACgCBCEQIABCADcDACAAIBAgDEEBaiIMEKuAgIAAIhBFDTggAEHTATYCHCAAIAw2AhQgACAQNgIMQQAhEAyFAQsgAEEANgIAC0EAIRAgAEEANgIcIAAgBDYCFCAAQdibgIAANgIQIABBCDYCDAyDAQsgACgCBCEQIABCADcDACAAIBAgC0EBaiILEKuAgIAAIhANAUHGASEQDGkLIABBAjoAKAxVCyAAQdUBNgIcIAAgCzYCFCAAIBA2AgxBACEQDIABCyAQQRVGDTcgAEEANgIcIAAgBDYCFCAAQaSMgIAANgIQIABBEDYCDEEAIRAMfwsgAC0ANEEBRw00IAAgBCACELyAgIAAIhBFDTQgEEEVRw01IABB3AE2AhwgACAENgIUIABB1ZaAgAA2AhAgAEEVNgIMQQAhEAx+C0EAIRAgAEEANgIcIABBr4uAgAA2AhAgAEECNgIMIAAgFEEBajYCFAx9C0EAIRAMYwtBAiEQDGILQQ0hEAxhC0EPIRAMYAtBJSEQDF8LQRMhEAxeC0EVIRAMXQtBFiEQDFwLQRchEAxbC0EYIRAMWgtBGSEQDFkLQRohEAxYC0EbIRAMVwtBHCEQDFYLQR0hEAxVC0EfIRAMVAtBISEQDFMLQSMhEAxSC0HGACEQDFELQS4hEAxQC0EvIRAMTwtBOyEQDE4LQT0hEAxNC0HIACEQDEwLQckAIRAMSwtBywAhEAxKC0HMACEQDEkLQc4AIRAMSAtB0QAhEAxHC0HVACEQDEYLQdgAIRAMRQtB2QAhEAxEC0HbACEQDEMLQeQAIRAMQgtB5QAhEAxBC0HxACEQDEALQfQAIRAMPwtBjQEhEAw+C0GXASEQDD0LQakBIRAMPAtBrAEhEAw7C0HAASEQDDoLQbkBIRAMOQtBrwEhEAw4C0GxASEQDDcLQbIBIRAMNgtBtAEhEAw1C0G1ASEQDDQLQboBIRAMMwtBvQEhEAwyC0G/ASEQDDELQcEBIRAMMAsgAEEANgIcIAAgBDYCFCAAQemLgIAANgIQIABBHzYCDEEAIRAMSAsgAEHbATYCHCAAIAQ2AhQgAEH6loCAADYCECAAQRU2AgxBACEQDEcLIABB+AA2AhwgACAMNgIUIABBypiAgAA2AhAgAEEVNgIMQQAhEAxGCyAAQdEANgIcIAAgBTYCFCAAQbCXgIAANgIQIABBFTYCDEEAIRAMRQsgAEH5ADYCHCAAIAE2AhQgACAQNgIMQQAhEAxECyAAQfgANgIcIAAgATYCFCAAQcqYgIAANgIQIABBFTYCDEEAIRAMQwsgAEHkADYCHCAAIAE2AhQgAEHjl4CAADYCECAAQRU2AgxBACEQDEILIABB1wA2AhwgACABNgIUIABByZeAgAA2AhAgAEEVNgIMQQAhEAxBCyAAQQA2AhwgACABNgIUIABBuY2AgAA2AhAgAEEaNgIMQQAhEAxACyAAQcIANgIcIAAgATYCFCAAQeOYgIAANgIQIABBFTYCDEEAIRAMPwsgAEEANgIEIAAgDyAPELGAgIAAIgRFDQEgAEE6NgIcIAAgBDYCDCAAIA9BAWo2AhRBACEQDD4LIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCxgICAACIERQ0AIABBOzYCHCAAIAQ2AgwgACABQQFqNgIUQQAhEAw+CyABQQFqIQEMLQsgD0EBaiEBDC0LIABBADYCHCAAIA82AhQgAEHkkoCAADYCECAAQQQ2AgxBACEQDDsLIABBNjYCHCAAIAQ2AhQgACACNgIMQQAhEAw6CyAAQS42AhwgACAONgIUIAAgBDYCDEEAIRAMOQsgAEHQADYCHCAAIAE2AhQgAEGRmICAADYCECAAQRU2AgxBACEQDDgLIA1BAWohAQwsCyAAQRU2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAw2CyAAQRs2AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAw1CyAAQQ82AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAw0CyAAQQs2AhwgACABNgIUIABBkZeAgAA2AhAgAEEVNgIMQQAhEAwzCyAAQRo2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAwyCyAAQQs2AhwgACABNgIUIABBgpmAgAA2AhAgAEEVNgIMQQAhEAwxCyAAQQo2AhwgACABNgIUIABB5JaAgAA2AhAgAEEVNgIMQQAhEAwwCyAAQR42AhwgACABNgIUIABB+ZeAgAA2AhAgAEEVNgIMQQAhEAwvCyAAQQA2AhwgACAQNgIUIABB2o2AgAA2AhAgAEEUNgIMQQAhEAwuCyAAQQQ2AhwgACABNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAwtCyAAQQA2AgAgC0EBaiELC0G4ASEQDBILIABBADYCACAQQQFqIQFB9QAhEAwRCyABIQECQCAALQApQQVHDQBB4wAhEAwRC0HiACEQDBALQQAhECAAQQA2AhwgAEHkkYCAADYCECAAQQc2AgwgACAUQQFqNgIUDCgLIABBADYCACAXQQFqIQFBwAAhEAwOC0EBIQELIAAgAToALCAAQQA2AgAgF0EBaiEBC0EoIRAMCwsgASEBC0E4IRAMCQsCQCABIg8gAkYNAANAAkAgDy0AAEGAvoCAAGotAAAiAUEBRg0AIAFBAkcNAyAPQQFqIQEMBAsgD0EBaiIPIAJHDQALQT4hEAwiC0E+IRAMIQsgAEEAOgAsIA8hAQwBC0ELIRAMBgtBOiEQDAULIAFBAWohAUEtIRAMBAsgACABOgAsIABBADYCACAWQQFqIQFBDCEQDAMLIABBADYCACAXQQFqIQFBCiEQDAILIABBADYCAAsgAEEAOgAsIA0hAUEJIRAMAAsLQQAhECAAQQA2AhwgACALNgIUIABBzZCAgAA2AhAgAEEJNgIMDBcLQQAhECAAQQA2AhwgACAKNgIUIABB6YqAgAA2AhAgAEEJNgIMDBYLQQAhECAAQQA2AhwgACAJNgIUIABBt5CAgAA2AhAgAEEJNgIMDBULQQAhECAAQQA2AhwgACAINgIUIABBnJGAgAA2AhAgAEEJNgIMDBQLQQAhECAAQQA2AhwgACABNgIUIABBzZCAgAA2AhAgAEEJNgIMDBMLQQAhECAAQQA2AhwgACABNgIUIABB6YqAgAA2AhAgAEEJNgIMDBILQQAhECAAQQA2AhwgACABNgIUIABBt5CAgAA2AhAgAEEJNgIMDBELQQAhECAAQQA2AhwgACABNgIUIABBnJGAgAA2AhAgAEEJNgIMDBALQQAhECAAQQA2AhwgACABNgIUIABBl5WAgAA2AhAgAEEPNgIMDA8LQQAhECAAQQA2AhwgACABNgIUIABBl5WAgAA2AhAgAEEPNgIMDA4LQQAhECAAQQA2AhwgACABNgIUIABBwJKAgAA2AhAgAEELNgIMDA0LQQAhECAAQQA2AhwgACABNgIUIABBlYmAgAA2AhAgAEELNgIMDAwLQQAhECAAQQA2AhwgACABNgIUIABB4Y+AgAA2AhAgAEEKNgIMDAsLQQAhECAAQQA2AhwgACABNgIUIABB+4+AgAA2AhAgAEEKNgIMDAoLQQAhECAAQQA2AhwgACABNgIUIABB8ZmAgAA2AhAgAEECNgIMDAkLQQAhECAAQQA2AhwgACABNgIUIABBxJSAgAA2AhAgAEECNgIMDAgLQQAhECAAQQA2AhwgACABNgIUIABB8pWAgAA2AhAgAEECNgIMDAcLIABBAjYCHCAAIAE2AhQgAEGcmoCAADYCECAAQRY2AgxBACEQDAYLQQEhEAwFC0HUACEQIAEiBCACRg0EIANBCGogACAEIAJB2MKAgABBChDFgICAACADKAIMIQQgAygCCA4DAQQCAAsQyoCAgAAACyAAQQA2AhwgAEG1moCAADYCECAAQRc2AgwgACAEQQFqNgIUQQAhEAwCCyAAQQA2AhwgACAENgIUIABBypqAgAA2AhAgAEEJNgIMQQAhEAwBCwJAIAEiBCACRw0AQSIhEAwBCyAAQYmAgIAANgIIIAAgBDYCBEEhIRALIANBEGokgICAgAAgEAuvAQECfyABKAIAIQYCQAJAIAIgA0YNACAEIAZqIQQgBiADaiACayEHIAIgBkF/cyAFaiIGaiEFA0ACQCACLQAAIAQtAABGDQBBAiEEDAMLAkAgBg0AQQAhBCAFIQIMAwsgBkF/aiEGIARBAWohBCACQQFqIgIgA0cNAAsgByEGIAMhAgsgAEEBNgIAIAEgBjYCACAAIAI2AgQPCyABQQA2AgAgACAENgIAIAAgAjYCBAsKACAAEMeAgIAAC/I2AQt/I4CAgIAAQRBrIgEkgICAgAACQEEAKAKg0ICAAA0AQQAQy4CAgABBgNSEgABrIgJB2QBJDQBBACEDAkBBACgC4NOAgAAiBA0AQQBCfzcC7NOAgABBAEKAgISAgIDAADcC5NOAgABBACABQQhqQXBxQdiq1aoFcyIENgLg04CAAEEAQQA2AvTTgIAAQQBBADYCxNOAgAALQQAgAjYCzNOAgABBAEGA1ISAADYCyNOAgABBAEGA1ISAADYCmNCAgABBACAENgKs0ICAAEEAQX82AqjQgIAAA0AgA0HE0ICAAGogA0G40ICAAGoiBDYCACAEIANBsNCAgABqIgU2AgAgA0G80ICAAGogBTYCACADQczQgIAAaiADQcDQgIAAaiIFNgIAIAUgBDYCACADQdTQgIAAaiADQcjQgIAAaiIENgIAIAQgBTYCACADQdDQgIAAaiAENgIAIANBIGoiA0GAAkcNAAtBgNSEgABBeEGA1ISAAGtBD3FBAEGA1ISAAEEIakEPcRsiA2oiBEEEaiACQUhqIgUgA2siA0EBcjYCAEEAQQAoAvDTgIAANgKk0ICAAEEAIAM2ApTQgIAAQQAgBDYCoNCAgABBgNSEgAAgBWpBODYCBAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEHsAUsNAAJAQQAoAojQgIAAIgZBECAAQRNqQXBxIABBC0kbIgJBA3YiBHYiA0EDcUUNAAJAAkAgA0EBcSAEckEBcyIFQQN0IgRBsNCAgABqIgMgBEG40ICAAGooAgAiBCgCCCICRw0AQQAgBkF+IAV3cTYCiNCAgAAMAQsgAyACNgIIIAIgAzYCDAsgBEEIaiEDIAQgBUEDdCIFQQNyNgIEIAQgBWoiBCAEKAIEQQFyNgIEDAwLIAJBACgCkNCAgAAiB00NAQJAIANFDQACQAJAIAMgBHRBAiAEdCIDQQAgA2tycSIDQQAgA2txQX9qIgMgA0EMdkEQcSIDdiIEQQV2QQhxIgUgA3IgBCAFdiIDQQJ2QQRxIgRyIAMgBHYiA0EBdkECcSIEciADIAR2IgNBAXZBAXEiBHIgAyAEdmoiBEEDdCIDQbDQgIAAaiIFIANBuNCAgABqKAIAIgMoAggiAEcNAEEAIAZBfiAEd3EiBjYCiNCAgAAMAQsgBSAANgIIIAAgBTYCDAsgAyACQQNyNgIEIAMgBEEDdCIEaiAEIAJrIgU2AgAgAyACaiIAIAVBAXI2AgQCQCAHRQ0AIAdBeHFBsNCAgABqIQJBACgCnNCAgAAhBAJAAkAgBkEBIAdBA3Z0IghxDQBBACAGIAhyNgKI0ICAACACIQgMAQsgAigCCCEICyAIIAQ2AgwgAiAENgIIIAQgAjYCDCAEIAg2AggLIANBCGohA0EAIAA2ApzQgIAAQQAgBTYCkNCAgAAMDAtBACgCjNCAgAAiCUUNASAJQQAgCWtxQX9qIgMgA0EMdkEQcSIDdiIEQQV2QQhxIgUgA3IgBCAFdiIDQQJ2QQRxIgRyIAMgBHYiA0EBdkECcSIEciADIAR2IgNBAXZBAXEiBHIgAyAEdmpBAnRBuNKAgABqKAIAIgAoAgRBeHEgAmshBCAAIQUCQANAAkAgBSgCECIDDQAgBUEUaigCACIDRQ0CCyADKAIEQXhxIAJrIgUgBCAFIARJIgUbIQQgAyAAIAUbIQAgAyEFDAALCyAAKAIYIQoCQCAAKAIMIgggAEYNACAAKAIIIgNBACgCmNCAgABJGiAIIAM2AgggAyAINgIMDAsLAkAgAEEUaiIFKAIAIgMNACAAKAIQIgNFDQMgAEEQaiEFCwNAIAUhCyADIghBFGoiBSgCACIDDQAgCEEQaiEFIAgoAhAiAw0ACyALQQA2AgAMCgtBfyECIABBv39LDQAgAEETaiIDQXBxIQJBACgCjNCAgAAiB0UNAEEAIQsCQCACQYACSQ0AQR8hCyACQf///wdLDQAgA0EIdiIDIANBgP4/akEQdkEIcSIDdCIEIARBgOAfakEQdkEEcSIEdCIFIAVBgIAPakEQdkECcSIFdEEPdiADIARyIAVyayIDQQF0IAIgA0EVanZBAXFyQRxqIQsLQQAgAmshBAJAAkACQAJAIAtBAnRBuNKAgABqKAIAIgUNAEEAIQNBACEIDAELQQAhAyACQQBBGSALQQF2ayALQR9GG3QhAEEAIQgDQAJAIAUoAgRBeHEgAmsiBiAETw0AIAYhBCAFIQggBg0AQQAhBCAFIQggBSEDDAMLIAMgBUEUaigCACIGIAYgBSAAQR12QQRxakEQaigCACIFRhsgAyAGGyEDIABBAXQhACAFDQALCwJAIAMgCHINAEEAIQhBAiALdCIDQQAgA2tyIAdxIgNFDQMgA0EAIANrcUF/aiIDIANBDHZBEHEiA3YiBUEFdkEIcSIAIANyIAUgAHYiA0ECdkEEcSIFciADIAV2IgNBAXZBAnEiBXIgAyAFdiIDQQF2QQFxIgVyIAMgBXZqQQJ0QbjSgIAAaigCACEDCyADRQ0BCwNAIAMoAgRBeHEgAmsiBiAESSEAAkAgAygCECIFDQAgA0EUaigCACEFCyAGIAQgABshBCADIAggABshCCAFIQMgBQ0ACwsgCEUNACAEQQAoApDQgIAAIAJrTw0AIAgoAhghCwJAIAgoAgwiACAIRg0AIAgoAggiA0EAKAKY0ICAAEkaIAAgAzYCCCADIAA2AgwMCQsCQCAIQRRqIgUoAgAiAw0AIAgoAhAiA0UNAyAIQRBqIQULA0AgBSEGIAMiAEEUaiIFKAIAIgMNACAAQRBqIQUgACgCECIDDQALIAZBADYCAAwICwJAQQAoApDQgIAAIgMgAkkNAEEAKAKc0ICAACEEAkACQCADIAJrIgVBEEkNACAEIAJqIgAgBUEBcjYCBEEAIAU2ApDQgIAAQQAgADYCnNCAgAAgBCADaiAFNgIAIAQgAkEDcjYCBAwBCyAEIANBA3I2AgQgBCADaiIDIAMoAgRBAXI2AgRBAEEANgKc0ICAAEEAQQA2ApDQgIAACyAEQQhqIQMMCgsCQEEAKAKU0ICAACIAIAJNDQBBACgCoNCAgAAiAyACaiIEIAAgAmsiBUEBcjYCBEEAIAU2ApTQgIAAQQAgBDYCoNCAgAAgAyACQQNyNgIEIANBCGohAwwKCwJAAkBBACgC4NOAgABFDQBBACgC6NOAgAAhBAwBC0EAQn83AuzTgIAAQQBCgICEgICAwAA3AuTTgIAAQQAgAUEMakFwcUHYqtWqBXM2AuDTgIAAQQBBADYC9NOAgABBAEEANgLE04CAAEGAgAQhBAtBACEDAkAgBCACQccAaiIHaiIGQQAgBGsiC3EiCCACSw0AQQBBMDYC+NOAgAAMCgsCQEEAKALA04CAACIDRQ0AAkBBACgCuNOAgAAiBCAIaiIFIARNDQAgBSADTQ0BC0EAIQNBAEEwNgL404CAAAwKC0EALQDE04CAAEEEcQ0EAkACQAJAQQAoAqDQgIAAIgRFDQBByNOAgAAhAwNAAkAgAygCACIFIARLDQAgBSADKAIEaiAESw0DCyADKAIIIgMNAAsLQQAQy4CAgAAiAEF/Rg0FIAghBgJAQQAoAuTTgIAAIgNBf2oiBCAAcUUNACAIIABrIAQgAGpBACADa3FqIQYLIAYgAk0NBSAGQf7///8HSw0FAkBBACgCwNOAgAAiA0UNAEEAKAK404CAACIEIAZqIgUgBE0NBiAFIANLDQYLIAYQy4CAgAAiAyAARw0BDAcLIAYgAGsgC3EiBkH+////B0sNBCAGEMuAgIAAIgAgAygCACADKAIEakYNAyAAIQMLAkAgA0F/Rg0AIAJByABqIAZNDQACQCAHIAZrQQAoAujTgIAAIgRqQQAgBGtxIgRB/v///wdNDQAgAyEADAcLAkAgBBDLgICAAEF/Rg0AIAQgBmohBiADIQAMBwtBACAGaxDLgICAABoMBAsgAyEAIANBf0cNBQwDC0EAIQgMBwtBACEADAULIABBf0cNAgtBAEEAKALE04CAAEEEcjYCxNOAgAALIAhB/v///wdLDQEgCBDLgICAACEAQQAQy4CAgAAhAyAAQX9GDQEgA0F/Rg0BIAAgA08NASADIABrIgYgAkE4ak0NAQtBAEEAKAK404CAACAGaiIDNgK404CAAAJAIANBACgCvNOAgABNDQBBACADNgK804CAAAsCQAJAAkACQEEAKAKg0ICAACIERQ0AQcjTgIAAIQMDQCAAIAMoAgAiBSADKAIEIghqRg0CIAMoAggiAw0ADAMLCwJAAkBBACgCmNCAgAAiA0UNACAAIANPDQELQQAgADYCmNCAgAALQQAhA0EAIAY2AszTgIAAQQAgADYCyNOAgABBAEF/NgKo0ICAAEEAQQAoAuDTgIAANgKs0ICAAEEAQQA2AtTTgIAAA0AgA0HE0ICAAGogA0G40ICAAGoiBDYCACAEIANBsNCAgABqIgU2AgAgA0G80ICAAGogBTYCACADQczQgIAAaiADQcDQgIAAaiIFNgIAIAUgBDYCACADQdTQgIAAaiADQcjQgIAAaiIENgIAIAQgBTYCACADQdDQgIAAaiAENgIAIANBIGoiA0GAAkcNAAsgAEF4IABrQQ9xQQAgAEEIakEPcRsiA2oiBCAGQUhqIgUgA2siA0EBcjYCBEEAQQAoAvDTgIAANgKk0ICAAEEAIAM2ApTQgIAAQQAgBDYCoNCAgAAgACAFakE4NgIEDAILIAMtAAxBCHENACAEIAVJDQAgBCAATw0AIARBeCAEa0EPcUEAIARBCGpBD3EbIgVqIgBBACgClNCAgAAgBmoiCyAFayIFQQFyNgIEIAMgCCAGajYCBEEAQQAoAvDTgIAANgKk0ICAAEEAIAU2ApTQgIAAQQAgADYCoNCAgAAgBCALakE4NgIEDAELAkAgAEEAKAKY0ICAACIITw0AQQAgADYCmNCAgAAgACEICyAAIAZqIQVByNOAgAAhAwJAAkACQAJAAkACQAJAA0AgAygCACAFRg0BIAMoAggiAw0ADAILCyADLQAMQQhxRQ0BC0HI04CAACEDA0ACQCADKAIAIgUgBEsNACAFIAMoAgRqIgUgBEsNAwsgAygCCCEDDAALCyADIAA2AgAgAyADKAIEIAZqNgIEIABBeCAAa0EPcUEAIABBCGpBD3EbaiILIAJBA3I2AgQgBUF4IAVrQQ9xQQAgBUEIakEPcRtqIgYgCyACaiICayEDAkAgBiAERw0AQQAgAjYCoNCAgABBAEEAKAKU0ICAACADaiIDNgKU0ICAACACIANBAXI2AgQMAwsCQCAGQQAoApzQgIAARw0AQQAgAjYCnNCAgABBAEEAKAKQ0ICAACADaiIDNgKQ0ICAACACIANBAXI2AgQgAiADaiADNgIADAMLAkAgBigCBCIEQQNxQQFHDQAgBEF4cSEHAkACQCAEQf8BSw0AIAYoAggiBSAEQQN2IghBA3RBsNCAgABqIgBGGgJAIAYoAgwiBCAFRw0AQQBBACgCiNCAgABBfiAId3E2AojQgIAADAILIAQgAEYaIAQgBTYCCCAFIAQ2AgwMAQsgBigCGCEJAkACQCAGKAIMIgAgBkYNACAGKAIIIgQgCEkaIAAgBDYCCCAEIAA2AgwMAQsCQCAGQRRqIgQoAgAiBQ0AIAZBEGoiBCgCACIFDQBBACEADAELA0AgBCEIIAUiAEEUaiIEKAIAIgUNACAAQRBqIQQgACgCECIFDQALIAhBADYCAAsgCUUNAAJAAkAgBiAGKAIcIgVBAnRBuNKAgABqIgQoAgBHDQAgBCAANgIAIAANAUEAQQAoAozQgIAAQX4gBXdxNgKM0ICAAAwCCyAJQRBBFCAJKAIQIAZGG2ogADYCACAARQ0BCyAAIAk2AhgCQCAGKAIQIgRFDQAgACAENgIQIAQgADYCGAsgBigCFCIERQ0AIABBFGogBDYCACAEIAA2AhgLIAcgA2ohAyAGIAdqIgYoAgQhBAsgBiAEQX5xNgIEIAIgA2ogAzYCACACIANBAXI2AgQCQCADQf8BSw0AIANBeHFBsNCAgABqIQQCQAJAQQAoAojQgIAAIgVBASADQQN2dCIDcQ0AQQAgBSADcjYCiNCAgAAgBCEDDAELIAQoAgghAwsgAyACNgIMIAQgAjYCCCACIAQ2AgwgAiADNgIIDAMLQR8hBAJAIANB////B0sNACADQQh2IgQgBEGA/j9qQRB2QQhxIgR0IgUgBUGA4B9qQRB2QQRxIgV0IgAgAEGAgA9qQRB2QQJxIgB0QQ92IAQgBXIgAHJrIgRBAXQgAyAEQRVqdkEBcXJBHGohBAsgAiAENgIcIAJCADcCECAEQQJ0QbjSgIAAaiEFAkBBACgCjNCAgAAiAEEBIAR0IghxDQAgBSACNgIAQQAgACAIcjYCjNCAgAAgAiAFNgIYIAIgAjYCCCACIAI2AgwMAwsgA0EAQRkgBEEBdmsgBEEfRht0IQQgBSgCACEAA0AgACIFKAIEQXhxIANGDQIgBEEddiEAIARBAXQhBCAFIABBBHFqQRBqIggoAgAiAA0ACyAIIAI2AgAgAiAFNgIYIAIgAjYCDCACIAI2AggMAgsgAEF4IABrQQ9xQQAgAEEIakEPcRsiA2oiCyAGQUhqIgggA2siA0EBcjYCBCAAIAhqQTg2AgQgBCAFQTcgBWtBD3FBACAFQUlqQQ9xG2pBQWoiCCAIIARBEGpJGyIIQSM2AgRBAEEAKALw04CAADYCpNCAgABBACADNgKU0ICAAEEAIAs2AqDQgIAAIAhBEGpBACkC0NOAgAA3AgAgCEEAKQLI04CAADcCCEEAIAhBCGo2AtDTgIAAQQAgBjYCzNOAgABBACAANgLI04CAAEEAQQA2AtTTgIAAIAhBJGohAwNAIANBBzYCACADQQRqIgMgBUkNAAsgCCAERg0DIAggCCgCBEF+cTYCBCAIIAggBGsiADYCACAEIABBAXI2AgQCQCAAQf8BSw0AIABBeHFBsNCAgABqIQMCQAJAQQAoAojQgIAAIgVBASAAQQN2dCIAcQ0AQQAgBSAAcjYCiNCAgAAgAyEFDAELIAMoAgghBQsgBSAENgIMIAMgBDYCCCAEIAM2AgwgBCAFNgIIDAQLQR8hAwJAIABB////B0sNACAAQQh2IgMgA0GA/j9qQRB2QQhxIgN0IgUgBUGA4B9qQRB2QQRxIgV0IgggCEGAgA9qQRB2QQJxIgh0QQ92IAMgBXIgCHJrIgNBAXQgACADQRVqdkEBcXJBHGohAwsgBCADNgIcIARCADcCECADQQJ0QbjSgIAAaiEFAkBBACgCjNCAgAAiCEEBIAN0IgZxDQAgBSAENgIAQQAgCCAGcjYCjNCAgAAgBCAFNgIYIAQgBDYCCCAEIAQ2AgwMBAsgAEEAQRkgA0EBdmsgA0EfRht0IQMgBSgCACEIA0AgCCIFKAIEQXhxIABGDQMgA0EddiEIIANBAXQhAyAFIAhBBHFqQRBqIgYoAgAiCA0ACyAGIAQ2AgAgBCAFNgIYIAQgBDYCDCAEIAQ2AggMAwsgBSgCCCIDIAI2AgwgBSACNgIIIAJBADYCGCACIAU2AgwgAiADNgIICyALQQhqIQMMBQsgBSgCCCIDIAQ2AgwgBSAENgIIIARBADYCGCAEIAU2AgwgBCADNgIIC0EAKAKU0ICAACIDIAJNDQBBACgCoNCAgAAiBCACaiIFIAMgAmsiA0EBcjYCBEEAIAM2ApTQgIAAQQAgBTYCoNCAgAAgBCACQQNyNgIEIARBCGohAwwDC0EAIQNBAEEwNgL404CAAAwCCwJAIAtFDQACQAJAIAggCCgCHCIFQQJ0QbjSgIAAaiIDKAIARw0AIAMgADYCACAADQFBACAHQX4gBXdxIgc2AozQgIAADAILIAtBEEEUIAsoAhAgCEYbaiAANgIAIABFDQELIAAgCzYCGAJAIAgoAhAiA0UNACAAIAM2AhAgAyAANgIYCyAIQRRqKAIAIgNFDQAgAEEUaiADNgIAIAMgADYCGAsCQAJAIARBD0sNACAIIAQgAmoiA0EDcjYCBCAIIANqIgMgAygCBEEBcjYCBAwBCyAIIAJqIgAgBEEBcjYCBCAIIAJBA3I2AgQgACAEaiAENgIAAkAgBEH/AUsNACAEQXhxQbDQgIAAaiEDAkACQEEAKAKI0ICAACIFQQEgBEEDdnQiBHENAEEAIAUgBHI2AojQgIAAIAMhBAwBCyADKAIIIQQLIAQgADYCDCADIAA2AgggACADNgIMIAAgBDYCCAwBC0EfIQMCQCAEQf///wdLDQAgBEEIdiIDIANBgP4/akEQdkEIcSIDdCIFIAVBgOAfakEQdkEEcSIFdCICIAJBgIAPakEQdkECcSICdEEPdiADIAVyIAJyayIDQQF0IAQgA0EVanZBAXFyQRxqIQMLIAAgAzYCHCAAQgA3AhAgA0ECdEG40oCAAGohBQJAIAdBASADdCICcQ0AIAUgADYCAEEAIAcgAnI2AozQgIAAIAAgBTYCGCAAIAA2AgggACAANgIMDAELIARBAEEZIANBAXZrIANBH0YbdCEDIAUoAgAhAgJAA0AgAiIFKAIEQXhxIARGDQEgA0EddiECIANBAXQhAyAFIAJBBHFqQRBqIgYoAgAiAg0ACyAGIAA2AgAgACAFNgIYIAAgADYCDCAAIAA2AggMAQsgBSgCCCIDIAA2AgwgBSAANgIIIABBADYCGCAAIAU2AgwgACADNgIICyAIQQhqIQMMAQsCQCAKRQ0AAkACQCAAIAAoAhwiBUECdEG40oCAAGoiAygCAEcNACADIAg2AgAgCA0BQQAgCUF+IAV3cTYCjNCAgAAMAgsgCkEQQRQgCigCECAARhtqIAg2AgAgCEUNAQsgCCAKNgIYAkAgACgCECIDRQ0AIAggAzYCECADIAg2AhgLIABBFGooAgAiA0UNACAIQRRqIAM2AgAgAyAINgIYCwJAAkAgBEEPSw0AIAAgBCACaiIDQQNyNgIEIAAgA2oiAyADKAIEQQFyNgIEDAELIAAgAmoiBSAEQQFyNgIEIAAgAkEDcjYCBCAFIARqIAQ2AgACQCAHRQ0AIAdBeHFBsNCAgABqIQJBACgCnNCAgAAhAwJAAkBBASAHQQN2dCIIIAZxDQBBACAIIAZyNgKI0ICAACACIQgMAQsgAigCCCEICyAIIAM2AgwgAiADNgIIIAMgAjYCDCADIAg2AggLQQAgBTYCnNCAgABBACAENgKQ0ICAAAsgAEEIaiEDCyABQRBqJICAgIAAIAMLCgAgABDJgICAAAviDQEHfwJAIABFDQAgAEF4aiIBIABBfGooAgAiAkF4cSIAaiEDAkAgAkEBcQ0AIAJBA3FFDQEgASABKAIAIgJrIgFBACgCmNCAgAAiBEkNASACIABqIQACQCABQQAoApzQgIAARg0AAkAgAkH/AUsNACABKAIIIgQgAkEDdiIFQQN0QbDQgIAAaiIGRhoCQCABKAIMIgIgBEcNAEEAQQAoAojQgIAAQX4gBXdxNgKI0ICAAAwDCyACIAZGGiACIAQ2AgggBCACNgIMDAILIAEoAhghBwJAAkAgASgCDCIGIAFGDQAgASgCCCICIARJGiAGIAI2AgggAiAGNgIMDAELAkAgAUEUaiICKAIAIgQNACABQRBqIgIoAgAiBA0AQQAhBgwBCwNAIAIhBSAEIgZBFGoiAigCACIEDQAgBkEQaiECIAYoAhAiBA0ACyAFQQA2AgALIAdFDQECQAJAIAEgASgCHCIEQQJ0QbjSgIAAaiICKAIARw0AIAIgBjYCACAGDQFBAEEAKAKM0ICAAEF+IAR3cTYCjNCAgAAMAwsgB0EQQRQgBygCECABRhtqIAY2AgAgBkUNAgsgBiAHNgIYAkAgASgCECICRQ0AIAYgAjYCECACIAY2AhgLIAEoAhQiAkUNASAGQRRqIAI2AgAgAiAGNgIYDAELIAMoAgQiAkEDcUEDRw0AIAMgAkF+cTYCBEEAIAA2ApDQgIAAIAEgAGogADYCACABIABBAXI2AgQPCyABIANPDQAgAygCBCICQQFxRQ0AAkACQCACQQJxDQACQCADQQAoAqDQgIAARw0AQQAgATYCoNCAgABBAEEAKAKU0ICAACAAaiIANgKU0ICAACABIABBAXI2AgQgAUEAKAKc0ICAAEcNA0EAQQA2ApDQgIAAQQBBADYCnNCAgAAPCwJAIANBACgCnNCAgABHDQBBACABNgKc0ICAAEEAQQAoApDQgIAAIABqIgA2ApDQgIAAIAEgAEEBcjYCBCABIABqIAA2AgAPCyACQXhxIABqIQACQAJAIAJB/wFLDQAgAygCCCIEIAJBA3YiBUEDdEGw0ICAAGoiBkYaAkAgAygCDCICIARHDQBBAEEAKAKI0ICAAEF+IAV3cTYCiNCAgAAMAgsgAiAGRhogAiAENgIIIAQgAjYCDAwBCyADKAIYIQcCQAJAIAMoAgwiBiADRg0AIAMoAggiAkEAKAKY0ICAAEkaIAYgAjYCCCACIAY2AgwMAQsCQCADQRRqIgIoAgAiBA0AIANBEGoiAigCACIEDQBBACEGDAELA0AgAiEFIAQiBkEUaiICKAIAIgQNACAGQRBqIQIgBigCECIEDQALIAVBADYCAAsgB0UNAAJAAkAgAyADKAIcIgRBAnRBuNKAgABqIgIoAgBHDQAgAiAGNgIAIAYNAUEAQQAoAozQgIAAQX4gBHdxNgKM0ICAAAwCCyAHQRBBFCAHKAIQIANGG2ogBjYCACAGRQ0BCyAGIAc2AhgCQCADKAIQIgJFDQAgBiACNgIQIAIgBjYCGAsgAygCFCICRQ0AIAZBFGogAjYCACACIAY2AhgLIAEgAGogADYCACABIABBAXI2AgQgAUEAKAKc0ICAAEcNAUEAIAA2ApDQgIAADwsgAyACQX5xNgIEIAEgAGogADYCACABIABBAXI2AgQLAkAgAEH/AUsNACAAQXhxQbDQgIAAaiECAkACQEEAKAKI0ICAACIEQQEgAEEDdnQiAHENAEEAIAQgAHI2AojQgIAAIAIhAAwBCyACKAIIIQALIAAgATYCDCACIAE2AgggASACNgIMIAEgADYCCA8LQR8hAgJAIABB////B0sNACAAQQh2IgIgAkGA/j9qQRB2QQhxIgJ0IgQgBEGA4B9qQRB2QQRxIgR0IgYgBkGAgA9qQRB2QQJxIgZ0QQ92IAIgBHIgBnJrIgJBAXQgACACQRVqdkEBcXJBHGohAgsgASACNgIcIAFCADcCECACQQJ0QbjSgIAAaiEEAkACQEEAKAKM0ICAACIGQQEgAnQiA3ENACAEIAE2AgBBACAGIANyNgKM0ICAACABIAQ2AhggASABNgIIIAEgATYCDAwBCyAAQQBBGSACQQF2ayACQR9GG3QhAiAEKAIAIQYCQANAIAYiBCgCBEF4cSAARg0BIAJBHXYhBiACQQF0IQIgBCAGQQRxakEQaiIDKAIAIgYNAAsgAyABNgIAIAEgBDYCGCABIAE2AgwgASABNgIIDAELIAQoAggiACABNgIMIAQgATYCCCABQQA2AhggASAENgIMIAEgADYCCAtBAEEAKAKo0ICAAEF/aiIBQX8gARs2AqjQgIAACwsEAAAAC04AAkAgAA0APwBBEHQPCwJAIABB//8DcQ0AIABBf0wNAAJAIABBEHZAACIAQX9HDQBBAEEwNgL404CAAEF/DwsgAEEQdA8LEMqAgIAAAAvyAgIDfwF+AkAgAkUNACAAIAE6AAAgAiAAaiIDQX9qIAE6AAAgAkEDSQ0AIAAgAToAAiAAIAE6AAEgA0F9aiABOgAAIANBfmogAToAACACQQdJDQAgACABOgADIANBfGogAToAACACQQlJDQAgAEEAIABrQQNxIgRqIgMgAUH/AXFBgYKECGwiATYCACADIAIgBGtBfHEiBGoiAkF8aiABNgIAIARBCUkNACADIAE2AgggAyABNgIEIAJBeGogATYCACACQXRqIAE2AgAgBEEZSQ0AIAMgATYCGCADIAE2AhQgAyABNgIQIAMgATYCDCACQXBqIAE2AgAgAkFsaiABNgIAIAJBaGogATYCACACQWRqIAE2AgAgBCADQQRxQRhyIgVrIgJBIEkNACABrUKBgICAEH4hBiADIAVqIQEDQCABIAY3AxggASAGNwMQIAEgBjcDCCABIAY3AwAgAUEgaiEBIAJBYGoiAkEfSw0ACwsgAAsLjkgBAEGACAuGSAEAAAACAAAAAwAAAAAAAAAAAAAABAAAAAUAAAAAAAAAAAAAAAYAAAAHAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASW52YWxpZCBjaGFyIGluIHVybCBxdWVyeQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2JvZHkAQ29udGVudC1MZW5ndGggb3ZlcmZsb3cAQ2h1bmsgc2l6ZSBvdmVyZmxvdwBSZXNwb25zZSBvdmVyZmxvdwBJbnZhbGlkIG1ldGhvZCBmb3IgSFRUUC94LnggcmVxdWVzdABJbnZhbGlkIG1ldGhvZCBmb3IgUlRTUC94LnggcmVxdWVzdABFeHBlY3RlZCBTT1VSQ0UgbWV0aG9kIGZvciBJQ0UveC54IHJlcXVlc3QASW52YWxpZCBjaGFyIGluIHVybCBmcmFnbWVudCBzdGFydABFeHBlY3RlZCBkb3QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9zdGF0dXMASW52YWxpZCByZXNwb25zZSBzdGF0dXMASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucwBVc2VyIGNhbGxiYWNrIGVycm9yAGBvbl9yZXNldGAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2hlYWRlcmAgY2FsbGJhY2sgZXJyb3IAYG9uX21lc3NhZ2VfYmVnaW5gIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19leHRlbnNpb25fdmFsdWVgIGNhbGxiYWNrIGVycm9yAGBvbl9zdGF0dXNfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl92ZXJzaW9uX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fdXJsX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fbWV0aG9kX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX25hbWVgIGNhbGxiYWNrIGVycm9yAFVuZXhwZWN0ZWQgY2hhciBpbiB1cmwgc2VydmVyAEludmFsaWQgaGVhZGVyIHZhbHVlIGNoYXIASW52YWxpZCBoZWFkZXIgZmllbGQgY2hhcgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3ZlcnNpb24ASW52YWxpZCBtaW5vciB2ZXJzaW9uAEludmFsaWQgbWFqb3IgdmVyc2lvbgBFeHBlY3RlZCBzcGFjZSBhZnRlciB2ZXJzaW9uAEV4cGVjdGVkIENSTEYgYWZ0ZXIgdmVyc2lvbgBJbnZhbGlkIEhUVFAgdmVyc2lvbgBJbnZhbGlkIGhlYWRlciB0b2tlbgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3VybABJbnZhbGlkIGNoYXJhY3RlcnMgaW4gdXJsAFVuZXhwZWN0ZWQgc3RhcnQgY2hhciBpbiB1cmwARG91YmxlIEAgaW4gdXJsAEVtcHR5IENvbnRlbnQtTGVuZ3RoAEludmFsaWQgY2hhcmFjdGVyIGluIENvbnRlbnQtTGVuZ3RoAER1cGxpY2F0ZSBDb250ZW50LUxlbmd0aABJbnZhbGlkIGNoYXIgaW4gdXJsIHBhdGgAQ29udGVudC1MZW5ndGggY2FuJ3QgYmUgcHJlc2VudCB3aXRoIFRyYW5zZmVyLUVuY29kaW5nAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIHNpemUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfdmFsdWUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9jaHVua19leHRlbnNpb25fdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyB2YWx1ZQBNaXNzaW5nIGV4cGVjdGVkIExGIGFmdGVyIGhlYWRlciB2YWx1ZQBJbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AgaGVhZGVyIHZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGUgdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBxdW90ZWQgdmFsdWUAUGF1c2VkIGJ5IG9uX2hlYWRlcnNfY29tcGxldGUASW52YWxpZCBFT0Ygc3RhdGUAb25fcmVzZXQgcGF1c2UAb25fY2h1bmtfaGVhZGVyIHBhdXNlAG9uX21lc3NhZ2VfYmVnaW4gcGF1c2UAb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlIHBhdXNlAG9uX3N0YXR1c19jb21wbGV0ZSBwYXVzZQBvbl92ZXJzaW9uX2NvbXBsZXRlIHBhdXNlAG9uX3VybF9jb21wbGV0ZSBwYXVzZQBvbl9jaHVua19jb21wbGV0ZSBwYXVzZQBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGUgcGF1c2UAb25fbWVzc2FnZV9jb21wbGV0ZSBwYXVzZQBvbl9tZXRob2RfY29tcGxldGUgcGF1c2UAb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlIHBhdXNlAG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lIHBhdXNlAFVuZXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgc3RhcnQgbGluZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgbmFtZQBQYXVzZSBvbiBDT05ORUNUL1VwZ3JhZGUAUGF1c2Ugb24gUFJJL1VwZ3JhZGUARXhwZWN0ZWQgSFRUUC8yIENvbm5lY3Rpb24gUHJlZmFjZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX21ldGhvZABFeHBlY3RlZCBzcGFjZSBhZnRlciBtZXRob2QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfZmllbGQAUGF1c2VkAEludmFsaWQgd29yZCBlbmNvdW50ZXJlZABJbnZhbGlkIG1ldGhvZCBlbmNvdW50ZXJlZABVbmV4cGVjdGVkIGNoYXIgaW4gdXJsIHNjaGVtYQBSZXF1ZXN0IGhhcyBpbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AAU1dJVENIX1BST1hZAFVTRV9QUk9YWQBNS0FDVElWSVRZAFVOUFJPQ0VTU0FCTEVfRU5USVRZAENPUFkATU9WRURfUEVSTUFORU5UTFkAVE9PX0VBUkxZAE5PVElGWQBGQUlMRURfREVQRU5ERU5DWQBCQURfR0FURVdBWQBQTEFZAFBVVABDSEVDS09VVABHQVRFV0FZX1RJTUVPVVQAUkVRVUVTVF9USU1FT1VUAE5FVFdPUktfQ09OTkVDVF9USU1FT1VUAENPTk5FQ1RJT05fVElNRU9VVABMT0dJTl9USU1FT1VUAE5FVFdPUktfUkVBRF9USU1FT1VUAFBPU1QATUlTRElSRUNURURfUkVRVUVTVABDTElFTlRfQ0xPU0VEX1JFUVVFU1QAQ0xJRU5UX0NMT1NFRF9MT0FEX0JBTEFOQ0VEX1JFUVVFU1QAQkFEX1JFUVVFU1QASFRUUF9SRVFVRVNUX1NFTlRfVE9fSFRUUFNfUE9SVABSRVBPUlQASU1fQV9URUFQT1QAUkVTRVRfQ09OVEVOVABOT19DT05URU5UAFBBUlRJQUxfQ09OVEVOVABIUEVfSU5WQUxJRF9DT05TVEFOVABIUEVfQ0JfUkVTRVQAR0VUAEhQRV9TVFJJQ1QAQ09ORkxJQ1QAVEVNUE9SQVJZX1JFRElSRUNUAFBFUk1BTkVOVF9SRURJUkVDVABDT05ORUNUAE1VTFRJX1NUQVRVUwBIUEVfSU5WQUxJRF9TVEFUVVMAVE9PX01BTllfUkVRVUVTVFMARUFSTFlfSElOVFMAVU5BVkFJTEFCTEVfRk9SX0xFR0FMX1JFQVNPTlMAT1BUSU9OUwBTV0lUQ0hJTkdfUFJPVE9DT0xTAFZBUklBTlRfQUxTT19ORUdPVElBVEVTAE1VTFRJUExFX0NIT0lDRVMASU5URVJOQUxfU0VSVkVSX0VSUk9SAFdFQl9TRVJWRVJfVU5LTk9XTl9FUlJPUgBSQUlMR1VOX0VSUk9SAElERU5USVRZX1BST1ZJREVSX0FVVEhFTlRJQ0FUSU9OX0VSUk9SAFNTTF9DRVJUSUZJQ0FURV9FUlJPUgBJTlZBTElEX1hfRk9SV0FSREVEX0ZPUgBTRVRfUEFSQU1FVEVSAEdFVF9QQVJBTUVURVIASFBFX1VTRVIAU0VFX09USEVSAEhQRV9DQl9DSFVOS19IRUFERVIATUtDQUxFTkRBUgBTRVRVUABXRUJfU0VSVkVSX0lTX0RPV04AVEVBUkRPV04ASFBFX0NMT1NFRF9DT05ORUNUSU9OAEhFVVJJU1RJQ19FWFBJUkFUSU9OAERJU0NPTk5FQ1RFRF9PUEVSQVRJT04ATk9OX0FVVEhPUklUQVRJVkVfSU5GT1JNQVRJT04ASFBFX0lOVkFMSURfVkVSU0lPTgBIUEVfQ0JfTUVTU0FHRV9CRUdJTgBTSVRFX0lTX0ZST1pFTgBIUEVfSU5WQUxJRF9IRUFERVJfVE9LRU4ASU5WQUxJRF9UT0tFTgBGT1JCSURERU4ARU5IQU5DRV9ZT1VSX0NBTE0ASFBFX0lOVkFMSURfVVJMAEJMT0NLRURfQllfUEFSRU5UQUxfQ09OVFJPTABNS0NPTABBQ0wASFBFX0lOVEVSTkFMAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0VfVU5PRkZJQ0lBTABIUEVfT0sAVU5MSU5LAFVOTE9DSwBQUkkAUkVUUllfV0lUSABIUEVfSU5WQUxJRF9DT05URU5UX0xFTkdUSABIUEVfVU5FWFBFQ1RFRF9DT05URU5UX0xFTkdUSABGTFVTSABQUk9QUEFUQ0gATS1TRUFSQ0gAVVJJX1RPT19MT05HAFBST0NFU1NJTkcATUlTQ0VMTEFORU9VU19QRVJTSVNURU5UX1dBUk5JTkcATUlTQ0VMTEFORU9VU19XQVJOSU5HAEhQRV9JTlZBTElEX1RSQU5TRkVSX0VOQ09ESU5HAEV4cGVjdGVkIENSTEYASFBFX0lOVkFMSURfQ0hVTktfU0laRQBNT1ZFAENPTlRJTlVFAEhQRV9DQl9TVEFUVVNfQ09NUExFVEUASFBFX0NCX0hFQURFUlNfQ09NUExFVEUASFBFX0NCX1ZFUlNJT05fQ09NUExFVEUASFBFX0NCX1VSTF9DT01QTEVURQBIUEVfQ0JfQ0hVTktfQ09NUExFVEUASFBFX0NCX0hFQURFUl9WQUxVRV9DT01QTEVURQBIUEVfQ0JfQ0hVTktfRVhURU5TSU9OX1ZBTFVFX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19FWFRFTlNJT05fTkFNRV9DT01QTEVURQBIUEVfQ0JfTUVTU0FHRV9DT01QTEVURQBIUEVfQ0JfTUVUSE9EX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJfRklFTERfQ09NUExFVEUAREVMRVRFAEhQRV9JTlZBTElEX0VPRl9TVEFURQBJTlZBTElEX1NTTF9DRVJUSUZJQ0FURQBQQVVTRQBOT19SRVNQT05TRQBVTlNVUFBPUlRFRF9NRURJQV9UWVBFAEdPTkUATk9UX0FDQ0VQVEFCTEUAU0VSVklDRV9VTkFWQUlMQUJMRQBSQU5HRV9OT1RfU0FUSVNGSUFCTEUAT1JJR0lOX0lTX1VOUkVBQ0hBQkxFAFJFU1BPTlNFX0lTX1NUQUxFAFBVUkdFAE1FUkdFAFJFUVVFU1RfSEVBREVSX0ZJRUxEU19UT09fTEFSR0UAUkVRVUVTVF9IRUFERVJfVE9PX0xBUkdFAFBBWUxPQURfVE9PX0xBUkdFAElOU1VGRklDSUVOVF9TVE9SQUdFAEhQRV9QQVVTRURfVVBHUkFERQBIUEVfUEFVU0VEX0gyX1VQR1JBREUAU09VUkNFAEFOTk9VTkNFAFRSQUNFAEhQRV9VTkVYUEVDVEVEX1NQQUNFAERFU0NSSUJFAFVOU1VCU0NSSUJFAFJFQ09SRABIUEVfSU5WQUxJRF9NRVRIT0QATk9UX0ZPVU5EAFBST1BGSU5EAFVOQklORABSRUJJTkQAVU5BVVRIT1JJWkVEAE1FVEhPRF9OT1RfQUxMT1dFRABIVFRQX1ZFUlNJT05fTk9UX1NVUFBPUlRFRABBTFJFQURZX1JFUE9SVEVEAEFDQ0VQVEVEAE5PVF9JTVBMRU1FTlRFRABMT09QX0RFVEVDVEVEAEhQRV9DUl9FWFBFQ1RFRABIUEVfTEZfRVhQRUNURUQAQ1JFQVRFRABJTV9VU0VEAEhQRV9QQVVTRUQAVElNRU9VVF9PQ0NVUkVEAFBBWU1FTlRfUkVRVUlSRUQAUFJFQ09ORElUSU9OX1JFUVVJUkVEAFBST1hZX0FVVEhFTlRJQ0FUSU9OX1JFUVVJUkVEAE5FVFdPUktfQVVUSEVOVElDQVRJT05fUkVRVUlSRUQATEVOR1RIX1JFUVVJUkVEAFNTTF9DRVJUSUZJQ0FURV9SRVFVSVJFRABVUEdSQURFX1JFUVVJUkVEAFBBR0VfRVhQSVJFRABQUkVDT05ESVRJT05fRkFJTEVEAEVYUEVDVEFUSU9OX0ZBSUxFRABSRVZBTElEQVRJT05fRkFJTEVEAFNTTF9IQU5EU0hBS0VfRkFJTEVEAExPQ0tFRABUUkFOU0ZPUk1BVElPTl9BUFBMSUVEAE5PVF9NT0RJRklFRABOT1RfRVhURU5ERUQAQkFORFdJRFRIX0xJTUlUX0VYQ0VFREVEAFNJVEVfSVNfT1ZFUkxPQURFRABIRUFEAEV4cGVjdGVkIEhUVFAvAABeEwAAJhMAADAQAADwFwAAnRMAABUSAAA5FwAA8BIAAAoQAAB1EgAArRIAAIITAABPFAAAfxAAAKAVAAAjFAAAiRIAAIsUAABNFQAA1BEAAM8UAAAQGAAAyRYAANwWAADBEQAA4BcAALsUAAB0FAAAfBUAAOUUAAAIFwAAHxAAAGUVAACjFAAAKBUAAAIVAACZFQAALBAAAIsZAABPDwAA1A4AAGoQAADOEAAAAhcAAIkOAABuEwAAHBMAAGYUAABWFwAAwRMAAM0TAABsEwAAaBcAAGYXAABfFwAAIhMAAM4PAABpDgAA2A4AAGMWAADLEwAAqg4AACgXAAAmFwAAxRMAAF0WAADoEQAAZxMAAGUTAADyFgAAcxMAAB0XAAD5FgAA8xEAAM8OAADOFQAADBIAALMRAAClEQAAYRAAADIXAAC7EwAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAgMCAgICAgAAAgIAAgIAAgICAgICAgICAgAEAAAAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAgICAAIAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIAAgICAgIAAAICAAICAAICAgICAgICAgIAAwAEAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgACAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsb3NlZWVwLWFsaXZlAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEBAQEBAQEBAgEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFjaHVua2VkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQABAQEBAQAAAQEAAQEAAQEBAQEBAQEBAQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGVjdGlvbmVudC1sZW5ndGhvbnJveHktY29ubmVjdGlvbgAAAAAAAAAAAAAAAAAAAHJhbnNmZXItZW5jb2RpbmdwZ3JhZGUNCg0KDQpTTQ0KDQpUVFAvQ0UvVFNQLwAAAAAAAAAAAAAAAAECAAEDAAAAAAAAAAAAAAAAAAAAAAAABAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAABAgABAwAAAAAAAAAAAAAAAAAAAAAAAAQBAQUBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAQAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAABAAACAAAAAAAAAAAAAAAAAAAAAAAAAwQAAAQEBAQEBAQEBAQEBQQEBAQEBAQEBAQEBAAEAAYHBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQABAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAEAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAgAAAAACAAAAAAAAAAAAAAAAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5PVU5DRUVDS09VVE5FQ1RFVEVDUklCRUxVU0hFVEVBRFNFQVJDSFJHRUNUSVZJVFlMRU5EQVJWRU9USUZZUFRJT05TQ0hTRUFZU1RBVENIR0VPUkRJUkVDVE9SVFJDSFBBUkFNRVRFUlVSQ0VCU0NSSUJFQVJET1dOQUNFSU5ETktDS1VCU0NSSUJFSFRUUC9BRFRQLw=="; + } +}); -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getPlatformHeaders = exports.isRunningInBrowser = void 0; -const version_1 = __nccwpck_require__(8027); -const isRunningInBrowser = () => { - return ( - // @ts-ignore - typeof window !== 'undefined' && - // @ts-ignore - typeof window.document !== 'undefined' && - // @ts-ignore - typeof navigator !== 'undefined'); -}; -exports.isRunningInBrowser = isRunningInBrowser; -/** - * Note this does not detect 'browser'; for that, use getBrowserInfo(). - */ -function getDetectedPlatform() { - if (typeof Deno !== 'undefined' && Deno.build != null) { - return 'deno'; - } - if (typeof EdgeRuntime !== 'undefined') { - return 'edge'; - } - if (Object.prototype.toString.call(typeof globalThis.process !== 'undefined' ? globalThis.process : 0) === '[object process]') { - return 'node'; - } - return 'unknown'; -} -const getPlatformProperties = () => { - const detectedPlatform = getDetectedPlatform(); - if (detectedPlatform === 'deno') { - return { - 'X-Stainless-Lang': 'js', - 'X-Stainless-Package-Version': version_1.VERSION, - 'X-Stainless-OS': normalizePlatform(Deno.build.os), - 'X-Stainless-Arch': normalizeArch(Deno.build.arch), - 'X-Stainless-Runtime': 'deno', - 'X-Stainless-Runtime-Version': typeof Deno.version === 'string' ? Deno.version : Deno.version?.deno ?? 'unknown', - }; - } - if (typeof EdgeRuntime !== 'undefined') { - return { - 'X-Stainless-Lang': 'js', - 'X-Stainless-Package-Version': version_1.VERSION, - 'X-Stainless-OS': 'Unknown', - 'X-Stainless-Arch': `other:${EdgeRuntime}`, - 'X-Stainless-Runtime': 'edge', - 'X-Stainless-Runtime-Version': globalThis.process.version, - }; - } - // Check if Node.js - if (detectedPlatform === 'node') { - return { - 'X-Stainless-Lang': 'js', - 'X-Stainless-Package-Version': version_1.VERSION, - 'X-Stainless-OS': normalizePlatform(globalThis.process.platform ?? 'unknown'), - 'X-Stainless-Arch': normalizeArch(globalThis.process.arch ?? 'unknown'), - 'X-Stainless-Runtime': 'node', - 'X-Stainless-Runtime-Version': globalThis.process.version ?? 'unknown', - }; +// node_modules/undici/lib/client.js +var require_client = __commonJS({ + "node_modules/undici/lib/client.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var net = require("net"); + var http = require("http"); + var { pipeline } = require("stream"); + var util = require_util(); + var timers = require_timers(); + var Request = require_request(); + var DispatcherBase = require_dispatcher_base(); + var { + RequestContentLengthMismatchError, + ResponseContentLengthMismatchError, + InvalidArgumentError, + RequestAbortedError, + HeadersTimeoutError, + HeadersOverflowError, + SocketError, + InformationalError, + BodyTimeoutError, + HTTPParserError, + ResponseExceededMaxSizeError, + ClientDestroyedError + } = require_errors2(); + var buildConnector = require_connect(); + var { + kUrl, + kReset, + kServerName, + kClient, + kBusy, + kParser, + kConnect, + kBlocking, + kResuming, + kRunning, + kPending, + kSize, + kWriting, + kQueue, + kConnected, + kConnecting, + kNeedDrain, + kNoRef, + kKeepAliveDefaultTimeout, + kHostHeader, + kPendingIdx, + kRunningIdx, + kError, + kPipelining, + kSocket, + kKeepAliveTimeoutValue, + kMaxHeadersSize, + kKeepAliveMaxTimeout, + kKeepAliveTimeoutThreshold, + kHeadersTimeout, + kBodyTimeout, + kStrictContentLength, + kConnector, + kMaxRedirections, + kMaxRequests, + kCounter, + kClose, + kDestroy, + kDispatch, + kInterceptors, + kLocalAddress, + kMaxResponseSize, + kHTTPConnVersion, + // HTTP2 + kHost, + kHTTP2Session, + kHTTP2SessionState, + kHTTP2BuildRequest, + kHTTP2CopyHeaders, + kHTTP1BuildRequest + } = require_symbols(); + var http2; + try { + http2 = require("http2"); + } catch { + http2 = { constants: {} }; + } + var { + constants: { + HTTP2_HEADER_AUTHORITY, + HTTP2_HEADER_METHOD, + HTTP2_HEADER_PATH, + HTTP2_HEADER_SCHEME, + HTTP2_HEADER_CONTENT_LENGTH, + HTTP2_HEADER_EXPECT, + HTTP2_HEADER_STATUS + } + } = http2; + var h2ExperimentalWarned = false; + var FastBuffer = Buffer[Symbol.species]; + var kClosedResolve = Symbol("kClosedResolve"); + var channels = {}; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders"); + channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect"); + channels.connectError = diagnosticsChannel.channel("undici:client:connectError"); + channels.connected = diagnosticsChannel.channel("undici:client:connected"); + } catch { + channels.sendHeaders = { hasSubscribers: false }; + channels.beforeConnect = { hasSubscribers: false }; + channels.connectError = { hasSubscribers: false }; + channels.connected = { hasSubscribers: false }; } - const browserInfo = getBrowserInfo(); - if (browserInfo) { - return { - 'X-Stainless-Lang': 'js', - 'X-Stainless-Package-Version': version_1.VERSION, - 'X-Stainless-OS': 'Unknown', - 'X-Stainless-Arch': 'unknown', - 'X-Stainless-Runtime': `browser:${browserInfo.browser}`, - 'X-Stainless-Runtime-Version': browserInfo.version, + var Client = class extends DispatcherBase { + /** + * + * @param {string|URL} url + * @param {import('../types/client').Client.Options} options + */ + constructor(url, { + interceptors, + maxHeaderSize, + headersTimeout, + socketTimeout, + requestTimeout, + connectTimeout, + bodyTimeout, + idleTimeout, + keepAlive, + keepAliveTimeout, + maxKeepAliveTimeout, + keepAliveMaxTimeout, + keepAliveTimeoutThreshold, + socketPath, + pipelining, + tls, + strictContentLength, + maxCachedSessions, + maxRedirections, + connect: connect2, + maxRequestsPerClient, + localAddress, + maxResponseSize, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + // h2 + allowH2, + maxConcurrentStreams + } = {}) { + super(); + if (keepAlive !== void 0) { + throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead"); + } + if (socketTimeout !== void 0) { + throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead"); + } + if (requestTimeout !== void 0) { + throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead"); + } + if (idleTimeout !== void 0) { + throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead"); + } + if (maxKeepAliveTimeout !== void 0) { + throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead"); + } + if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) { + throw new InvalidArgumentError("invalid maxHeaderSize"); + } + if (socketPath != null && typeof socketPath !== "string") { + throw new InvalidArgumentError("invalid socketPath"); + } + if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) { + throw new InvalidArgumentError("invalid connectTimeout"); + } + if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveTimeout"); + } + if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveMaxTimeout"); + } + if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) { + throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold"); + } + if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("headersTimeout must be a positive integer or zero"); + } + if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero"); + } + if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) { + throw new InvalidArgumentError("maxRequestsPerClient must be a positive number"); + } + if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) { + throw new InvalidArgumentError("localAddress must be valid string IP address"); + } + if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) { + throw new InvalidArgumentError("maxResponseSize must be a positive number"); + } + if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) { + throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number"); + } + if (allowH2 != null && typeof allowH2 !== "boolean") { + throw new InvalidArgumentError("allowH2 must be a valid boolean value"); + } + if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) { + throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0"); + } + if (typeof connect2 !== "function") { + connect2 = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect2 + }); + } + this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })]; + this[kUrl] = util.parseOrigin(url); + this[kConnector] = connect2; + this[kSocket] = null; + this[kPipelining] = pipelining != null ? pipelining : 1; + this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize; + this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout; + this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout; + this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold; + this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]; + this[kServerName] = null; + this[kLocalAddress] = localAddress != null ? localAddress : null; + this[kResuming] = 0; + this[kNeedDrain] = 0; + this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r +`; + this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5; + this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5; + this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength; + this[kMaxRedirections] = maxRedirections; + this[kMaxRequests] = maxRequestsPerClient; + this[kClosedResolve] = null; + this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1; + this[kHTTPConnVersion] = "h1"; + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = !allowH2 ? null : { + // streams: null, // Fixed queue of streams - For future support of `push` + openStreams: 0, + // Keep track of them to decide wether or not unref the session + maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100 + // Max peerConcurrentStreams for a Node h2 server }; - } - // TODO add support for Cloudflare workers, etc. - return { - 'X-Stainless-Lang': 'js', - 'X-Stainless-Package-Version': version_1.VERSION, - 'X-Stainless-OS': 'Unknown', - 'X-Stainless-Arch': 'unknown', - 'X-Stainless-Runtime': 'unknown', - 'X-Stainless-Runtime-Version': 'unknown', - }; -}; -// Note: modified from https://github.com/JS-DevTools/host-environment/blob/b1ab79ecde37db5d6e163c050e54fe7d287d7c92/src/isomorphic.browser.ts -function getBrowserInfo() { - if (typeof navigator === 'undefined' || !navigator) { - return null; - } - // NOTE: The order matters here! - const browserPatterns = [ - { key: 'edge', pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, - { key: 'ie', pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, - { key: 'ie', pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, - { key: 'chrome', pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, - { key: 'firefox', pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, - { key: 'safari', pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }, - ]; - // Find the FIRST matching browser - for (const { key, pattern } of browserPatterns) { - const match = pattern.exec(navigator.userAgent); - if (match) { - const major = match[1] || 0; - const minor = match[2] || 0; - const patch = match[3] || 0; - return { browser: key, version: `${major}.${minor}.${patch}` }; + this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`; + this[kQueue] = []; + this[kRunningIdx] = 0; + this[kPendingIdx] = 0; + } + get pipelining() { + return this[kPipelining]; + } + set pipelining(value) { + this[kPipelining] = value; + resume(this, true); + } + get [kPending]() { + return this[kQueue].length - this[kPendingIdx]; + } + get [kRunning]() { + return this[kPendingIdx] - this[kRunningIdx]; + } + get [kSize]() { + return this[kQueue].length - this[kRunningIdx]; + } + get [kConnected]() { + return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed; + } + get [kBusy]() { + const socket = this[kSocket]; + return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0; + } + /* istanbul ignore: only used for test */ + [kConnect](cb) { + connect(this); + this.once("connect", cb); + } + [kDispatch](opts, handler) { + const origin = opts.origin || this[kUrl].origin; + const request = this[kHTTPConnVersion] === "h2" ? Request[kHTTP2BuildRequest](origin, opts, handler) : Request[kHTTP1BuildRequest](origin, opts, handler); + this[kQueue].push(request); + if (this[kResuming]) { + } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) { + this[kResuming] = 1; + process.nextTick(resume, this); + } else { + resume(this, true); } - } - return null; -} -const normalizeArch = (arch) => { - // Node docs: - // - https://nodejs.org/api/process.html#processarch - // Deno docs: - // - https://doc.deno.land/deno/stable/~/Deno.build - if (arch === 'x32') - return 'x32'; - if (arch === 'x86_64' || arch === 'x64') - return 'x64'; - if (arch === 'arm') - return 'arm'; - if (arch === 'aarch64' || arch === 'arm64') - return 'arm64'; - if (arch) - return `other:${arch}`; - return 'unknown'; -}; -const normalizePlatform = (platform) => { - // Node platforms: - // - https://nodejs.org/api/process.html#processplatform - // Deno platforms: - // - https://doc.deno.land/deno/stable/~/Deno.build - // - https://github.com/denoland/deno/issues/14799 - platform = platform.toLowerCase(); - // NOTE: this iOS check is untested and may not work - // Node does not work natively on IOS, there is a fork at - // https://github.com/nodejs-mobile/nodejs-mobile - // however it is unknown at the time of writing how to detect if it is running - if (platform.includes('ios')) - return 'iOS'; - if (platform === 'android') - return 'Android'; - if (platform === 'darwin') - return 'MacOS'; - if (platform === 'win32') - return 'Windows'; - if (platform === 'freebsd') - return 'FreeBSD'; - if (platform === 'openbsd') - return 'OpenBSD'; - if (platform === 'linux') - return 'Linux'; - if (platform) - return `Other:${platform}`; - return 'Unknown'; -}; -let _platformHeaders; -const getPlatformHeaders = () => { - return (_platformHeaders ?? (_platformHeaders = getPlatformProperties())); -}; -exports.getPlatformHeaders = getPlatformHeaders; -//# sourceMappingURL=detect-platform.js.map - -/***/ }), - -/***/ 4838: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.castToError = void 0; -exports.isAbortError = isAbortError; -function isAbortError(err) { - return (typeof err === 'object' && - err !== null && - // Spec-compliant fetch implementations - (('name' in err && err.name === 'AbortError') || - // Expo fetch - ('message' in err && String(err.message).includes('FetchRequestCanceledException')))); -} -const castToError = (err) => { - if (err instanceof Error) - return err; - if (typeof err === 'object' && err !== null) { - try { - if (Object.prototype.toString.call(err) === '[object Error]') { - // @ts-ignore - not all envs have native support for cause yet - const error = new Error(err.message, err.cause ? { cause: err.cause } : {}); - if (err.stack) - error.stack = err.stack; - // @ts-ignore - not all envs have native support for cause yet - if (err.cause && !error.cause) - error.cause = err.cause; - if (err.name) - error.name = err.name; - return error; + if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) { + this[kNeedDrain] = 2; + } + return this[kNeedDrain] < 2; + } + async [kClose]() { + return new Promise((resolve) => { + if (!this[kSize]) { + resolve(null); + } else { + this[kClosedResolve] = resolve; + } + }); + } + async [kDestroy](err) { + return new Promise((resolve) => { + const requests = this[kQueue].splice(this[kPendingIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + const callback = () => { + if (this[kClosedResolve]) { + this[kClosedResolve](); + this[kClosedResolve] = null; + } + resolve(); + }; + if (this[kHTTP2Session] != null) { + util.destroy(this[kHTTP2Session], err); + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = null; + } + if (!this[kSocket]) { + queueMicrotask(callback); + } else { + util.destroy(this[kSocket].on("close", callback), err); + } + resume(this); + }); + } + }; + function onHttp2SessionError(err) { + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kSocket][kError] = err; + onError(this[kClient], err); + } + function onHttp2FrameError(type, code, id) { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + if (id === 0) { + this[kSocket][kError] = err; + onError(this[kClient], err); + } + } + function onHttp2SessionEnd() { + util.destroy(this, new SocketError("other side closed")); + util.destroy(this[kSocket], new SocketError("other side closed")); + } + function onHTTP2GoAway(code) { + const client = this[kClient]; + const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`); + client[kSocket] = null; + client[kHTTP2Session] = null; + if (client.destroyed) { + assert(this[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + } else if (client[kRunning] > 0) { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit( + "disconnect", + client[kUrl], + [client], + err + ); + resume(client); + } + var constants = require_constants3(); + var createRedirectInterceptor = require_redirectInterceptor(); + var EMPTY_BUF = Buffer.alloc(0); + async function lazyllhttp() { + const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0; + let mod; + try { + mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64")); + } catch (e) { + mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64")); + } + return await WebAssembly.instantiate(mod, { + env: { + /* eslint-disable camelcase */ + wasm_on_url: (p, at, len) => { + return 0; + }, + wasm_on_status: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_begin: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageBegin() || 0; + }, + wasm_on_header_field: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_header_value: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; + }, + wasm_on_body: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_complete: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageComplete() || 0; + } + /* eslint-enable camelcase */ + } + }); + } + var llhttpInstance = null; + var llhttpPromise = lazyllhttp(); + llhttpPromise.catch(); + var currentParser = null; + var currentBufferRef = null; + var currentBufferSize = 0; + var currentBufferPtr = null; + var TIMEOUT_HEADERS = 1; + var TIMEOUT_BODY = 2; + var TIMEOUT_IDLE = 3; + var Parser = class { + constructor(client, socket, { exports: exports3 }) { + assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); + this.llhttp = exports3; + this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE); + this.client = client; + this.socket = socket; + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.statusCode = null; + this.statusText = ""; + this.upgrade = false; + this.headers = []; + this.headersSize = 0; + this.headersMaxSize = client[kMaxHeadersSize]; + this.shouldKeepAlive = false; + this.paused = false; + this.resume = this.resume.bind(this); + this.bytesRead = 0; + this.keepAlive = ""; + this.contentLength = ""; + this.connection = ""; + this.maxResponseSize = client[kMaxResponseSize]; + } + setTimeout(value, type) { + this.timeoutType = type; + if (value !== this.timeoutValue) { + timers.clearTimeout(this.timeout); + if (value) { + this.timeout = timers.setTimeout(onParserTimeout, value, this); + if (this.timeout.unref) { + this.timeout.unref(); } + } else { + this.timeout = null; + } + this.timeoutValue = value; + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } } - catch { } - try { - return new Error(JSON.stringify(err)); + } + resume() { + if (this.socket.destroyed || !this.paused) { + return; } - catch { } - } - return new Error(err); -}; -exports.castToError = castToError; -//# sourceMappingURL=errors.js.map - -/***/ }), - -/***/ 9191: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.isEmptyHeaders = exports.buildHeaders = void 0; -const values_1 = __nccwpck_require__(5537); -const brand_privateNullableHeaders = /* @__PURE__ */ Symbol('brand.privateNullableHeaders'); -function* iterateHeaders(headers) { - if (!headers) - return; - if (brand_privateNullableHeaders in headers) { - const { values, nulls } = headers; - yield* values.entries(); - for (const name of nulls) { - yield [name, null]; + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_resume(this.ptr); + assert(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } } - return; - } - let shouldClear = false; - let iter; - if (headers instanceof Headers) { - iter = headers.entries(); - } - else if ((0, values_1.isReadonlyArray)(headers)) { - iter = headers; - } - else { - shouldClear = true; - iter = Object.entries(headers ?? {}); - } - for (let row of iter) { - const name = row[0]; - if (typeof name !== 'string') - throw new TypeError('expected header name to be a string'); - const values = (0, values_1.isReadonlyArray)(row[1]) ? row[1] : [row[1]]; - let didClear = false; - for (const value of values) { - if (value === undefined) - continue; - // Objects keys always overwrite older headers, they never append. - // Yield a null to clear the header before adding the new values. - if (shouldClear && !didClear) { - didClear = true; - yield [name, null]; - } - yield [name, value]; + this.paused = false; + this.execute(this.socket.read() || EMPTY_BUF); + this.readMore(); + } + readMore() { + while (!this.paused && this.ptr) { + const chunk = this.socket.read(); + if (chunk === null) { + break; + } + this.execute(chunk); } - } -} -const buildHeaders = (newHeaders) => { - const targetHeaders = new Headers(); - const nullHeaders = new Set(); - for (const headers of newHeaders) { - const seenHeaders = new Set(); - for (const [name, value] of iterateHeaders(headers)) { - const lowerName = name.toLowerCase(); - if (!seenHeaders.has(lowerName)) { - targetHeaders.delete(name); - seenHeaders.add(lowerName); - } - if (value === null) { - targetHeaders.delete(name); - nullHeaders.add(lowerName); - } - else { - targetHeaders.append(name, value); - nullHeaders.delete(lowerName); - } + } + execute(data) { + assert(this.ptr != null); + assert(currentParser == null); + assert(!this.paused); + const { socket, llhttp } = this; + if (data.length > currentBufferSize) { + if (currentBufferPtr) { + llhttp.free(currentBufferPtr); + } + currentBufferSize = Math.ceil(data.length / 4096) * 4096; + currentBufferPtr = llhttp.malloc(currentBufferSize); } - } - return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders }; -}; -exports.buildHeaders = buildHeaders; -const isEmptyHeaders = (headers) => { - for (const _ of iterateHeaders(headers)) - return false; - return true; -}; -exports.isEmptyHeaders = isEmptyHeaders; -//# sourceMappingURL=headers.js.map - -/***/ }), - -/***/ 5702: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.defaultParseResponse = defaultParseResponse; -const log_1 = __nccwpck_require__(277); -async function defaultParseResponse(client, props) { - const { response, requestLogID, retryOfRequestLogID, startTime } = props; - const body = await (async () => { - // fetch refuses to read the body when the status code is 204. - if (response.status === 204) { - return null; + new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data); + try { + let ret; + try { + currentBufferRef = data; + currentParser = this; + ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length); + } catch (err) { + throw err; + } finally { + currentParser = null; + currentBufferRef = null; + } + const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; + if (ret === constants.ERROR.PAUSED_UPGRADE) { + this.onUpgrade(data.slice(offset)); + } else if (ret === constants.ERROR.PAUSED) { + this.paused = true; + socket.unshift(data.slice(offset)); + } else if (ret !== constants.ERROR.OK) { + const ptr = llhttp.llhttp_get_error_reason(this.ptr); + let message = ""; + if (ptr) { + const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); + message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; + } + throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)); + } + } catch (err) { + util.destroy(socket, err); } - if (props.options.__binaryResponse) { - return response; + } + destroy() { + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_free(this.ptr); + this.ptr = null; + timers.clearTimeout(this.timeout); + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.paused = false; + } + onStatus(buf) { + this.statusText = buf.toString(); + } + onMessageBegin() { + const { socket, client } = this; + if (socket.destroyed) { + return -1; } - const contentType = response.headers.get('content-type'); - const mediaType = contentType?.split(';')[0]?.trim(); - const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json'); - if (isJSON) { - const json = await response.json(); - return json; + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; } - const text = await response.text(); - return text; - })(); - (0, log_1.loggerFor)(client).debug(`[${requestLogID}] response parsed`, (0, log_1.formatRequestDetails)({ - retryOfRequestLogID, - url: response.url, - status: response.status, - body, - durationMs: Date.now() - startTime, - })); - return body; -} -//# sourceMappingURL=parse.js.map - -/***/ }), - -/***/ 1398: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.RFC3986 = exports.RFC1738 = exports.formatters = exports.default_formatter = exports.default_format = void 0; -exports.default_format = 'RFC3986'; -const default_formatter = (v) => String(v); -exports.default_formatter = default_formatter; -exports.formatters = { - RFC1738: (v) => String(v).replace(/%20/g, '+'), - RFC3986: exports.default_formatter, -}; -exports.RFC1738 = 'RFC1738'; -exports.RFC3986 = 'RFC3986'; -//# sourceMappingURL=formats.js.map - -/***/ }), - -/***/ 5186: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.formats = exports.stringify = void 0; -const formats_1 = __nccwpck_require__(1398); -const formats = { - formatters: formats_1.formatters, - RFC1738: formats_1.RFC1738, - RFC3986: formats_1.RFC3986, - default: formats_1.default_format, -}; -exports.formats = formats; -var stringify_1 = __nccwpck_require__(3375); -Object.defineProperty(exports, "stringify", ({ enumerable: true, get: function () { return stringify_1.stringify; } })); -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 3375: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.stringify = stringify; -const utils_1 = __nccwpck_require__(915); -const formats_1 = __nccwpck_require__(1398); -const values_1 = __nccwpck_require__(5537); -const array_prefix_generators = { - brackets(prefix) { - return String(prefix) + '[]'; - }, - comma: 'comma', - indices(prefix, key) { - return String(prefix) + '[' + key + ']'; - }, - repeat(prefix) { - return String(prefix); - }, -}; -const push_to_array = function (arr, value_or_array) { - Array.prototype.push.apply(arr, (0, values_1.isArray)(value_or_array) ? value_or_array : [value_or_array]); -}; -let toISOString; -const defaults = { - addQueryPrefix: false, - allowDots: false, - allowEmptyArrays: false, - arrayFormat: 'indices', - charset: 'utf-8', - charsetSentinel: false, - delimiter: '&', - encode: true, - encodeDotInKeys: false, - encoder: utils_1.encode, - encodeValuesOnly: false, - format: formats_1.default_format, - formatter: formats_1.default_formatter, - /** @deprecated */ - indices: false, - serializeDate(date) { - return (toISOString ?? (toISOString = Function.prototype.call.bind(Date.prototype.toISOString)))(date); - }, - skipNulls: false, - strictNullHandling: false, -}; -function is_non_nullish_primitive(v) { - return (typeof v === 'string' || - typeof v === 'number' || - typeof v === 'boolean' || - typeof v === 'symbol' || - typeof v === 'bigint'); -} -const sentinel = {}; -function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { - let obj = object; - let tmp_sc = sideChannel; - let step = 0; - let find_flag = false; - while ((tmp_sc = tmp_sc.get(sentinel)) !== void undefined && !find_flag) { - // Where object last appeared in the ref tree - const pos = tmp_sc.get(object); - step += 1; - if (typeof pos !== 'undefined') { - if (pos === step) { - throw new RangeError('Cyclic object value'); - } - else { - find_flag = true; // Break while - } + } + onHeaderField(buf) { + const len = this.headers.length; + if ((len & 1) === 0) { + this.headers.push(buf); + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); } - if (typeof tmp_sc.get(sentinel) === 'undefined') { - step = 0; + this.trackHeader(buf.length); + } + onHeaderValue(buf) { + let len = this.headers.length; + if ((len & 1) === 1) { + this.headers.push(buf); + len += 1; + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + } + const key = this.headers[len - 2]; + if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") { + this.keepAlive += buf.toString(); + } else if (key.length === 10 && key.toString().toLowerCase() === "connection") { + this.connection += buf.toString(); + } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") { + this.contentLength += buf.toString(); + } + this.trackHeader(buf.length); + } + trackHeader(len) { + this.headersSize += len; + if (this.headersSize >= this.headersMaxSize) { + util.destroy(this.socket, new HeadersOverflowError()); + } + } + onUpgrade(head) { + const { upgrade, client, socket, headers, statusCode } = this; + assert(upgrade); + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(!socket.destroyed); + assert(socket === client[kSocket]); + assert(!this.paused); + assert(request.upgrade || request.method === "CONNECT"); + this.statusCode = null; + this.statusText = ""; + this.shouldKeepAlive = null; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + socket.unshift(head); + socket[kParser].destroy(); + socket[kParser] = null; + socket[kClient] = null; + socket[kError] = null; + socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose); + client[kSocket] = null; + client[kQueue][client[kRunningIdx]++] = null; + client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); + try { + request.onUpgrade(statusCode, headers, socket); + } catch (err) { + util.destroy(socket, err); } - } - if (typeof filter === 'function') { - obj = filter(prefix, obj); - } - else if (obj instanceof Date) { - obj = serializeDate?.(obj); - } - else if (generateArrayPrefix === 'comma' && (0, values_1.isArray)(obj)) { - obj = (0, utils_1.maybe_map)(obj, function (value) { - if (value instanceof Date) { - return serializeDate?.(value); - } - return value; - }); - } - if (obj === null) { - if (strictNullHandling) { - return encoder && !encodeValuesOnly ? - // @ts-expect-error - encoder(prefix, defaults.encoder, charset, 'key', format) - : prefix; - } - obj = ''; - } - if (is_non_nullish_primitive(obj) || (0, utils_1.is_buffer)(obj)) { - if (encoder) { - const key_value = encodeValuesOnly ? prefix - // @ts-expect-error - : encoder(prefix, defaults.encoder, charset, 'key', format); - return [ - formatter?.(key_value) + - '=' + - // @ts-expect-error - formatter?.(encoder(obj, defaults.encoder, charset, 'value', format)), - ]; - } - return [formatter?.(prefix) + '=' + formatter?.(String(obj))]; - } - const values = []; - if (typeof obj === 'undefined') { - return values; - } - let obj_keys; - if (generateArrayPrefix === 'comma' && (0, values_1.isArray)(obj)) { - // we need to join elements in - if (encodeValuesOnly && encoder) { - // @ts-expect-error values only - obj = (0, utils_1.maybe_map)(obj, encoder); - } - obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }]; - } - else if ((0, values_1.isArray)(filter)) { - obj_keys = filter; - } - else { - const keys = Object.keys(obj); - obj_keys = sort ? keys.sort(sort) : keys; - } - const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix); - const adjusted_prefix = commaRoundTrip && (0, values_1.isArray)(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix; - if (allowEmptyArrays && (0, values_1.isArray)(obj) && obj.length === 0) { - return adjusted_prefix + '[]'; - } - for (let j = 0; j < obj_keys.length; ++j) { - const key = obj_keys[j]; - const value = - // @ts-ignore - typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key]; - if (skipNulls && value === null) { - continue; + resume(client); + } + onHeadersComplete(statusCode, upgrade, shouldKeepAlive) { + const { client, socket, headers, statusText } = this; + if (socket.destroyed) { + return -1; } - // @ts-ignore - const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, '%2E') : key; - const key_prefix = (0, values_1.isArray)(obj) ? - typeof generateArrayPrefix === 'function' ? - generateArrayPrefix(adjusted_prefix, encoded_key) - : adjusted_prefix - : adjusted_prefix + (allowDots ? '.' + encoded_key : '[' + encoded_key + ']'); - sideChannel.set(object, step); - const valueSideChannel = new WeakMap(); - valueSideChannel.set(sentinel, sideChannel); - push_to_array(values, inner_stringify(value, key_prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, - // @ts-ignore - generateArrayPrefix === 'comma' && encodeValuesOnly && (0, values_1.isArray)(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel)); - } - return values; -} -function normalize_stringify_options(opts = defaults) { - if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') { - throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided'); - } - if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') { - throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided'); - } - if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') { - throw new TypeError('Encoder has to be a function.'); - } - const charset = opts.charset || defaults.charset; - if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') { - throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined'); - } - let format = formats_1.default_format; - if (typeof opts.format !== 'undefined') { - if (!(0, utils_1.has)(formats_1.formatters, opts.format)) { - throw new TypeError('Unknown format option provided.'); + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; } - format = opts.format; - } - const formatter = formats_1.formatters[format]; - let filter = defaults.filter; - if (typeof opts.filter === 'function' || (0, values_1.isArray)(opts.filter)) { - filter = opts.filter; - } - let arrayFormat; - if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) { - arrayFormat = opts.arrayFormat; - } - else if ('indices' in opts) { - arrayFormat = opts.indices ? 'indices' : 'repeat'; - } - else { - arrayFormat = defaults.arrayFormat; - } - if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') { - throw new TypeError('`commaRoundTrip` must be a boolean, or absent'); - } - const allowDots = typeof opts.allowDots === 'undefined' ? - !!opts.encodeDotInKeys === true ? - true - : defaults.allowDots - : !!opts.allowDots; - return { - addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix, - // @ts-ignore - allowDots: allowDots, - allowEmptyArrays: typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays, - arrayFormat: arrayFormat, - charset: charset, - charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel, - commaRoundTrip: !!opts.commaRoundTrip, - delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter, - encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode, - encodeDotInKeys: typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys, - encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder, - encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly, - filter: filter, - format: format, - formatter: formatter, - serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate, - skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls, - // @ts-ignore - sort: typeof opts.sort === 'function' ? opts.sort : null, - strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling, - }; -} -function stringify(object, opts = {}) { - let obj = object; - const options = normalize_stringify_options(opts); - let obj_keys; - let filter; - if (typeof options.filter === 'function') { - filter = options.filter; - obj = filter('', obj); - } - else if ((0, values_1.isArray)(options.filter)) { - filter = options.filter; - obj_keys = filter; - } - const keys = []; - if (typeof obj !== 'object' || obj === null) { - return ''; - } - const generateArrayPrefix = array_prefix_generators[options.arrayFormat]; - const commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip; - if (!obj_keys) { - obj_keys = Object.keys(obj); - } - if (options.sort) { - obj_keys.sort(options.sort); - } - const sideChannel = new WeakMap(); - for (let i = 0; i < obj_keys.length; ++i) { - const key = obj_keys[i]; - if (options.skipNulls && obj[key] === null) { - continue; + assert(!this.upgrade); + assert(this.statusCode < 200); + if (statusCode === 100) { + util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket))); + return -1; } - push_to_array(keys, inner_stringify(obj[key], key, - // @ts-expect-error - generateArrayPrefix, commaRoundTrip, options.allowEmptyArrays, options.strictNullHandling, options.skipNulls, options.encodeDotInKeys, options.encode ? options.encoder : null, options.filter, options.sort, options.allowDots, options.serializeDate, options.format, options.formatter, options.encodeValuesOnly, options.charset, sideChannel)); - } - const joined = keys.join(options.delimiter); - let prefix = options.addQueryPrefix === true ? '?' : ''; - if (options.charsetSentinel) { - if (options.charset === 'iso-8859-1') { - // encodeURIComponent('✓'), the "numeric entity" representation of a checkmark - prefix += 'utf8=%26%2310003%3B&'; + if (upgrade && !request.upgrade) { + util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket))); + return -1; } - else { - // encodeURIComponent('✓') - prefix += 'utf8=%E2%9C%93&'; + assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS); + this.statusCode = statusCode; + this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. + request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; + if (this.statusCode >= 200) { + const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]; + this.setTimeout(bodyTimeout, TIMEOUT_BODY); + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } } - } - return joined.length > 0 ? prefix + joined : ''; -} -//# sourceMappingURL=stringify.js.map - -/***/ }), - -/***/ 915: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.encode = exports.has = void 0; -exports.merge = merge; -exports.assign_single_source = assign_single_source; -exports.decode = decode; -exports.compact = compact; -exports.is_regexp = is_regexp; -exports.is_buffer = is_buffer; -exports.combine = combine; -exports.maybe_map = maybe_map; -const formats_1 = __nccwpck_require__(1398); -const values_1 = __nccwpck_require__(5537); -let has = (obj, key) => ((exports.has = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)), - (0, exports.has)(obj, key)); -exports.has = has; -const hex_table = /* @__PURE__ */ (() => { - const array = []; - for (let i = 0; i < 256; ++i) { - array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase()); - } - return array; -})(); -function compact_queue(queue) { - while (queue.length > 1) { - const item = queue.pop(); - if (!item) - continue; - const obj = item.obj[item.prop]; - if ((0, values_1.isArray)(obj)) { - const compacted = []; - for (let j = 0; j < obj.length; ++j) { - if (typeof obj[j] !== 'undefined') { - compacted.push(obj[j]); - } + if (request.method === "CONNECT") { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + if (upgrade) { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (this.shouldKeepAlive && client[kPipelining]) { + const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null; + if (keepAliveTimeout != null) { + const timeout = Math.min( + keepAliveTimeout - client[kKeepAliveTimeoutThreshold], + client[kKeepAliveMaxTimeout] + ); + if (timeout <= 0) { + socket[kReset] = true; + } else { + client[kKeepAliveTimeoutValue] = timeout; } - // @ts-ignore - item.obj[item.prop] = compacted; + } else { + client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]; + } + } else { + socket[kReset] = true; } - } -} -function array_to_object(source, options) { - const obj = options && options.plainObjects ? Object.create(null) : {}; - for (let i = 0; i < source.length; ++i) { - if (typeof source[i] !== 'undefined') { - obj[i] = source[i]; + const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false; + if (request.aborted) { + return -1; } - } - return obj; -} -function merge(target, source, options = {}) { - if (!source) { - return target; - } - if (typeof source !== 'object') { - if ((0, values_1.isArray)(target)) { - target.push(source); + if (request.method === "HEAD") { + return 1; } - else if (target && typeof target === 'object') { - if ((options && (options.plainObjects || options.allowPrototypes)) || !(0, exports.has)(Object.prototype, source)) { - target[source] = true; - } + if (statusCode < 200) { + return 1; } - else { - return [target, source]; + if (socket[kBlocking]) { + socket[kBlocking] = false; + resume(client); } - return target; - } - if (!target || typeof target !== 'object') { - return [target].concat(source); - } - let mergeTarget = target; - if ((0, values_1.isArray)(target) && !(0, values_1.isArray)(source)) { - // @ts-ignore - mergeTarget = array_to_object(target, options); - } - if ((0, values_1.isArray)(target) && (0, values_1.isArray)(source)) { - source.forEach(function (item, i) { - if ((0, exports.has)(target, i)) { - const targetItem = target[i]; - if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') { - target[i] = merge(targetItem, item, options); - } - else { - target.push(item); - } - } - else { - target[i] = item; + return pause ? constants.ERROR.PAUSED : 0; + } + onBody(buf) { + const { client, socket, statusCode, maxResponseSize } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert.strictEqual(this.timeoutType, TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + assert(statusCode >= 200); + if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) { + util.destroy(socket, new ResponseExceededMaxSizeError()); + return -1; + } + this.bytesRead += buf.length; + if (request.onData(buf) === false) { + return constants.ERROR.PAUSED; + } + } + onMessageComplete() { + const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this; + if (socket.destroyed && (!statusCode || shouldKeepAlive)) { + return -1; + } + if (upgrade) { + return; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(statusCode >= 100); + this.statusCode = null; + this.statusText = ""; + this.bytesRead = 0; + this.contentLength = ""; + this.keepAlive = ""; + this.connection = ""; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (statusCode < 200) { + return; + } + if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) { + util.destroy(socket, new ResponseContentLengthMismatchError()); + return -1; + } + request.onComplete(headers); + client[kQueue][client[kRunningIdx]++] = null; + if (socket[kWriting]) { + assert.strictEqual(client[kRunning], 0); + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (!shouldKeepAlive) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (socket[kReset] && client[kRunning] === 0) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (client[kPipelining] === 1) { + setImmediate(resume, client); + } else { + resume(client); + } + } + }; + function onParserTimeout(parser) { + const { socket, timeoutType, client } = parser; + if (timeoutType === TIMEOUT_HEADERS) { + if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { + assert(!parser.paused, "cannot be paused while waiting for headers"); + util.destroy(socket, new HeadersTimeoutError()); + } + } else if (timeoutType === TIMEOUT_BODY) { + if (!parser.paused) { + util.destroy(socket, new BodyTimeoutError()); + } + } else if (timeoutType === TIMEOUT_IDLE) { + assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); + util.destroy(socket, new InformationalError("socket idle timeout")); + } + } + function onSocketReadable() { + const { [kParser]: parser } = this; + if (parser) { + parser.readMore(); + } + } + function onSocketError(err) { + const { [kClient]: client, [kParser]: parser } = this; + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + if (client[kHTTPConnVersion] !== "h2") { + if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + this[kError] = err; + onError(this[kClient], err); + } + function onError(client, err) { + if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") { + assert(client[kPendingIdx] === client[kRunningIdx]); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + assert(client[kSize] === 0); + } + } + function onSocketEnd() { + const { [kParser]: parser, [kClient]: client } = this; + if (client[kHTTPConnVersion] !== "h2") { + if (parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this))); + } + function onSocketClose() { + const { [kClient]: client, [kParser]: parser } = this; + if (client[kHTTPConnVersion] === "h1" && parser) { + if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + } + this[kParser].destroy(); + this[kParser] = null; + } + const err = this[kError] || new SocketError("closed", util.getSocketInfo(this)); + client[kSocket] = null; + if (client.destroyed) { + assert(client[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + resume(client); + } + async function connect(client) { + assert(!client[kConnecting]); + assert(!client[kSocket]); + let { host, hostname, protocol, port } = client[kUrl]; + if (hostname[0] === "[") { + const idx = hostname.indexOf("]"); + assert(idx !== -1); + const ip = hostname.substring(1, idx); + assert(net.isIP(ip)); + hostname = ip; + } + client[kConnecting] = true; + if (channels.beforeConnect.hasSubscribers) { + channels.beforeConnect.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector] + }); + } + try { + const socket = await new Promise((resolve, reject) => { + client[kConnector]({ + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, (err, socket2) => { + if (err) { + reject(err); + } else { + resolve(socket2); } + }); }); - return target; - } - return Object.keys(source).reduce(function (acc, key) { - const value = source[key]; - if ((0, exports.has)(acc, key)) { - acc[key] = merge(acc[key], value, options); + if (client.destroyed) { + util.destroy(socket.on("error", () => { + }), new ClientDestroyedError()); + return; + } + client[kConnecting] = false; + assert(socket); + const isH2 = socket.alpnProtocol === "h2"; + if (isH2) { + if (!h2ExperimentalWarned) { + h2ExperimentalWarned = true; + process.emitWarning("H2 support is experimental, expect them to change at any time.", { + code: "UNDICI-H2" + }); + } + const session = http2.connect(client[kUrl], { + createConnection: () => socket, + peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams + }); + client[kHTTPConnVersion] = "h2"; + session[kClient] = client; + session[kSocket] = socket; + session.on("error", onHttp2SessionError); + session.on("frameError", onHttp2FrameError); + session.on("end", onHttp2SessionEnd); + session.on("goaway", onHTTP2GoAway); + session.on("close", onSocketClose); + session.unref(); + client[kHTTP2Session] = session; + socket[kHTTP2Session] = session; + } else { + if (!llhttpInstance) { + llhttpInstance = await llhttpPromise; + llhttpPromise = null; + } + socket[kNoRef] = false; + socket[kWriting] = false; + socket[kReset] = false; + socket[kBlocking] = false; + socket[kParser] = new Parser(client, socket, llhttpInstance); + } + socket[kCounter] = 0; + socket[kMaxRequests] = client[kMaxRequests]; + socket[kClient] = client; + socket[kError] = null; + socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose); + client[kSocket] = socket; + if (channels.connected.hasSubscribers) { + channels.connected.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + socket + }); } - else { - acc[key] = value; + client.emit("connect", client[kUrl], [client]); + } catch (err) { + if (client.destroyed) { + return; + } + client[kConnecting] = false; + if (channels.connectError.hasSubscribers) { + channels.connectError.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + error: err + }); + } + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { + assert(client[kRunning] === 0); + while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { + const request = client[kQueue][client[kPendingIdx]++]; + errorRequest(client, request, err); + } + } else { + onError(client, err); } - return acc; - }, mergeTarget); -} -function assign_single_source(target, source) { - return Object.keys(source).reduce(function (acc, key) { - acc[key] = source[key]; - return acc; - }, target); -} -function decode(str, _, charset) { - const strWithoutPlus = str.replace(/\+/g, ' '); - if (charset === 'iso-8859-1') { - // unescape never throws, no try...catch needed: - return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape); - } - // utf-8 - try { - return decodeURIComponent(strWithoutPlus); - } - catch (e) { - return strWithoutPlus; - } -} -const limit = 1024; -const encode = (str, _defaultEncoder, charset, _kind, format) => { - // This code was originally written by Brian White for the io.js core querystring library. - // It has been adapted here for stricter adherence to RFC 3986 - if (str.length === 0) { - return str; - } - let string = str; - if (typeof str === 'symbol') { - string = Symbol.prototype.toString.call(str); - } - else if (typeof str !== 'string') { - string = String(str); + client.emit("connectionError", client[kUrl], [client], err); + } + resume(client); } - if (charset === 'iso-8859-1') { - return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) { - return '%26%23' + parseInt($0.slice(2), 16) + '%3B'; - }); + function emitDrain(client) { + client[kNeedDrain] = 0; + client.emit("drain", client[kUrl], [client]); } - let out = ''; - for (let j = 0; j < string.length; j += limit) { - const segment = string.length >= limit ? string.slice(j, j + limit) : string; - const arr = []; - for (let i = 0; i < segment.length; ++i) { - let c = segment.charCodeAt(i); - if (c === 0x2d || // - - c === 0x2e || // . - c === 0x5f || // _ - c === 0x7e || // ~ - (c >= 0x30 && c <= 0x39) || // 0-9 - (c >= 0x41 && c <= 0x5a) || // a-z - (c >= 0x61 && c <= 0x7a) || // A-Z - (format === formats_1.RFC1738 && (c === 0x28 || c === 0x29)) // ( ) - ) { - arr[arr.length] = segment.charAt(i); - continue; - } - if (c < 0x80) { - arr[arr.length] = hex_table[c]; - continue; + function resume(client, sync) { + if (client[kResuming] === 2) { + return; + } + client[kResuming] = 2; + _resume(client, sync); + client[kResuming] = 0; + if (client[kRunningIdx] > 256) { + client[kQueue].splice(0, client[kRunningIdx]); + client[kPendingIdx] -= client[kRunningIdx]; + client[kRunningIdx] = 0; + } + } + function _resume(client, sync) { + while (true) { + if (client.destroyed) { + assert(client[kPending] === 0); + return; + } + if (client[kClosedResolve] && !client[kSize]) { + client[kClosedResolve](); + client[kClosedResolve] = null; + return; + } + const socket = client[kSocket]; + if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") { + if (client[kSize] === 0) { + if (!socket[kNoRef] && socket.unref) { + socket.unref(); + socket[kNoRef] = true; } - if (c < 0x800) { - arr[arr.length] = hex_table[0xc0 | (c >> 6)] + hex_table[0x80 | (c & 0x3f)]; - continue; + } else if (socket[kNoRef] && socket.ref) { + socket.ref(); + socket[kNoRef] = false; + } + if (client[kSize] === 0) { + if (socket[kParser].timeoutType !== TIMEOUT_IDLE) { + socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE); } - if (c < 0xd800 || c >= 0xe000) { - arr[arr.length] = - hex_table[0xe0 | (c >> 12)] + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)]; - continue; + } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) { + if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) { + const request2 = client[kQueue][client[kRunningIdx]]; + const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout]; + socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS); } - i += 1; - c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff)); - arr[arr.length] = - hex_table[0xf0 | (c >> 18)] + - hex_table[0x80 | ((c >> 12) & 0x3f)] + - hex_table[0x80 | ((c >> 6) & 0x3f)] + - hex_table[0x80 | (c & 0x3f)]; + } } - out += arr.join(''); - } - return out; -}; -exports.encode = encode; -function compact(value) { - const queue = [{ obj: { o: value }, prop: 'o' }]; - const refs = []; - for (let i = 0; i < queue.length; ++i) { - const item = queue[i]; - // @ts-ignore - const obj = item.obj[item.prop]; - const keys = Object.keys(obj); - for (let j = 0; j < keys.length; ++j) { - const key = keys[j]; - const val = obj[key]; - if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) { - queue.push({ obj: obj, prop: key }); - refs.push(val); - } + if (client[kBusy]) { + client[kNeedDrain] = 2; + } else if (client[kNeedDrain] === 2) { + if (sync) { + client[kNeedDrain] = 1; + process.nextTick(emitDrain, client); + } else { + emitDrain(client); + } + continue; } - } - compact_queue(queue); - return value; -} -function is_regexp(obj) { - return Object.prototype.toString.call(obj) === '[object RegExp]'; -} -function is_buffer(obj) { - if (!obj || typeof obj !== 'object') { - return false; - } - return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); -} -function combine(a, b) { - return [].concat(a, b); -} -function maybe_map(val, fn) { - if ((0, values_1.isArray)(val)) { - const mapped = []; - for (let i = 0; i < val.length; i += 1) { - mapped.push(fn(val[i])); + if (client[kPending] === 0) { + return; } - return mapped; - } - return fn(val); -} -//# sourceMappingURL=utils.js.map - -/***/ }), - -/***/ 6340: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.FallbackEncoder = void 0; -const FallbackEncoder = ({ headers, body }) => { - return { - bodyHeaders: { - 'content-type': 'application/json', - }, - body: JSON.stringify(body), - }; -}; -exports.FallbackEncoder = FallbackEncoder; -//# sourceMappingURL=request-options.js.map - -/***/ }), - -/***/ 9019: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getDefaultFetch = getDefaultFetch; -exports.makeReadableStream = makeReadableStream; -exports.ReadableStreamFrom = ReadableStreamFrom; -exports.ReadableStreamToAsyncIterable = ReadableStreamToAsyncIterable; -exports.CancelReadableStream = CancelReadableStream; -function getDefaultFetch() { - if (typeof fetch !== 'undefined') { - return fetch; - } - throw new Error('`fetch` is not defined as a global; Either pass `fetch` to the client, `new Stainless({ fetch })` or polyfill the global, `globalThis.fetch = fetch`'); -} -function makeReadableStream(...args) { - const ReadableStream = globalThis.ReadableStream; - if (typeof ReadableStream === 'undefined') { - // Note: All of the platforms / runtimes we officially support already define - // `ReadableStream` as a global, so this should only ever be hit on unsupported runtimes. - throw new Error('`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`'); - } - return new ReadableStream(...args); -} -function ReadableStreamFrom(iterable) { - let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); - return makeReadableStream({ - start() { }, - async pull(controller) { - const { done, value } = await iter.next(); - if (done) { - controller.close(); - } - else { - controller.enqueue(value); - } - }, - async cancel() { - await iter.return?.(); - }, - }); -} -/** - * Most browsers don't yet have async iterable support for ReadableStream, - * and Node has a very different way of reading bytes from its "ReadableStream". - * - * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490 - */ -function ReadableStreamToAsyncIterable(stream) { - if (stream[Symbol.asyncIterator]) - return stream; - const reader = stream.getReader(); - return { - async next() { - try { - const result = await reader.read(); - if (result?.done) - reader.releaseLock(); // release lock when stream becomes closed - return result; - } - catch (e) { - reader.releaseLock(); // release lock when stream becomes errored - throw e; - } - }, - async return() { - const cancelPromise = reader.cancel(); - reader.releaseLock(); - await cancelPromise; - return { done: true, value: undefined }; - }, - [Symbol.asyncIterator]() { - return this; - }, - }; -} -/** - * Cancels a ReadableStream we don't need to consume. - * See https://undici.nodejs.org/#/?id=garbage-collection - */ -async function CancelReadableStream(stream) { - if (stream === null || typeof stream !== 'object') - return; - if (stream[Symbol.asyncIterator]) { - await stream[Symbol.asyncIterator]().return?.(); - return; - } - const reader = stream.getReader(); - const cancelPromise = reader.cancel(); - reader.releaseLock(); - await cancelPromise; -} -//# sourceMappingURL=shims.js.map - -/***/ }), - -/***/ 8719: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.toFile = toFile; -const uploads_1 = __nccwpck_require__(2875); -const uploads_2 = __nccwpck_require__(2875); -/** - * This check adds the arrayBuffer() method type because it is available and used at runtime - */ -const isBlobLike = (value) => value != null && - typeof value === 'object' && - typeof value.size === 'number' && - typeof value.type === 'string' && - typeof value.text === 'function' && - typeof value.slice === 'function' && - typeof value.arrayBuffer === 'function'; -/** - * This check adds the arrayBuffer() method type because it is available and used at runtime - */ -const isFileLike = (value) => value != null && - typeof value === 'object' && - typeof value.name === 'string' && - typeof value.lastModified === 'number' && - isBlobLike(value); -const isResponseLike = (value) => value != null && - typeof value === 'object' && - typeof value.url === 'string' && - typeof value.blob === 'function'; -/** - * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats - * @param value the raw content of the file. Can be an {@link Uploadable}, {@link BlobLikePart}, or {@link AsyncIterable} of {@link BlobLikePart}s - * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible - * @param {Object=} options additional properties - * @param {string=} options.type the MIME type of the content - * @param {number=} options.lastModified the last modified timestamp - * @returns a {@link File} with the given properties - */ -async function toFile(value, name, options) { - (0, uploads_2.checkFileSupport)(); - // If it's a promise, resolve it. - value = await value; - // If we've been given a `File` we don't need to do anything - if (isFileLike(value)) { - if (value instanceof File) { - return value; - } - return (0, uploads_1.makeFile)([await value.arrayBuffer()], value.name); - } - if (isResponseLike(value)) { - const blob = await value.blob(); - name || (name = new URL(value.url).pathname.split(/[\\/]/).pop()); - return (0, uploads_1.makeFile)(await getBytes(blob), name, options); - } - const parts = await getBytes(value); - name || (name = (0, uploads_1.getName)(value)); - if (!options?.type) { - const type = parts.find((part) => typeof part === 'object' && 'type' in part && part.type); - if (typeof type === 'string') { - options = { ...options, type }; - } - } - return (0, uploads_1.makeFile)(parts, name, options); -} -async function getBytes(value) { - let parts = []; - if (typeof value === 'string' || - ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc. - value instanceof ArrayBuffer) { - parts.push(value); - } - else if (isBlobLike(value)) { - parts.push(value instanceof Blob ? value : await value.arrayBuffer()); - } - else if ((0, uploads_1.isAsyncIterable)(value) // includes Readable, ReadableStream, etc. - ) { - for await (const chunk of value) { - parts.push(...(await getBytes(chunk))); // TODO, consider validating? + if (client[kRunning] >= (client[kPipelining] || 1)) { + return; } - } - else { - const constructor = value?.constructor?.name; - throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ''}${propsForError(value)}`); - } - return parts; -} -function propsForError(value) { - if (typeof value !== 'object' || value === null) - return ''; - const props = Object.getOwnPropertyNames(value); - return `; props: [${props.map((p) => `"${p}"`).join(', ')}]`; -} -//# sourceMappingURL=to-file.js.map - -/***/ }), - -/***/ 533: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.__setModuleDefault = exports.__createBinding = void 0; -exports.__classPrivateFieldSet = __classPrivateFieldSet; -exports.__classPrivateFieldGet = __classPrivateFieldGet; -exports.__importStar = __importStar; -exports.__exportStar = __exportStar; -function __classPrivateFieldSet(receiver, state, value, kind, f) { - if (kind === "m") - throw new TypeError("Private method is not writable"); - if (kind === "a" && !f) - throw new TypeError("Private accessor was defined without a setter"); - if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) - throw new TypeError("Cannot write private member to an object whose class did not declare it"); - return kind === "a" ? f.call(receiver, value) : f ? (f.value = value) : state.set(receiver, value), value; -} -function __classPrivateFieldGet(receiver, state, kind, f) { - if (kind === "a" && !f) - throw new TypeError("Private accessor was defined without a getter"); - if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) - throw new TypeError("Cannot read private member from an object whose class did not declare it"); - return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); -} -var __createBinding = Object.create - ? function (o, m, k, k2) { - if (k2 === void 0) - k2 = k; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { - enumerable: true, - get: function () { - return m[k]; - }, - }; + const request = client[kQueue][client[kPendingIdx]]; + if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) { + if (client[kRunning] > 0) { + return; + } + client[kServerName] = request.servername; + if (socket && socket.servername !== request.servername) { + util.destroy(socket, new InformationalError("servername changed")); + return; + } } - Object.defineProperty(o, k2, desc); - } - : function (o, m, k, k2) { - if (k2 === void 0) - k2 = k; - o[k2] = m[k]; - }; -exports.__createBinding = __createBinding; -var __setModuleDefault = Object.create - ? function (o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); - } - : function (o, v) { - o["default"] = v; - }; -exports.__setModuleDefault = __setModuleDefault; -var ownKeys = function (o) { - ownKeys = - Object.getOwnPropertyNames || - function (o2) { - var ar = []; - for (var k in o2) - if (Object.prototype.hasOwnProperty.call(o2, k)) - ar[ar.length] = k; - return ar; - }; - return ownKeys(o); -}; -function __importStar(mod) { - if (mod && mod.__esModule) - return mod; - var result = {}; - if (mod != null) { - for (var k = ownKeys(mod), i = 0; i < k.length; i++) - if (k[i] !== "default") - __createBinding(result, mod, k[i]); - } - __setModuleDefault(result, mod); - return result; -} -function __exportStar(m, o) { - for (var p in m) - if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) - __createBinding(o, m, p); -} - - -/***/ }), - -/***/ 2875: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.createForm = exports.multipartFormRequestOptions = exports.maybeMultipartFormRequestOptions = exports.isAsyncIterable = exports.checkFileSupport = void 0; -exports.makeFile = makeFile; -exports.getName = getName; -const shims_1 = __nccwpck_require__(9019); -const checkFileSupport = () => { - if (typeof File === 'undefined') { - const { process } = globalThis; - const isOldNode = typeof process?.versions?.node === 'string' && parseInt(process.versions.node.split('.')) < 20; - throw new Error('`File` is not defined as a global, which is required for file uploads.' + - (isOldNode ? - " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." - : '')); - } -}; -exports.checkFileSupport = checkFileSupport; -/** - * Construct a `File` instance. This is used to ensure a helpful error is thrown - * for environments that don't define a global `File` yet. - */ -function makeFile(fileBits, fileName, options) { - (0, exports.checkFileSupport)(); - return new File(fileBits, fileName ?? 'unknown_file', options); -} -function getName(value) { - return (((typeof value === 'object' && - value !== null && - (('name' in value && value.name && String(value.name)) || - ('url' in value && value.url && String(value.url)) || - ('filename' in value && value.filename && String(value.filename)) || - ('path' in value && value.path && String(value.path)))) || - '') - .split(/[\\/]/) - .pop() || undefined); -} -const isAsyncIterable = (value) => value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function'; -exports.isAsyncIterable = isAsyncIterable; -/** - * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value. - * Otherwise returns the request as is. - */ -const maybeMultipartFormRequestOptions = async (opts, fetch) => { - if (!hasUploadableValue(opts.body)) - return opts; - return { ...opts, body: await (0, exports.createForm)(opts.body, fetch) }; -}; -exports.maybeMultipartFormRequestOptions = maybeMultipartFormRequestOptions; -const multipartFormRequestOptions = async (opts, fetch) => { - return { ...opts, body: await (0, exports.createForm)(opts.body, fetch) }; -}; -exports.multipartFormRequestOptions = multipartFormRequestOptions; -const supportsFormDataMap = /* @__PURE__ */ new WeakMap(); -/** - * node-fetch doesn't support the global FormData object in recent node versions. Instead of sending - * properly-encoded form data, it just stringifies the object, resulting in a request body of "[object FormData]". - * This function detects if the fetch function provided supports the global FormData object to avoid - * confusing error messages later on. - */ -function supportsFormData(fetchObject) { - const fetch = typeof fetchObject === 'function' ? fetchObject : fetchObject.fetch; - const cached = supportsFormDataMap.get(fetch); - if (cached) - return cached; - const promise = (async () => { - try { - const FetchResponse = ('Response' in fetch ? - fetch.Response - : (await fetch('data:,')).constructor); - const data = new FormData(); - if (data.toString() === (await new FetchResponse(data).text())) { - return false; - } - return true; + if (client[kConnecting]) { + return; } - catch { - // avoid false negatives - return true; + if (!socket && !client[kHTTP2Session]) { + connect(client); + return; } - })(); - supportsFormDataMap.set(fetch, promise); - return promise; -} -const createForm = async (body, fetch) => { - if (!(await supportsFormData(fetch))) { - throw new TypeError('The provided fetch function does not support file uploads with the current global FormData class.'); - } - const form = new FormData(); - await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value))); - return form; -}; -exports.createForm = createForm; -// We check for Blob not File because Bun.File doesn't inherit from File, -// but they both inherit from Blob and have a `name` property at runtime. -const isNamedBlob = (value) => value instanceof Blob && 'name' in value; -const isUploadable = (value) => typeof value === 'object' && - value !== null && - (value instanceof Response || (0, exports.isAsyncIterable)(value) || isNamedBlob(value)); -const hasUploadableValue = (value) => { - if (isUploadable(value)) - return true; - if (Array.isArray(value)) - return value.some(hasUploadableValue); - if (value && typeof value === 'object') { - for (const k in value) { - if (hasUploadableValue(value[k])) - return true; + if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) { + return; } + if (client[kRunning] > 0 && !request.idempotent) { + return; + } + if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) { + return; + } + if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body))) { + return; + } + if (!request.aborted && write(client, request)) { + client[kPendingIdx]++; + } else { + client[kQueue].splice(client[kPendingIdx], 1); + } + } } - return false; -}; -const addFormValue = async (form, key, value) => { - if (value === undefined) - return; - if (value == null) { - throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`); - } - // TODO: make nested formats configurable - if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') { - form.append(key, String(value)); - } - else if (value instanceof Response) { - form.append(key, makeFile([await value.blob()], getName(value))); - } - else if ((0, exports.isAsyncIterable)(value)) { - form.append(key, makeFile([await new Response((0, shims_1.ReadableStreamFrom)(value)).blob()], getName(value))); - } - else if (isNamedBlob(value)) { - form.append(key, value, getName(value)); - } - else if (Array.isArray(value)) { - await Promise.all(value.map((entry) => addFormValue(form, key + '[]', entry))); - } - else if (typeof value === 'object') { - await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop))); - } - else { - throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`); - } -}; -//# sourceMappingURL=uploads.js.map - -/***/ }), - -/***/ 3516: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.readEnv = void 0; -/** - * Read an environment variable. - * - * Trims beginning and trailing whitespace. - * - * Will return undefined if the environment variable doesn't exist or cannot be accessed. - */ -const readEnv = (env) => { - if (typeof globalThis.process !== 'undefined') { - return globalThis.process.env?.[env]?.trim() ?? undefined; - } - if (typeof globalThis.Deno !== 'undefined') { - return globalThis.Deno.env?.get?.(env)?.trim(); - } - return undefined; -}; -exports.readEnv = readEnv; -//# sourceMappingURL=env.js.map - -/***/ }), - -/***/ 277: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.formatRequestDetails = exports.parseLogLevel = void 0; -exports.loggerFor = loggerFor; -const values_1 = __nccwpck_require__(5537); -const levelNumbers = { - off: 0, - error: 200, - warn: 300, - info: 400, - debug: 500, -}; -const parseLogLevel = (maybeLevel, sourceName, client) => { - if (!maybeLevel) { - return undefined; - } - if ((0, values_1.hasOwn)(levelNumbers, maybeLevel)) { - return maybeLevel; - } - loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`); - return undefined; -}; -exports.parseLogLevel = parseLogLevel; -function noop() { } -function makeLogFn(fnLevel, logger, logLevel) { - if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) { - return noop; - } - else { - // Don't wrap logger functions, we want the stacktrace intact! - return logger[fnLevel].bind(logger); + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; } -} -const noopLogger = { - error: noop, - warn: noop, - info: noop, - debug: noop, -}; -let cachedLoggers = /* @__PURE__ */ new WeakMap(); -function loggerFor(client) { - const logger = client.logger; - const logLevel = client.logLevel ?? 'off'; - if (!logger) { - return noopLogger; - } - const cachedLogger = cachedLoggers.get(logger); - if (cachedLogger && cachedLogger[0] === logLevel) { - return cachedLogger[1]; - } - const levelLogger = { - error: makeLogFn('error', logger, logLevel), - warn: makeLogFn('warn', logger, logLevel), - info: makeLogFn('info', logger, logLevel), - debug: makeLogFn('debug', logger, logLevel), - }; - cachedLoggers.set(logger, [logLevel, levelLogger]); - return levelLogger; -} -const formatRequestDetails = (details) => { - if (details.options) { - details.options = { ...details.options }; - delete details.options['headers']; // redundant + leaks internals - } - if (details.headers) { - details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [ - name, - (name.toLowerCase() === 'authorization' || - name.toLowerCase() === 'cookie' || - name.toLowerCase() === 'set-cookie') ? - '***' - : value, - ])); - } - if ('retryOfRequestLogID' in details) { - if (details.retryOfRequestLogID) { - details.retryOf = details.retryOfRequestLogID; - } - delete details.retryOfRequestLogID; - } - return details; -}; -exports.formatRequestDetails = formatRequestDetails; -//# sourceMappingURL=log.js.map - -/***/ }), - -/***/ 5580: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.path = exports.createPathTagFunction = void 0; -exports.encodeURIPath = encodeURIPath; -const error_1 = __nccwpck_require__(3801); -/** - * Percent-encode everything that isn't safe to have in a path without encoding safe chars. - * - * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3: - * > unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" - * > sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "=" - * > pchar = unreserved / pct-encoded / sub-delims / ":" / "@" - */ -function encodeURIPath(str) { - return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); -} -const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); -const createPathTagFunction = (pathEncoder = encodeURIPath) => function path(statics, ...params) { - // If there are no params, no processing is needed. - if (statics.length === 1) - return statics[0]; - let postPath = false; - const invalidSegments = []; - const path = statics.reduce((previousValue, currentValue, index) => { - if (/[?#]/.test(currentValue)) { - postPath = true; - } - const value = params[index]; - let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value); - if (index !== params.length && - (value == null || - (typeof value === 'object' && - // handle values from other realms - value.toString === - Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY) - ?.toString))) { - encoded = value + ''; - invalidSegments.push({ - start: previousValue.length + currentValue.length, - length: encoded.length, - error: `Value of type ${Object.prototype.toString - .call(value) - .slice(8, -1)} is not a valid path parameter`, - }); + function write(client, request) { + if (client[kHTTPConnVersion] === "h2") { + writeH2(client, client[kHTTP2Session], request); + return; + } + const { body, method, path: path2, host, upgrade, headers, blocking, reset } = request; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + const bodyLength = util.bodyLength(body); + let contentLength = bodyLength; + if (contentLength === null) { + contentLength = request.contentLength; + } + if (contentLength === 0 && !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; } - return previousValue + currentValue + (index === params.length ? '' : encoded); - }, ''); - const pathOnly = path.split(/[?#]/, 1)[0]; - const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; - let match; - // Find all invalid segments - while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { - invalidSegments.push({ - start: match.index, - length: match[0].length, - error: `Value "${match[0]}" can\'t be safely passed as a path parameter`, + process.emitWarning(new RequestContentLengthMismatchError()); + } + const socket = client[kSocket]; + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); + util.destroy(socket, new InformationalError("aborted")); }); - } - invalidSegments.sort((a, b) => a.start - b.start); - if (invalidSegments.length > 0) { - let lastEnd = 0; - const underline = invalidSegments.reduce((acc, segment) => { - const spaces = ' '.repeat(segment.start - lastEnd); - const arrows = '^'.repeat(segment.length); - lastEnd = segment.start + segment.length; - return acc + spaces + arrows; - }, ''); - throw new error_1.StainlessError(`Path parameters result in path with invalid segments:\n${invalidSegments - .map((e) => e.error) - .join('\n')}\n${path}\n${underline}`); - } - return path; -}; -exports.createPathTagFunction = createPathTagFunction; -/** - * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced. - */ -exports.path = (0, exports.createPathTagFunction)(encodeURIPath); -//# sourceMappingURL=path.js.map - -/***/ }), - -/***/ 3160: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.sleep = void 0; -const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); -exports.sleep = sleep; -//# sourceMappingURL=sleep.js.map - -/***/ }), - -/***/ 7008: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.uuid4 = void 0; -/** - * https://stackoverflow.com/a/2117523 - */ -let uuid4 = function () { - const { crypto } = globalThis; - if (crypto?.randomUUID) { - exports.uuid4 = crypto.randomUUID.bind(crypto); - return crypto.randomUUID(); - } - const u8 = new Uint8Array(1); - const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => (Math.random() * 0xff) & 0xff; - return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) => (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16)); -}; -exports.uuid4 = uuid4; -//# sourceMappingURL=uuid.js.map - -/***/ }), - -/***/ 5537: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.safeJSON = exports.maybeCoerceBoolean = exports.maybeCoerceFloat = exports.maybeCoerceInteger = exports.coerceBoolean = exports.coerceFloat = exports.coerceInteger = exports.validatePositiveInteger = exports.ensurePresent = exports.isReadonlyArray = exports.isArray = exports.isAbsoluteURL = void 0; -exports.maybeObj = maybeObj; -exports.isEmptyObj = isEmptyObj; -exports.hasOwn = hasOwn; -exports.isObj = isObj; -const error_1 = __nccwpck_require__(3801); -// https://url.spec.whatwg.org/#url-scheme-string -const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i; -const isAbsoluteURL = (url) => { - return startsWithSchemeRegexp.test(url); -}; -exports.isAbsoluteURL = isAbsoluteURL; -let isArray = (val) => ((exports.isArray = Array.isArray), (0, exports.isArray)(val)); -exports.isArray = isArray; -exports.isReadonlyArray = exports.isArray; -/** Returns an object if the given value isn't an object, otherwise returns as-is */ -function maybeObj(x) { - if (typeof x !== 'object') { - return {}; - } - return x ?? {}; -} -// https://stackoverflow.com/a/34491287 -function isEmptyObj(obj) { - if (!obj) - return true; - for (const _k in obj) + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { return false; - return true; -} -// https://eslint.org/docs/latest/rules/no-prototype-builtins -function hasOwn(obj, key) { - return Object.prototype.hasOwnProperty.call(obj, key); -} -function isObj(obj) { - return obj != null && typeof obj === 'object' && !Array.isArray(obj); -} -const ensurePresent = (value) => { - if (value == null) { - throw new error_1.StainlessError(`Expected a value to be given but received ${value} instead.`); - } - return value; -}; -exports.ensurePresent = ensurePresent; -const validatePositiveInteger = (name, n) => { - if (typeof n !== 'number' || !Number.isInteger(n)) { - throw new error_1.StainlessError(`${name} must be an integer`); - } - if (n < 0) { - throw new error_1.StainlessError(`${name} must be a positive integer`); - } - return n; -}; -exports.validatePositiveInteger = validatePositiveInteger; -const coerceInteger = (value) => { - if (typeof value === 'number') - return Math.round(value); - if (typeof value === 'string') - return parseInt(value, 10); - throw new error_1.StainlessError(`Could not coerce ${value} (type: ${typeof value}) into a number`); -}; -exports.coerceInteger = coerceInteger; -const coerceFloat = (value) => { - if (typeof value === 'number') - return value; - if (typeof value === 'string') - return parseFloat(value); - throw new error_1.StainlessError(`Could not coerce ${value} (type: ${typeof value}) into a number`); -}; -exports.coerceFloat = coerceFloat; -const coerceBoolean = (value) => { - if (typeof value === 'boolean') - return value; - if (typeof value === 'string') - return value === 'true'; - return Boolean(value); -}; -exports.coerceBoolean = coerceBoolean; -const maybeCoerceInteger = (value) => { - if (value === undefined) { - return undefined; - } - return (0, exports.coerceInteger)(value); -}; -exports.maybeCoerceInteger = maybeCoerceInteger; -const maybeCoerceFloat = (value) => { - if (value === undefined) { - return undefined; - } - return (0, exports.coerceFloat)(value); -}; -exports.maybeCoerceFloat = maybeCoerceFloat; -const maybeCoerceBoolean = (value) => { - if (value === undefined) { - return undefined; - } - return (0, exports.coerceBoolean)(value); -}; -exports.maybeCoerceBoolean = maybeCoerceBoolean; -const safeJSON = (text) => { - try { - return JSON.parse(text); - } - catch (err) { - return undefined; - } -}; -exports.safeJSON = safeJSON; -//# sourceMappingURL=values.js.map - -/***/ }), - -/***/ 7568: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.unwrapFile = unwrapFile; -async function unwrapFile(value) { - if (value === null) { - return null; - } - if (value.type === 'content') { - return value.content; + } + if (method === "HEAD") { + socket[kReset] = true; + } + if (upgrade || method === "CONNECT") { + socket[kReset] = true; + } + if (reset != null) { + socket[kReset] = reset; + } + if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { + socket[kReset] = true; + } + if (blocking) { + socket[kBlocking] = true; + } + let header = `${method} ${path2} HTTP/1.1\r +`; + if (typeof host === "string") { + header += `host: ${host}\r +`; + } else { + header += client[kHostHeader]; + } + if (upgrade) { + header += `connection: upgrade\r +upgrade: ${upgrade}\r +`; + } else if (client[kPipelining] && !socket[kReset]) { + header += "connection: keep-alive\r\n"; + } else { + header += "connection: close\r\n"; + } + if (headers) { + header += headers; + } + if (channels.sendHeaders.hasSubscribers) { + channels.sendHeaders.publish({ request, headers: header, socket }); + } + if (!body || bodyLength === 0) { + if (contentLength === 0) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + assert(contentLength === null, "no body must not have content length"); + socket.write(`${header}\r +`, "latin1"); + } + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(body); + socket.uncork(); + request.onBodySent(body); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload }); + } else { + writeBlob({ body, client, request, socket, contentLength, header, expectsPayload }); + } + } else if (util.isStream(body)) { + writeStream({ body, client, request, socket, contentLength, header, expectsPayload }); + } else if (util.isIterable(body)) { + writeIterable({ body, client, request, socket, contentLength, header, expectsPayload }); + } else { + assert(false); + } + return true; } - const response = await fetch(value.url); - return response.text(); -} -//# sourceMappingURL=unwrap.js.map - -/***/ }), - -/***/ 5786: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Builds = void 0; -const tslib_1 = __nccwpck_require__(533); -const resource_1 = __nccwpck_require__(283); -const DiagnosticsAPI = tslib_1.__importStar(__nccwpck_require__(3467)); -const diagnostics_1 = __nccwpck_require__(3467); -const TargetOutputsAPI = tslib_1.__importStar(__nccwpck_require__(4817)); -const target_outputs_1 = __nccwpck_require__(4817); -const pagination_1 = __nccwpck_require__(8575); -const path_1 = __nccwpck_require__(5580); -class Builds extends resource_1.APIResource { - constructor() { - super(...arguments); - this.diagnostics = new DiagnosticsAPI.Diagnostics(this._client); - this.targetOutputs = new TargetOutputsAPI.TargetOutputs(this._client); - } - /** - * Create a new build - */ - create(params, options) { - const { project = this._client.project, ...body } = params; - return this._client.post('/v0/builds', { body: { project, ...body }, ...options }); - } - /** - * Retrieve a build by ID - */ - retrieve(buildID, options) { - return this._client.get((0, path_1.path) `/v0/builds/${buildID}`, options); - } - /** - * List builds for a project - */ - list(params = {}, options) { - const { project = this._client.project, ...query } = params ?? {}; - return this._client.getAPIList('/v0/builds', (pagination_1.Page), { - query: { project, ...query }, - ...options, + function writeH2(client, session, request) { + const { body, method, path: path2, host, upgrade, expectContinue, signal, headers: reqHeaders } = request; + let headers; + if (typeof reqHeaders === "string") headers = Request[kHTTP2CopyHeaders](reqHeaders.trim()); + else headers = reqHeaders; + if (upgrade) { + errorRequest(client, request, new Error("Upgrade not supported for H2")); + return false; + } + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); }); - } - /** - * Creates two builds whose outputs can be compared directly - */ - compare(params, options) { - const { project = this._client.project, ...body } = params; - return this._client.post('/v0/builds/compare', { body: { project, ...body }, ...options }); - } -} -exports.Builds = Builds; -Builds.Diagnostics = diagnostics_1.Diagnostics; -Builds.TargetOutputs = target_outputs_1.TargetOutputs; -//# sourceMappingURL=builds.js.map - -/***/ }), - -/***/ 3467: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Diagnostics = void 0; -const resource_1 = __nccwpck_require__(283); -const pagination_1 = __nccwpck_require__(8575); -const path_1 = __nccwpck_require__(5580); -class Diagnostics extends resource_1.APIResource { - /** - * Get diagnostics for a build - */ - list(buildID, query = {}, options) { - return this._client.getAPIList((0, path_1.path) `/v0/builds/${buildID}/diagnostics`, (pagination_1.Page), { - query, - ...options, + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + let stream; + const h2State = client[kHTTP2SessionState]; + headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost]; + headers[HTTP2_HEADER_METHOD] = method; + if (method === "CONNECT") { + session.ref(); + stream = session.request(headers, { endStream: false, signal }); + if (stream.id && !stream.pending) { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + } else { + stream.once("ready", () => { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + }); + } + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) session.unref(); }); + return true; + } + headers[HTTP2_HEADER_PATH] = path2; + headers[HTTP2_HEADER_SCHEME] = "https"; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + let contentLength = util.bodyLength(body); + if (contentLength == null) { + contentLength = request.contentLength; + } + if (contentLength === 0 || !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + if (contentLength != null) { + assert(body, "no body must not have content length"); + headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`; + } + session.ref(); + const shouldEndStream = method === "GET" || method === "HEAD"; + if (expectContinue) { + headers[HTTP2_HEADER_EXPECT] = "100-continue"; + stream = session.request(headers, { endStream: shouldEndStream, signal }); + stream.once("continue", writeBodyH2); + } else { + stream = session.request(headers, { + endStream: shouldEndStream, + signal + }); + writeBodyH2(); + } + ++h2State.openStreams; + stream.once("response", (headers2) => { + const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2; + if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), "") === false) { + stream.pause(); + } + }); + stream.once("end", () => { + request.onComplete([]); + }); + stream.on("data", (chunk) => { + if (request.onData(chunk) === false) { + stream.pause(); + } + }); + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) { + session.unref(); + } + }); + stream.once("error", function(err) { + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + stream.once("frameError", (type, code) => { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + errorRequest(client, request, err); + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + return true; + function writeBodyH2() { + if (!body) { + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + stream.cork(); + stream.write(body); + stream.uncork(); + stream.end(); + request.onBodySent(body); + request.onRequestSent(); + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ + client, + request, + contentLength, + h2stream: stream, + expectsPayload, + body: body.stream(), + socket: client[kSocket], + header: "" + }); + } else { + writeBlob({ + body, + client, + request, + contentLength, + expectsPayload, + h2stream: stream, + header: "", + socket: client[kSocket] + }); + } + } else if (util.isStream(body)) { + writeStream({ + body, + client, + request, + contentLength, + expectsPayload, + socket: client[kSocket], + h2stream: stream, + header: "" + }); + } else if (util.isIterable(body)) { + writeIterable({ + body, + client, + request, + contentLength, + expectsPayload, + header: "", + h2stream: stream, + socket: client[kSocket] + }); + } else { + assert(false); + } + } } -} -exports.Diagnostics = Diagnostics; -//# sourceMappingURL=diagnostics.js.map - -/***/ }), - -/***/ 4817: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.TargetOutputs = void 0; -const resource_1 = __nccwpck_require__(283); -class TargetOutputs extends resource_1.APIResource { - /** - * Download the output of a build target - */ - retrieve(query, options) { - return this._client.get('/v0/build_target_outputs', { query, ...options }); - } -} -exports.TargetOutputs = TargetOutputs; -//# sourceMappingURL=target-outputs.js.map - -/***/ }), - -/***/ 786: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Generate = void 0; -const resource_1 = __nccwpck_require__(283); -class Generate extends resource_1.APIResource { - createSpec(params, options) { - const { project = this._client.project, ...body } = params; - return this._client.post('/v0/generate/spec', { body: { project, ...body }, ...options }); - } -} -exports.Generate = Generate; -//# sourceMappingURL=generate.js.map - -/***/ }), - -/***/ 9789: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Projects = exports.Orgs = exports.Generate = exports.Builds = void 0; -var builds_1 = __nccwpck_require__(5786); -Object.defineProperty(exports, "Builds", ({ enumerable: true, get: function () { return builds_1.Builds; } })); -var generate_1 = __nccwpck_require__(786); -Object.defineProperty(exports, "Generate", ({ enumerable: true, get: function () { return generate_1.Generate; } })); -var orgs_1 = __nccwpck_require__(9366); -Object.defineProperty(exports, "Orgs", ({ enumerable: true, get: function () { return orgs_1.Orgs; } })); -var projects_1 = __nccwpck_require__(8120); -Object.defineProperty(exports, "Projects", ({ enumerable: true, get: function () { return projects_1.Projects; } })); -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 9366: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Orgs = void 0; -const resource_1 = __nccwpck_require__(283); -const path_1 = __nccwpck_require__(5580); -class Orgs extends resource_1.APIResource { - /** - * Retrieve an organization by name - */ - retrieve(org, options) { - return this._client.get((0, path_1.path) `/v0/orgs/${org}`, options); - } - /** - * List organizations the user has access to - */ - list(options) { - return this._client.get('/v0/orgs', options); - } -} -exports.Orgs = Orgs; -//# sourceMappingURL=orgs.js.map - -/***/ }), - -/***/ 934: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Branches = void 0; -const resource_1 = __nccwpck_require__(283); -const path_1 = __nccwpck_require__(5580); -class Branches extends resource_1.APIResource { - /** - * Create a new branch for a project - */ - create(params, options) { - const { project = this._client.project, ...body } = params; - return this._client.post((0, path_1.path) `/v0/projects/${project}/branches`, { body, ...options }); - } - /** - * Retrieve a project branch - */ - retrieve(branch, params = {}, options) { - const { project = this._client.project } = params ?? {}; - return this._client.get((0, path_1.path) `/v0/projects/${project}/branches/${branch}`, options); - } -} -exports.Branches = Branches; -//# sourceMappingURL=branches.js.map - -/***/ }), - -/***/ 8471: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Configs = void 0; -const resource_1 = __nccwpck_require__(283); -const path_1 = __nccwpck_require__(5580); -class Configs extends resource_1.APIResource { - /** - * Retrieve configuration files for a project - */ - retrieve(params = {}, options) { - const { project = this._client.project, ...query } = params ?? {}; - return this._client.get((0, path_1.path) `/v0/projects/${project}/configs`, { query, ...options }); - } - /** - * Generate configuration suggestions based on an OpenAPI spec - */ - guess(params, options) { - const { project = this._client.project, ...body } = params; - return this._client.post((0, path_1.path) `/v0/projects/${project}/configs/guess`, { body, ...options }); - } -} -exports.Configs = Configs; -//# sourceMappingURL=configs.js.map - -/***/ }), - -/***/ 8120: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - -// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.Projects = void 0; -const tslib_1 = __nccwpck_require__(533); -const resource_1 = __nccwpck_require__(283); -const BranchesAPI = tslib_1.__importStar(__nccwpck_require__(934)); -const branches_1 = __nccwpck_require__(934); -const ConfigsAPI = tslib_1.__importStar(__nccwpck_require__(8471)); -const configs_1 = __nccwpck_require__(8471); -const pagination_1 = __nccwpck_require__(8575); -const path_1 = __nccwpck_require__(5580); -class Projects extends resource_1.APIResource { - constructor() { - super(...arguments); - this.branches = new BranchesAPI.Branches(this._client); - this.configs = new ConfigsAPI.Configs(this._client); - } - /** - * Create a new project - */ - create(body, options) { - return this._client.post('/v0/projects', { body, ...options }); - } - /** - * Retrieve a project by name - */ - retrieve(params = {}, options) { - const { project = this._client.project } = params ?? {}; - return this._client.get((0, path_1.path) `/v0/projects/${project}`, options); - } - /** - * Update a project's properties - */ - update(params = {}, options) { - const { project = this._client.project, ...body } = params ?? {}; - return this._client.patch((0, path_1.path) `/v0/projects/${project}`, { body, ...options }); - } - /** - * List projects in an organization, from oldest to newest - */ - list(query = {}, options) { - return this._client.getAPIList('/v0/projects', (pagination_1.Page), { query, ...options }); - } -} -exports.Projects = Projects; -Projects.Branches = branches_1.Branches; -Projects.Configs = configs_1.Configs; -//# sourceMappingURL=projects.js.map - -/***/ }), - -/***/ 8027: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.VERSION = void 0; -exports.VERSION = '0.1.0-alpha.11'; // x-release-please-version -//# sourceMappingURL=version.js.map - -/***/ }), - -/***/ 7349: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Scalar = __nccwpck_require__(3301); -var YAMLMap = __nccwpck_require__(4454); -var YAMLSeq = __nccwpck_require__(2223); -var resolveBlockMap = __nccwpck_require__(7103); -var resolveBlockSeq = __nccwpck_require__(334); -var resolveFlowCollection = __nccwpck_require__(3142); - -function resolveCollection(CN, ctx, token, onError, tagName, tag) { - const coll = token.type === 'block-map' - ? resolveBlockMap.resolveBlockMap(CN, ctx, token, onError, tag) - : token.type === 'block-seq' - ? resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError, tag) - : resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError, tag); - const Coll = coll.constructor; - // If we got a tagName matching the class, or the tag name is '!', - // then use the tagName from the node class used to create it. - if (tagName === '!' || tagName === Coll.tagName) { - coll.tag = Coll.tagName; - return coll; + function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + if (client[kHTTPConnVersion] === "h2") { + let onPipeData = function(chunk) { + request.onBodySent(chunk); + }; + const pipe = pipeline( + body, + h2stream, + (err) => { + if (err) { + util.destroy(body, err); + util.destroy(h2stream, err); + } else { + request.onRequestSent(); + } + } + ); + pipe.on("data", onPipeData); + pipe.once("end", () => { + pipe.removeListener("data", onPipeData); + util.destroy(pipe); + }); + return; + } + let finished = false; + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + const onData = function(chunk) { + if (finished) { + return; + } + try { + if (!writer.write(chunk) && this.pause) { + this.pause(); + } + } catch (err) { + util.destroy(this, err); + } + }; + const onDrain = function() { + if (finished) { + return; + } + if (body.resume) { + body.resume(); + } + }; + const onAbort = function() { + if (finished) { + return; + } + const err = new RequestAbortedError(); + queueMicrotask(() => onFinished(err)); + }; + const onFinished = function(err) { + if (finished) { + return; + } + finished = true; + assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); + socket.off("drain", onDrain).off("error", onFinished); + body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort); + if (!err) { + try { + writer.end(); + } catch (er) { + err = er; + } + } + writer.destroy(err); + if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) { + util.destroy(body, err); + } else { + util.destroy(body); + } + }; + body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort); + if (body.resume) { + body.resume(); + } + socket.on("drain", onDrain).on("error", onFinished); } - if (tagName) - coll.tag = tagName; - return coll; -} -function composeCollection(CN, ctx, token, props, onError) { - const tagToken = props.tag; - const tagName = !tagToken - ? null - : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg)); - if (token.type === 'block-seq') { - const { anchor, newlineAfterProp: nl } = props; - const lastProp = anchor && tagToken - ? anchor.offset > tagToken.offset - ? anchor - : tagToken - : (anchor ?? tagToken); - if (lastProp && (!nl || nl.offset < lastProp.offset)) { - const message = 'Missing newline after block sequence props'; - onError(lastProp, 'MISSING_CHAR', message); - } - } - const expType = token.type === 'block-map' - ? 'map' - : token.type === 'block-seq' - ? 'seq' - : token.start.source === '{' - ? 'map' - : 'seq'; - // shortcut: check if it's a generic YAMLMap or YAMLSeq - // before jumping into the custom tag logic. - if (!tagToken || - !tagName || - tagName === '!' || - (tagName === YAMLMap.YAMLMap.tagName && expType === 'map') || - (tagName === YAMLSeq.YAMLSeq.tagName && expType === 'seq')) { - return resolveCollection(CN, ctx, token, onError, tagName); + async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength === body.size, "blob body must have content length"); + const isH2 = client[kHTTPConnVersion] === "h2"; + try { + if (contentLength != null && contentLength !== body.size) { + throw new RequestContentLengthMismatchError(); + } + const buffer = Buffer.from(await body.arrayBuffer()); + if (isH2) { + h2stream.cork(); + h2stream.write(buffer); + h2stream.uncork(); + } else { + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(buffer); + socket.uncork(); + } + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + resume(client); + } catch (err) { + util.destroy(isH2 ? h2stream : socket, err); + } } - let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType); - if (!tag) { - const kt = ctx.schema.knownTags[tagName]; - if (kt && kt.collection === expType) { - ctx.schema.tags.push(Object.assign({}, kt, { default: false })); - tag = kt; + async function writeIterable({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve, reject) => { + assert(callback === null); + if (socket[kError]) { + reject(socket[kError]); + } else { + callback = resolve; + } + }); + if (client[kHTTPConnVersion] === "h2") { + h2stream.on("close", onDrain).on("drain", onDrain); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + const res = h2stream.write(chunk); + request.onBodySent(chunk); + if (!res) { + await waitForDrain(); + } + } + } catch (err) { + h2stream.destroy(err); + } finally { + request.onRequestSent(); + h2stream.end(); + h2stream.off("close", onDrain).off("drain", onDrain); + } + return; + } + socket.on("close", onDrain).on("drain", onDrain); + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + if (!writer.write(chunk)) { + await waitForDrain(); + } } - else { - if (kt) { - onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true); - } - else { - onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true); + writer.end(); + } catch (err) { + writer.destroy(err); + } finally { + socket.off("close", onDrain).off("drain", onDrain); + } + } + var AsyncWriter = class { + constructor({ socket, request, contentLength, client, expectsPayload, header }) { + this.socket = socket; + this.request = request; + this.contentLength = contentLength; + this.client = client; + this.bytesWritten = 0; + this.expectsPayload = expectsPayload; + this.header = header; + socket[kWriting] = true; + } + write(chunk) { + const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return false; + } + const len = Buffer.byteLength(chunk); + if (!len) { + return true; + } + if (contentLength !== null && bytesWritten + len > contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + socket.cork(); + if (bytesWritten === 0) { + if (!expectsPayload) { + socket[kReset] = true; + } + if (contentLength === null) { + socket.write(`${header}transfer-encoding: chunked\r +`, "latin1"); + } else { + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + } + } + if (contentLength === null) { + socket.write(`\r +${len.toString(16)}\r +`, "latin1"); + } + this.bytesWritten += len; + const ret = socket.write(chunk); + socket.uncork(); + request.onBodySent(chunk); + if (!ret) { + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); } - return resolveCollection(CN, ctx, token, onError, tagName); + } + } + return ret; + } + end() { + const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this; + request.onRequestSent(); + socket[kWriting] = false; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return; + } + if (bytesWritten === 0) { + if (expectsPayload) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + socket.write(`${header}\r +`, "latin1"); + } + } else if (contentLength === null) { + socket.write("\r\n0\r\n\r\n", "latin1"); + } + if (contentLength !== null && bytesWritten !== contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } else { + process.emitWarning(new RequestContentLengthMismatchError()); + } + } + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + resume(client); + } + destroy(err) { + const { socket, client } = this; + socket[kWriting] = false; + if (err) { + assert(client[kRunning] <= 1, "pipeline should only contain this request"); + util.destroy(socket, err); } + } + }; + function errorRequest(client, request, err) { + try { + request.onError(err); + assert(request.aborted); + } catch (err2) { + client.emit("error", err2); + } } - const coll = resolveCollection(CN, ctx, token, onError, tagName, tag); - const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll; - const node = identity.isNode(res) - ? res - : new Scalar.Scalar(res); - node.range = coll.range; - node.tag = tagName; - if (tag?.format) - node.format = tag.format; - return node; -} - -exports.composeCollection = composeCollection; - - -/***/ }), - -/***/ 3683: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Document = __nccwpck_require__(3021); -var composeNode = __nccwpck_require__(5937); -var resolveEnd = __nccwpck_require__(7788); -var resolveProps = __nccwpck_require__(4631); + module2.exports = Client; + } +}); -function composeDoc(options, directives, { offset, start, value, end }, onError) { - const opts = Object.assign({ _directives: directives }, options); - const doc = new Document.Document(undefined, opts); - const ctx = { - atKey: false, - atRoot: true, - directives: doc.directives, - options: doc.options, - schema: doc.schema +// node_modules/undici/lib/node/fixed-queue.js +var require_fixed_queue = __commonJS({ + "node_modules/undici/lib/node/fixed-queue.js"(exports2, module2) { + "use strict"; + var kSize = 2048; + var kMask = kSize - 1; + var FixedCircularBuffer = class { + constructor() { + this.bottom = 0; + this.top = 0; + this.list = new Array(kSize); + this.next = null; + } + isEmpty() { + return this.top === this.bottom; + } + isFull() { + return (this.top + 1 & kMask) === this.bottom; + } + push(data) { + this.list[this.top] = data; + this.top = this.top + 1 & kMask; + } + shift() { + const nextItem = this.list[this.bottom]; + if (nextItem === void 0) + return null; + this.list[this.bottom] = void 0; + this.bottom = this.bottom + 1 & kMask; + return nextItem; + } }; - const props = resolveProps.resolveProps(start, { - indicator: 'doc-start', - next: value ?? end?.[0], - offset, - onError, - parentIndent: 0, - startOnNewline: true - }); - if (props.found) { - doc.directives.docStart = true; - if (value && - (value.type === 'block-map' || value.type === 'block-seq') && - !props.hasNewline) - onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker'); - } - // @ts-expect-error If Contents is set, let's trust the user - doc.contents = value - ? composeNode.composeNode(ctx, value, props, onError) - : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError); - const contentEnd = doc.contents.range[2]; - const re = resolveEnd.resolveEnd(end, contentEnd, false, onError); - if (re.comment) - doc.comment = re.comment; - doc.range = [offset, contentEnd, re.offset]; - return doc; -} - -exports.composeDoc = composeDoc; - - -/***/ }), - -/***/ 5937: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - + module2.exports = class FixedQueue { + constructor() { + this.head = this.tail = new FixedCircularBuffer(); + } + isEmpty() { + return this.head.isEmpty(); + } + push(data) { + if (this.head.isFull()) { + this.head = this.head.next = new FixedCircularBuffer(); + } + this.head.push(data); + } + shift() { + const tail = this.tail; + const next = tail.shift(); + if (tail.isEmpty() && tail.next !== null) { + this.tail = tail.next; + } + return next; + } + }; + } +}); -var Alias = __nccwpck_require__(4065); -var identity = __nccwpck_require__(1127); -var composeCollection = __nccwpck_require__(7349); -var composeScalar = __nccwpck_require__(5413); -var resolveEnd = __nccwpck_require__(7788); -var utilEmptyScalarPosition = __nccwpck_require__(2599); +// node_modules/undici/lib/pool-stats.js +var require_pool_stats = __commonJS({ + "node_modules/undici/lib/pool-stats.js"(exports2, module2) { + var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols(); + var kPool = Symbol("pool"); + var PoolStats = class { + constructor(pool) { + this[kPool] = pool; + } + get connected() { + return this[kPool][kConnected]; + } + get free() { + return this[kPool][kFree]; + } + get pending() { + return this[kPool][kPending]; + } + get queued() { + return this[kPool][kQueued]; + } + get running() { + return this[kPool][kRunning]; + } + get size() { + return this[kPool][kSize]; + } + }; + module2.exports = PoolStats; + } +}); -const CN = { composeNode, composeEmptyNode }; -function composeNode(ctx, token, props, onError) { - const atKey = ctx.atKey; - const { spaceBefore, comment, anchor, tag } = props; - let node; - let isSrcToken = true; - switch (token.type) { - case 'alias': - node = composeAlias(ctx, token, onError); - if (anchor || tag) - onError(token, 'ALIAS_PROPS', 'An alias node must not specify any properties'); - break; - case 'scalar': - case 'single-quoted-scalar': - case 'double-quoted-scalar': - case 'block-scalar': - node = composeScalar.composeScalar(ctx, token, tag, onError); - if (anchor) - node.anchor = anchor.source.substring(1); - break; - case 'block-map': - case 'block-seq': - case 'flow-collection': - node = composeCollection.composeCollection(CN, ctx, token, props, onError); - if (anchor) - node.anchor = anchor.source.substring(1); +// node_modules/undici/lib/pool-base.js +var require_pool_base = __commonJS({ + "node_modules/undici/lib/pool-base.js"(exports2, module2) { + "use strict"; + var DispatcherBase = require_dispatcher_base(); + var FixedQueue = require_fixed_queue(); + var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols(); + var PoolStats = require_pool_stats(); + var kClients = Symbol("clients"); + var kNeedDrain = Symbol("needDrain"); + var kQueue = Symbol("queue"); + var kClosedResolve = Symbol("closed resolve"); + var kOnDrain = Symbol("onDrain"); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kGetDispatcher = Symbol("get dispatcher"); + var kAddClient = Symbol("add client"); + var kRemoveClient = Symbol("remove client"); + var kStats = Symbol("stats"); + var PoolBase = class extends DispatcherBase { + constructor() { + super(); + this[kQueue] = new FixedQueue(); + this[kClients] = []; + this[kQueued] = 0; + const pool = this; + this[kOnDrain] = function onDrain(origin, targets) { + const queue = pool[kQueue]; + let needDrain = false; + while (!needDrain) { + const item = queue.shift(); + if (!item) { + break; + } + pool[kQueued]--; + needDrain = !this.dispatch(item.opts, item.handler); + } + this[kNeedDrain] = needDrain; + if (!this[kNeedDrain] && pool[kNeedDrain]) { + pool[kNeedDrain] = false; + pool.emit("drain", origin, [pool, ...targets]); + } + if (pool[kClosedResolve] && queue.isEmpty()) { + Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]); + } + }; + this[kOnConnect] = (origin, targets) => { + pool.emit("connect", origin, [pool, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + pool.emit("disconnect", origin, [pool, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + pool.emit("connectionError", origin, [pool, ...targets], err); + }; + this[kStats] = new PoolStats(this); + } + get [kBusy]() { + return this[kNeedDrain]; + } + get [kConnected]() { + return this[kClients].filter((client) => client[kConnected]).length; + } + get [kFree]() { + return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length; + } + get [kPending]() { + let ret = this[kQueued]; + for (const { [kPending]: pending } of this[kClients]) { + ret += pending; + } + return ret; + } + get [kRunning]() { + let ret = 0; + for (const { [kRunning]: running } of this[kClients]) { + ret += running; + } + return ret; + } + get [kSize]() { + let ret = this[kQueued]; + for (const { [kSize]: size } of this[kClients]) { + ret += size; + } + return ret; + } + get stats() { + return this[kStats]; + } + async [kClose]() { + if (this[kQueue].isEmpty()) { + return Promise.all(this[kClients].map((c) => c.close())); + } else { + return new Promise((resolve) => { + this[kClosedResolve] = resolve; + }); + } + } + async [kDestroy](err) { + while (true) { + const item = this[kQueue].shift(); + if (!item) { break; - default: { - const message = token.type === 'error' - ? token.message - : `Unsupported token (type: ${token.type})`; - onError(token, 'UNEXPECTED_TOKEN', message); - node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError); - isSrcToken = false; - } - } - if (anchor && node.anchor === '') - onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string'); - if (atKey && - ctx.options.stringKeys && - (!identity.isScalar(node) || - typeof node.value !== 'string' || - (node.tag && node.tag !== 'tag:yaml.org,2002:str'))) { - const msg = 'With stringKeys, all keys must be strings'; - onError(tag ?? token, 'NON_STRING_KEY', msg); - } - if (spaceBefore) - node.spaceBefore = true; - if (comment) { - if (token.type === 'scalar' && token.source === '') - node.comment = comment; - else - node.commentBefore = comment; - } - // @ts-expect-error Type checking misses meaning of isSrcToken - if (ctx.options.keepSourceTokens && isSrcToken) - node.srcToken = token; - return node; -} -function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) { - const token = { - type: 'scalar', - offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos), - indent: -1, - source: '' + } + item.handler.onError(err); + } + return Promise.all(this[kClients].map((c) => c.destroy(err))); + } + [kDispatch](opts, handler) { + const dispatcher = this[kGetDispatcher](); + if (!dispatcher) { + this[kNeedDrain] = true; + this[kQueue].push({ opts, handler }); + this[kQueued]++; + } else if (!dispatcher.dispatch(opts, handler)) { + dispatcher[kNeedDrain] = true; + this[kNeedDrain] = !this[kGetDispatcher](); + } + return !this[kNeedDrain]; + } + [kAddClient](client) { + client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].push(client); + if (this[kNeedDrain]) { + process.nextTick(() => { + if (this[kNeedDrain]) { + this[kOnDrain](client[kUrl], [this, client]); + } + }); + } + return this; + } + [kRemoveClient](client) { + client.close(() => { + const idx = this[kClients].indexOf(client); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + }); + this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true); + } }; - const node = composeScalar.composeScalar(ctx, token, tag, onError); - if (anchor) { - node.anchor = anchor.source.substring(1); - if (node.anchor === '') - onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string'); - } - if (spaceBefore) - node.spaceBefore = true; - if (comment) { - node.comment = comment; - node.range[2] = end; - } - return node; -} -function composeAlias({ options }, { offset, source, end }, onError) { - const alias = new Alias.Alias(source.substring(1)); - if (alias.source === '') - onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string'); - if (alias.source.endsWith(':')) - onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true); - const valueEnd = offset + source.length; - const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError); - alias.range = [offset, valueEnd, re.offset]; - if (re.comment) - alias.comment = re.comment; - return alias; -} - -exports.composeEmptyNode = composeEmptyNode; -exports.composeNode = composeNode; - - -/***/ }), - -/***/ 5413: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Scalar = __nccwpck_require__(3301); -var resolveBlockScalar = __nccwpck_require__(8913); -var resolveFlowScalar = __nccwpck_require__(6842); + module2.exports = { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + }; + } +}); -function composeScalar(ctx, token, tagToken, onError) { - const { value, type, comment, range } = token.type === 'block-scalar' - ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) - : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError); - const tagName = tagToken - ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg)) - : null; - let tag; - if (ctx.options.stringKeys && ctx.atKey) { - tag = ctx.schema[identity.SCALAR]; - } - else if (tagName) - tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError); - else if (token.type === 'scalar') - tag = findScalarTagByTest(ctx, value, token, onError); - else - tag = ctx.schema[identity.SCALAR]; - let scalar; - try { - const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options); - scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res); - } - catch (error) { - const msg = error instanceof Error ? error.message : String(error); - onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg); - scalar = new Scalar.Scalar(value); - } - scalar.range = range; - scalar.source = value; - if (type) - scalar.type = type; - if (tagName) - scalar.tag = tagName; - if (tag.format) - scalar.format = tag.format; - if (comment) - scalar.comment = comment; - return scalar; -} -function findScalarTagByName(schema, value, tagName, tagToken, onError) { - if (tagName === '!') - return schema[identity.SCALAR]; // non-specific tag - const matchWithTest = []; - for (const tag of schema.tags) { - if (!tag.collection && tag.tag === tagName) { - if (tag.default && tag.test) - matchWithTest.push(tag); - else - return tag; +// node_modules/undici/lib/pool.js +var require_pool = __commonJS({ + "node_modules/undici/lib/pool.js"(exports2, module2) { + "use strict"; + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kGetDispatcher + } = require_pool_base(); + var Client = require_client(); + var { + InvalidArgumentError + } = require_errors2(); + var util = require_util(); + var { kUrl, kInterceptors } = require_symbols(); + var buildConnector = require_connect(); + var kOptions = Symbol("options"); + var kConnections = Symbol("connections"); + var kFactory = Symbol("factory"); + function defaultFactory(origin, opts) { + return new Client(origin, opts); + } + var Pool = class extends PoolBase { + constructor(origin, { + connections, + factory = defaultFactory, + connect, + connectTimeout, + tls, + maxCachedSessions, + socketPath, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + allowH2, + ...options + } = {}) { + super(); + if (connections != null && (!Number.isFinite(connections) || connections < 0)) { + throw new InvalidArgumentError("invalid connections"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (typeof connect !== "function") { + connect = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect + }); + } + this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : []; + this[kConnections] = connections || null; + this[kUrl] = util.parseOrigin(origin); + this[kOptions] = { ...util.deepClone(options), connect, allowH2 }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kFactory] = factory; + this.on("connectionError", (origin2, targets, error2) => { + for (const target of targets) { + const idx = this[kClients].indexOf(target); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + } + }); + } + [kGetDispatcher]() { + let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]); + if (dispatcher) { + return dispatcher; } - } - for (const tag of matchWithTest) - if (tag.test?.test(value)) - return tag; - const kt = schema.knownTags[tagName]; - if (kt && !kt.collection) { - // Ensure that the known tag is available for stringifying, - // but does not get used by default. - schema.tags.push(Object.assign({}, kt, { default: false, test: undefined })); - return kt; - } - onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str'); - return schema[identity.SCALAR]; -} -function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) { - const tag = schema.tags.find(tag => (tag.default === true || (atKey && tag.default === 'key')) && - tag.test?.test(value)) || schema[identity.SCALAR]; - if (schema.compat) { - const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ?? - schema[identity.SCALAR]; - if (tag.tag !== compat.tag) { - const ts = directives.tagString(tag.tag); - const cs = directives.tagString(compat.tag); - const msg = `Value may be parsed as either ${ts} or ${cs}`; - onError(token, 'TAG_RESOLVE_FAILED', msg, true); + if (!this[kConnections] || this[kClients].length < this[kConnections]) { + dispatcher = this[kFactory](this[kUrl], this[kOptions]); + this[kAddClient](dispatcher); } - } - return tag; -} - -exports.composeScalar = composeScalar; - - -/***/ }), - -/***/ 9984: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var node_process = __nccwpck_require__(932); -var directives = __nccwpck_require__(1342); -var Document = __nccwpck_require__(3021); -var errors = __nccwpck_require__(1464); -var identity = __nccwpck_require__(1127); -var composeDoc = __nccwpck_require__(3683); -var resolveEnd = __nccwpck_require__(7788); + return dispatcher; + } + }; + module2.exports = Pool; + } +}); -function getErrorPos(src) { - if (typeof src === 'number') - return [src, src + 1]; - if (Array.isArray(src)) - return src.length === 2 ? src : [src[0], src[1]]; - const { offset, source } = src; - return [offset, offset + (typeof source === 'string' ? source.length : 1)]; -} -function parsePrelude(prelude) { - let comment = ''; - let atComment = false; - let afterEmptyLine = false; - for (let i = 0; i < prelude.length; ++i) { - const source = prelude[i]; - switch (source[0]) { - case '#': - comment += - (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') + - (source.substring(1) || ' '); - atComment = true; - afterEmptyLine = false; - break; - case '%': - if (prelude[i + 1]?.[0] !== '#') - i += 1; - atComment = false; - break; - default: - // This may be wrong after doc-end, but in that case it doesn't matter - if (!atComment) - afterEmptyLine = true; - atComment = false; +// node_modules/undici/lib/balanced-pool.js +var require_balanced_pool = __commonJS({ + "node_modules/undici/lib/balanced-pool.js"(exports2, module2) { + "use strict"; + var { + BalancedPoolMissingUpstreamError, + InvalidArgumentError + } = require_errors2(); + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + } = require_pool_base(); + var Pool = require_pool(); + var { kUrl, kInterceptors } = require_symbols(); + var { parseOrigin } = require_util(); + var kFactory = Symbol("factory"); + var kOptions = Symbol("options"); + var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor"); + var kCurrentWeight = Symbol("kCurrentWeight"); + var kIndex = Symbol("kIndex"); + var kWeight = Symbol("kWeight"); + var kMaxWeightPerServer = Symbol("kMaxWeightPerServer"); + var kErrorPenalty = Symbol("kErrorPenalty"); + function getGreatestCommonDivisor(a, b) { + if (b === 0) return a; + return getGreatestCommonDivisor(b, a % b); + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var BalancedPool = class extends PoolBase { + constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) { + super(); + this[kOptions] = opts; + this[kIndex] = -1; + this[kCurrentWeight] = 0; + this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100; + this[kErrorPenalty] = this[kOptions].errorPenalty || 15; + if (!Array.isArray(upstreams)) { + upstreams = [upstreams]; + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : []; + this[kFactory] = factory; + for (const upstream of upstreams) { + this.addUpstream(upstream); + } + this._updateBalancedPoolStats(); + } + addUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) { + return this; + } + const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions])); + this[kAddClient](pool); + pool.on("connect", () => { + pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]); + }); + pool.on("connectionError", () => { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + }); + pool.on("disconnect", (...args) => { + const err = args[2]; + if (err && err.code === "UND_ERR_SOCKET") { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + } + }); + for (const client of this[kClients]) { + client[kWeight] = this[kMaxWeightPerServer]; } - } - return { comment, afterEmptyLine }; -} -/** - * Compose a stream of CST nodes into a stream of YAML Documents. - * - * ```ts - * import { Composer, Parser } from 'yaml' - * - * const src: string = ... - * const tokens = new Parser().parse(src) - * const docs = new Composer().compose(tokens) - * ``` - */ -class Composer { - constructor(options = {}) { - this.doc = null; - this.atDirectives = false; - this.prelude = []; - this.errors = []; - this.warnings = []; - this.onError = (source, code, message, warning) => { - const pos = getErrorPos(source); - if (warning) - this.warnings.push(new errors.YAMLWarning(pos, code, message)); - else - this.errors.push(new errors.YAMLParseError(pos, code, message)); - }; - // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing - this.directives = new directives.Directives({ version: options.version || '1.2' }); - this.options = options; - } - decorate(doc, afterDoc) { - const { comment, afterEmptyLine } = parsePrelude(this.prelude); - //console.log({ dc: doc.comment, prelude, comment }) - if (comment) { - const dc = doc.contents; - if (afterDoc) { - doc.comment = doc.comment ? `${doc.comment}\n${comment}` : comment; - } - else if (afterEmptyLine || doc.directives.docStart || !dc) { - doc.commentBefore = comment; - } - else if (identity.isCollection(dc) && !dc.flow && dc.items.length > 0) { - let it = dc.items[0]; - if (identity.isPair(it)) - it = it.key; - const cb = it.commentBefore; - it.commentBefore = cb ? `${comment}\n${cb}` : comment; - } - else { - const cb = dc.commentBefore; - dc.commentBefore = cb ? `${comment}\n${cb}` : comment; - } + this._updateBalancedPoolStats(); + return this; + } + _updateBalancedPoolStats() { + this[kGreatestCommonDivisor] = this[kClients].map((p) => p[kWeight]).reduce(getGreatestCommonDivisor, 0); + } + removeUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true); + if (pool) { + this[kRemoveClient](pool); } - if (afterDoc) { - Array.prototype.push.apply(doc.errors, this.errors); - Array.prototype.push.apply(doc.warnings, this.warnings); + return this; + } + get upstreams() { + return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin); + } + [kGetDispatcher]() { + if (this[kClients].length === 0) { + throw new BalancedPoolMissingUpstreamError(); + } + const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true); + if (!dispatcher) { + return; + } + const allClientsBusy = this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true); + if (allClientsBusy) { + return; + } + let counter = 0; + let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]); + while (counter++ < this[kClients].length) { + this[kIndex] = (this[kIndex] + 1) % this[kClients].length; + const pool = this[kClients][this[kIndex]]; + if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) { + maxWeightIndex = this[kIndex]; + } + if (this[kIndex] === 0) { + this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]; + if (this[kCurrentWeight] <= 0) { + this[kCurrentWeight] = this[kMaxWeightPerServer]; + } + } + if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) { + return pool; + } } - else { - doc.errors = this.errors; - doc.warnings = this.warnings; + this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]; + this[kIndex] = maxWeightIndex; + return this[kClients][maxWeightIndex]; + } + }; + module2.exports = BalancedPool; + } +}); + +// node_modules/undici/lib/compat/dispatcher-weakref.js +var require_dispatcher_weakref = __commonJS({ + "node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module2) { + "use strict"; + var { kConnected, kSize } = require_symbols(); + var CompatWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value; + } + }; + var CompatFinalizer = class { + constructor(finalizer) { + this.finalizer = finalizer; + } + register(dispatcher, key) { + if (dispatcher.on) { + dispatcher.on("disconnect", () => { + if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) { + this.finalizer(key); + } + }); } - this.prelude = []; - this.errors = []; - this.warnings = []; - } - /** - * Current stream status information. - * - * Mostly useful at the end of input for an empty stream. - */ - streamInfo() { + } + }; + module2.exports = function() { + if (process.env.NODE_V8_COVERAGE) { return { - comment: parsePrelude(this.prelude).comment, - directives: this.directives, - errors: this.errors, - warnings: this.warnings + WeakRef: CompatWeakRef, + FinalizationRegistry: CompatFinalizer }; - } - /** - * Compose tokens into documents. - * - * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document. - * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly. - */ - *compose(tokens, forceDoc = false, endOffset = -1) { - for (const token of tokens) - yield* this.next(token); - yield* this.end(forceDoc, endOffset); - } - /** Advance the composer by one CST token. */ - *next(token) { - if (node_process.env.LOG_STREAM) - console.dir(token, { depth: null }); - switch (token.type) { - case 'directive': - this.directives.add(token.source, (offset, message, warning) => { - const pos = getErrorPos(token); - pos[0] += offset; - this.onError(pos, 'BAD_DIRECTIVE', message, warning); - }); - this.prelude.push(token.source); - this.atDirectives = true; - break; - case 'document': { - const doc = composeDoc.composeDoc(this.options, this.directives, token, this.onError); - if (this.atDirectives && !doc.directives.docStart) - this.onError(token, 'MISSING_CHAR', 'Missing directives-end/doc-start indicator line'); - this.decorate(doc, false); - if (this.doc) - yield this.doc; - this.doc = doc; - this.atDirectives = false; - break; - } - case 'byte-order-mark': - case 'space': - break; - case 'comment': - case 'newline': - this.prelude.push(token.source); - break; - case 'error': { - const msg = token.source - ? `${token.message}: ${JSON.stringify(token.source)}` - : token.message; - const error = new errors.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg); - if (this.atDirectives || !this.doc) - this.errors.push(error); - else - this.doc.errors.push(error); - break; - } - case 'doc-end': { - if (!this.doc) { - const msg = 'Unexpected doc-end without preceding document'; - this.errors.push(new errors.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg)); - break; - } - this.doc.directives.docEnd = true; - const end = resolveEnd.resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError); - this.decorate(this.doc, true); - if (end.comment) { - const dc = this.doc.comment; - this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment; - } - this.doc.range[2] = end.offset; - break; + } + return { + WeakRef: global.WeakRef || CompatWeakRef, + FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer + }; + }; + } +}); + +// node_modules/undici/lib/agent.js +var require_agent = __commonJS({ + "node_modules/undici/lib/agent.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError } = require_errors2(); + var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); + var DispatcherBase = require_dispatcher_base(); + var Pool = require_pool(); + var Client = require_client(); + var util = require_util(); + var createRedirectInterceptor = require_redirectInterceptor(); + var { WeakRef: WeakRef2, FinalizationRegistry } = require_dispatcher_weakref()(); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kMaxRedirections = Symbol("maxRedirections"); + var kOnDrain = Symbol("onDrain"); + var kFactory = Symbol("factory"); + var kFinalizer = Symbol("finalizer"); + var kOptions = Symbol("options"); + function defaultFactory(origin, opts) { + return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts); + } + var Agent = class extends DispatcherBase { + constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { + super(); + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (!Number.isInteger(maxRedirections) || maxRedirections < 0) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (connect && typeof connect !== "function") { + connect = { ...connect }; + } + this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })]; + this[kOptions] = { ...util.deepClone(options), connect }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kMaxRedirections] = maxRedirections; + this[kFactory] = factory; + this[kClients] = /* @__PURE__ */ new Map(); + this[kFinalizer] = new FinalizationRegistry( + /* istanbul ignore next: gc is undeterministic */ + (key) => { + const ref = this[kClients].get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this[kClients].delete(key); } - default: - this.errors.push(new errors.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', `Unsupported token ${token.type}`)); + } + ); + const agent = this; + this[kOnDrain] = (origin, targets) => { + agent.emit("drain", origin, [agent, ...targets]); + }; + this[kOnConnect] = (origin, targets) => { + agent.emit("connect", origin, [agent, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + agent.emit("disconnect", origin, [agent, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + agent.emit("connectionError", origin, [agent, ...targets], err); + }; + } + get [kRunning]() { + let ret = 0; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + ret += client[kRunning]; + } } - } - /** - * Call at end of input to yield any remaining document. - * - * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document. - * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly. - */ - *end(forceDoc = false, endOffset = -1) { - if (this.doc) { - this.decorate(this.doc, true); - yield this.doc; - this.doc = null; - } - else if (forceDoc) { - const opts = Object.assign({ _directives: this.directives }, this.options); - const doc = new Document.Document(undefined, opts); - if (this.atDirectives) - this.onError(endOffset, 'MISSING_CHAR', 'Missing directives-end indicator line'); - doc.range = [0, endOffset, endOffset]; - this.decorate(doc, false); - yield doc; + return ret; + } + [kDispatch](opts, handler) { + let key; + if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) { + key = String(opts.origin); + } else { + throw new InvalidArgumentError("opts.origin must be a non-empty string or URL."); + } + const ref = this[kClients].get(key); + let dispatcher = ref ? ref.deref() : null; + if (!dispatcher) { + dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].set(key, new WeakRef2(dispatcher)); + this[kFinalizer].register(dispatcher, key); + } + return dispatcher.dispatch(opts, handler); + } + async [kClose]() { + const closePromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + closePromises.push(client.close()); + } } - } -} - -exports.Composer = Composer; - - -/***/ }), - -/***/ 7103: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Pair = __nccwpck_require__(7165); -var YAMLMap = __nccwpck_require__(4454); -var resolveProps = __nccwpck_require__(4631); -var utilContainsNewline = __nccwpck_require__(9499); -var utilFlowIndentCheck = __nccwpck_require__(4051); -var utilMapIncludes = __nccwpck_require__(1187); + await Promise.all(closePromises); + } + async [kDestroy](err) { + const destroyPromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + destroyPromises.push(client.destroy(err)); + } + } + await Promise.all(destroyPromises); + } + }; + module2.exports = Agent; + } +}); -const startColMsg = 'All mapping items must start at the same column'; -function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) { - const NodeClass = tag?.nodeClass ?? YAMLMap.YAMLMap; - const map = new NodeClass(ctx.schema); - if (ctx.atRoot) - ctx.atRoot = false; - let offset = bm.offset; - let commentEnd = null; - for (const collItem of bm.items) { - const { start, key, sep, value } = collItem; - // key properties - const keyProps = resolveProps.resolveProps(start, { - indicator: 'explicit-key-ind', - next: key ?? sep?.[0], - offset, - onError, - parentIndent: bm.indent, - startOnNewline: true +// node_modules/undici/lib/api/readable.js +var require_readable = __commonJS({ + "node_modules/undici/lib/api/readable.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { Readable } = require("stream"); + var { RequestAbortedError, NotSupportedError, InvalidArgumentError } = require_errors2(); + var util = require_util(); + var { ReadableStreamFrom: ReadableStreamFrom2, toUSVString } = require_util(); + var Blob2; + var kConsume = Symbol("kConsume"); + var kReading = Symbol("kReading"); + var kBody = Symbol("kBody"); + var kAbort = Symbol("abort"); + var kContentType = Symbol("kContentType"); + var noop2 = () => { + }; + module2.exports = class BodyReadable extends Readable { + constructor({ + resume, + abort, + contentType = "", + highWaterMark = 64 * 1024 + // Same as nodejs fs streams. + }) { + super({ + autoDestroy: true, + read: resume, + highWaterMark }); - const implicitKey = !keyProps.found; - if (implicitKey) { - if (key) { - if (key.type === 'block-seq') - onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'A block sequence may not be used as an implicit map key'); - else if ('indent' in key && key.indent !== bm.indent) - onError(offset, 'BAD_INDENT', startColMsg); - } - if (!keyProps.anchor && !keyProps.tag && !sep) { - commentEnd = keyProps.end; - if (keyProps.comment) { - if (map.comment) - map.comment += '\n' + keyProps.comment; - else - map.comment = keyProps.comment; - } - continue; - } - if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key)) { - onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line'); - } + this._readableState.dataEmitted = false; + this[kAbort] = abort; + this[kConsume] = null; + this[kBody] = null; + this[kContentType] = contentType; + this[kReading] = false; + } + destroy(err) { + if (this.destroyed) { + return this; } - else if (keyProps.found?.indent !== bm.indent) { - onError(offset, 'BAD_INDENT', startColMsg); + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); } - // key value - ctx.atKey = true; - const keyStart = keyProps.end; - const keyNode = key - ? composeNode(ctx, key, keyProps, onError) - : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError); - if (ctx.schema.compat) - utilFlowIndentCheck.flowIndentCheck(bm.indent, key, onError); - ctx.atKey = false; - if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode)) - onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique'); - // value properties - const valueProps = resolveProps.resolveProps(sep ?? [], { - indicator: 'map-value-ind', - next: value, - offset: keyNode.range[2], - onError, - parentIndent: bm.indent, - startOnNewline: !key || key.type === 'block-scalar' - }); - offset = valueProps.end; - if (valueProps.found) { - if (implicitKey) { - if (value?.type === 'block-map' && !valueProps.hasNewline) - onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'Nested mappings are not allowed in compact mappings'); - if (ctx.options.strict && - keyProps.start < valueProps.found.offset - 1024) - onError(keyNode.range, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit block mapping key'); - } - // value value - const valueNode = value - ? composeNode(ctx, value, valueProps, onError) - : composeEmptyNode(ctx, offset, sep, null, valueProps, onError); - if (ctx.schema.compat) - utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError); - offset = valueNode.range[2]; - const pair = new Pair.Pair(keyNode, valueNode); - if (ctx.options.keepSourceTokens) - pair.srcToken = collItem; - map.items.push(pair); + if (err) { + this[kAbort](); } - else { - // key with no value - if (implicitKey) - onError(keyNode.range, 'MISSING_CHAR', 'Implicit map keys need to be followed by map values'); - if (valueProps.comment) { - if (keyNode.comment) - keyNode.comment += '\n' + valueProps.comment; - else - keyNode.comment = valueProps.comment; - } - const pair = new Pair.Pair(keyNode); - if (ctx.options.keepSourceTokens) - pair.srcToken = collItem; - map.items.push(pair); + return super.destroy(err); + } + emit(ev, ...args) { + if (ev === "data") { + this._readableState.dataEmitted = true; + } else if (ev === "error") { + this._readableState.errorEmitted = true; } - } - if (commentEnd && commentEnd < offset) - onError(commentEnd, 'IMPOSSIBLE', 'Map comment with trailing content'); - map.range = [bm.offset, offset, commentEnd ?? offset]; - return map; -} - -exports.resolveBlockMap = resolveBlockMap; - - -/***/ }), - -/***/ 8913: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Scalar = __nccwpck_require__(3301); - -function resolveBlockScalar(ctx, scalar, onError) { - const start = scalar.offset; - const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError); - if (!header) - return { value: '', type: null, comment: '', range: [start, start, start] }; - const type = header.mode === '>' ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL; - const lines = scalar.source ? splitLines(scalar.source) : []; - // determine the end of content & start of chomping - let chompStart = lines.length; - for (let i = lines.length - 1; i >= 0; --i) { - const content = lines[i][1]; - if (content === '' || content === '\r') - chompStart = i; - else - break; - } - // shortcut for empty contents - if (chompStart === 0) { - const value = header.chomp === '+' && lines.length > 0 - ? '\n'.repeat(Math.max(1, lines.length - 1)) - : ''; - let end = start + header.length; - if (scalar.source) - end += scalar.source.length; - return { value, type, comment: header.comment, range: [start, end, end] }; - } - // find the indentation level to trim from start - let trimIndent = scalar.indent + header.indent; - let offset = scalar.offset + header.length; - let contentStart = 0; - for (let i = 0; i < chompStart; ++i) { - const [indent, content] = lines[i]; - if (content === '' || content === '\r') { - if (header.indent === 0 && indent.length > trimIndent) - trimIndent = indent.length; + return super.emit(ev, ...args); + } + on(ev, ...args) { + if (ev === "data" || ev === "readable") { + this[kReading] = true; } - else { - if (indent.length < trimIndent) { - const message = 'Block scalars with more-indented leading empty lines must use an explicit indentation indicator'; - onError(offset + indent.length, 'MISSING_CHAR', message); - } - if (header.indent === 0) - trimIndent = indent.length; - contentStart = i; - if (trimIndent === 0 && !ctx.atRoot) { - const message = 'Block scalar values in collections must be indented'; - onError(offset, 'BAD_INDENT', message); - } - break; + return super.on(ev, ...args); + } + addListener(ev, ...args) { + return this.on(ev, ...args); + } + off(ev, ...args) { + const ret = super.off(ev, ...args); + if (ev === "data" || ev === "readable") { + this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0; } - offset += indent.length + content.length + 1; - } - // include trailing more-indented empty lines in content - for (let i = lines.length - 1; i >= chompStart; --i) { - if (lines[i][0].length > trimIndent) - chompStart = i + 1; - } - let value = ''; - let sep = ''; - let prevMoreIndented = false; - // leading whitespace is kept intact - for (let i = 0; i < contentStart; ++i) - value += lines[i][0].slice(trimIndent) + '\n'; - for (let i = contentStart; i < chompStart; ++i) { - let [indent, content] = lines[i]; - offset += indent.length + content.length + 1; - const crlf = content[content.length - 1] === '\r'; - if (crlf) - content = content.slice(0, -1); - /* istanbul ignore if already caught in lexer */ - if (content && indent.length < trimIndent) { - const src = header.indent - ? 'explicit indentation indicator' - : 'first line'; - const message = `Block scalar lines must not be less indented than their ${src}`; - onError(offset - content.length - (crlf ? 2 : 1), 'BAD_INDENT', message); - indent = ''; + return ret; + } + removeListener(ev, ...args) { + return this.off(ev, ...args); + } + push(chunk) { + if (this[kConsume] && chunk !== null && this.readableLength === 0) { + consumePush(this[kConsume], chunk); + return this[kReading] ? super.push(chunk) : true; } - if (type === Scalar.Scalar.BLOCK_LITERAL) { - value += sep + indent.slice(trimIndent) + content; - sep = '\n'; - } - else if (indent.length > trimIndent || content[0] === '\t') { - // more-indented content within a folded block - if (sep === ' ') - sep = '\n'; - else if (!prevMoreIndented && sep === '\n') - sep = '\n\n'; - value += sep + indent.slice(trimIndent) + content; - sep = '\n'; - prevMoreIndented = true; - } - else if (content === '') { - // empty line - if (sep === '\n') - value += '\n'; - else - sep = '\n'; + return super.push(chunk); + } + // https://fetch.spec.whatwg.org/#dom-body-text + async text() { + return consume(this, "text"); + } + // https://fetch.spec.whatwg.org/#dom-body-json + async json() { + return consume(this, "json"); + } + // https://fetch.spec.whatwg.org/#dom-body-blob + async blob() { + return consume(this, "blob"); + } + // https://fetch.spec.whatwg.org/#dom-body-arraybuffer + async arrayBuffer() { + return consume(this, "arrayBuffer"); + } + // https://fetch.spec.whatwg.org/#dom-body-formdata + async formData() { + throw new NotSupportedError(); + } + // https://fetch.spec.whatwg.org/#dom-body-bodyused + get bodyUsed() { + return util.isDisturbed(this); + } + // https://fetch.spec.whatwg.org/#dom-body-body + get body() { + if (!this[kBody]) { + this[kBody] = ReadableStreamFrom2(this); + if (this[kConsume]) { + this[kBody].getReader(); + assert(this[kBody].locked); + } } - else { - value += sep + content; - sep = ' '; - prevMoreIndented = false; + return this[kBody]; + } + dump(opts) { + let limit2 = opts && Number.isFinite(opts.limit) ? opts.limit : 262144; + const signal = opts && opts.signal; + if (signal) { + try { + if (typeof signal !== "object" || !("aborted" in signal)) { + throw new InvalidArgumentError("signal must be an AbortSignal"); + } + util.throwIfAborted(signal); + } catch (err) { + return Promise.reject(err); + } } + if (this.closed) { + return Promise.resolve(null); + } + return new Promise((resolve, reject) => { + const signalListenerCleanup = signal ? util.addAbortListener(signal, () => { + this.destroy(); + }) : noop2; + this.on("close", function() { + signalListenerCleanup(); + if (signal && signal.aborted) { + reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" })); + } else { + resolve(null); + } + }).on("error", noop2).on("data", function(chunk) { + limit2 -= chunk.length; + if (limit2 <= 0) { + this.destroy(); + } + }).resume(); + }); + } + }; + function isLocked(self) { + return self[kBody] && self[kBody].locked === true || self[kConsume]; } - switch (header.chomp) { - case '-': - break; - case '+': - for (let i = chompStart; i < lines.length; ++i) - value += '\n' + lines[i][0].slice(trimIndent); - if (value[value.length - 1] !== '\n') - value += '\n'; - break; - default: - value += '\n'; + function isUnusable(self) { + return util.isDisturbed(self) || isLocked(self); } - const end = start + header.length + scalar.source.length; - return { value, type, comment: header.comment, range: [start, end, end] }; -} -function parseBlockScalarHeader({ offset, props }, strict, onError) { - /* istanbul ignore if should not happen */ - if (props[0].type !== 'block-scalar-header') { - onError(props[0], 'IMPOSSIBLE', 'Block scalar header not found'); - return null; + async function consume(stream, type) { + if (isUnusable(stream)) { + throw new TypeError("unusable"); + } + assert(!stream[kConsume]); + return new Promise((resolve, reject) => { + stream[kConsume] = { + type, + stream, + resolve, + reject, + length: 0, + body: [] + }; + stream.on("error", function(err) { + consumeFinish(this[kConsume], err); + }).on("close", function() { + if (this[kConsume].body !== null) { + consumeFinish(this[kConsume], new RequestAbortedError()); + } + }); + process.nextTick(consumeStart, stream[kConsume]); + }); } - const { source } = props[0]; - const mode = source[0]; - let indent = 0; - let chomp = ''; - let error = -1; - for (let i = 1; i < source.length; ++i) { - const ch = source[i]; - if (!chomp && (ch === '-' || ch === '+')) - chomp = ch; - else { - const n = Number(ch); - if (!indent && n) - indent = n; - else if (error === -1) - error = offset + i; - } - } - if (error !== -1) - onError(error, 'UNEXPECTED_TOKEN', `Block scalar header includes extra characters: ${source}`); - let hasSpace = false; - let comment = ''; - let length = source.length; - for (let i = 1; i < props.length; ++i) { - const token = props[i]; - switch (token.type) { - case 'space': - hasSpace = true; - // fallthrough - case 'newline': - length += token.source.length; - break; - case 'comment': - if (strict && !hasSpace) { - const message = 'Comments must be separated from other tokens by white space characters'; - onError(token, 'MISSING_CHAR', message); - } - length += token.source.length; - comment = token.source.substring(1); - break; - case 'error': - onError(token, 'UNEXPECTED_TOKEN', token.message); - length += token.source.length; - break; - /* istanbul ignore next should not happen */ - default: { - const message = `Unexpected token in block scalar header: ${token.type}`; - onError(token, 'UNEXPECTED_TOKEN', message); - const ts = token.source; - if (ts && typeof ts === 'string') - length += ts.length; - } + function consumeStart(consume2) { + if (consume2.body === null) { + return; + } + const { _readableState: state } = consume2.stream; + for (const chunk of state.buffer) { + consumePush(consume2, chunk); + } + if (state.endEmitted) { + consumeEnd(this[kConsume]); + } else { + consume2.stream.on("end", function() { + consumeEnd(this[kConsume]); + }); + } + consume2.stream.resume(); + while (consume2.stream.read() != null) { + } + } + function consumeEnd(consume2) { + const { type, body, resolve, stream, length } = consume2; + try { + if (type === "text") { + resolve(toUSVString(Buffer.concat(body))); + } else if (type === "json") { + resolve(JSON.parse(Buffer.concat(body))); + } else if (type === "arrayBuffer") { + const dst = new Uint8Array(length); + let pos = 0; + for (const buf of body) { + dst.set(buf, pos); + pos += buf.byteLength; + } + resolve(dst.buffer); + } else if (type === "blob") { + if (!Blob2) { + Blob2 = require("buffer").Blob; + } + resolve(new Blob2(body, { type: stream[kContentType] })); } + consumeFinish(consume2); + } catch (err) { + stream.destroy(err); + } } - return { mode, indent, chomp, comment, length }; -} -/** @returns Array of lines split up as `[indent, content]` */ -function splitLines(source) { - const split = source.split(/\n( *)/); - const first = split[0]; - const m = first.match(/^( *)/); - const line0 = m?.[1] - ? [m[1], first.slice(m[1].length)] - : ['', first]; - const lines = [line0]; - for (let i = 1; i < split.length; i += 2) - lines.push([split[i], split[i + 1]]); - return lines; -} - -exports.resolveBlockScalar = resolveBlockScalar; - - -/***/ }), - -/***/ 334: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; + function consumePush(consume2, chunk) { + consume2.length += chunk.length; + consume2.body.push(chunk); + } + function consumeFinish(consume2, err) { + if (consume2.body === null) { + return; + } + if (err) { + consume2.reject(err); + } else { + consume2.resolve(); + } + consume2.type = null; + consume2.stream = null; + consume2.resolve = null; + consume2.reject = null; + consume2.length = 0; + consume2.body = null; + } + } +}); +// node_modules/undici/lib/api/util.js +var require_util3 = __commonJS({ + "node_modules/undici/lib/api/util.js"(exports2, module2) { + var assert = require("assert"); + var { + ResponseStatusCodeError + } = require_errors2(); + var { toUSVString } = require_util(); + async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) { + assert(body); + let chunks = []; + let limit2 = 0; + for await (const chunk of body) { + chunks.push(chunk); + limit2 += chunk.length; + if (limit2 > 128 * 1024) { + chunks = null; + break; + } + } + if (statusCode === 204 || !contentType || !chunks) { + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + return; + } + try { + if (contentType.startsWith("application/json")) { + const payload = JSON.parse(toUSVString(Buffer.concat(chunks))); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + if (contentType.startsWith("text/")) { + const payload = toUSVString(Buffer.concat(chunks)); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + } catch (err) { + } + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + } + module2.exports = { getResolveErrorBodyCallback }; + } +}); -var YAMLSeq = __nccwpck_require__(2223); -var resolveProps = __nccwpck_require__(4631); -var utilFlowIndentCheck = __nccwpck_require__(4051); +// node_modules/undici/lib/api/abort-signal.js +var require_abort_signal = __commonJS({ + "node_modules/undici/lib/api/abort-signal.js"(exports2, module2) { + var { addAbortListener } = require_util(); + var { RequestAbortedError } = require_errors2(); + var kListener = Symbol("kListener"); + var kSignal = Symbol("kSignal"); + function abort(self) { + if (self.abort) { + self.abort(); + } else { + self.onError(new RequestAbortedError()); + } + } + function addSignal(self, signal) { + self[kSignal] = null; + self[kListener] = null; + if (!signal) { + return; + } + if (signal.aborted) { + abort(self); + return; + } + self[kSignal] = signal; + self[kListener] = () => { + abort(self); + }; + addAbortListener(self[kSignal], self[kListener]); + } + function removeSignal(self) { + if (!self[kSignal]) { + return; + } + if ("removeEventListener" in self[kSignal]) { + self[kSignal].removeEventListener("abort", self[kListener]); + } else { + self[kSignal].removeListener("abort", self[kListener]); + } + self[kSignal] = null; + self[kListener] = null; + } + module2.exports = { + addSignal, + removeSignal + }; + } +}); -function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) { - const NodeClass = tag?.nodeClass ?? YAMLSeq.YAMLSeq; - const seq = new NodeClass(ctx.schema); - if (ctx.atRoot) - ctx.atRoot = false; - if (ctx.atKey) - ctx.atKey = false; - let offset = bs.offset; - let commentEnd = null; - for (const { start, value } of bs.items) { - const props = resolveProps.resolveProps(start, { - indicator: 'seq-item-ind', - next: value, - offset, - onError, - parentIndent: bs.indent, - startOnNewline: true +// node_modules/undici/lib/api/api-request.js +var require_api_request = __commonJS({ + "node_modules/undici/lib/api/api-request.js"(exports2, module2) { + "use strict"; + var Readable = require_readable(); + var { + InvalidArgumentError, + RequestAbortedError + } = require_errors2(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var RequestHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) { + throw new InvalidArgumentError("invalid highWaterMark"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_REQUEST"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.res = null; + this.abort = null; + this.body = body; + this.trailers = {}; + this.context = null; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError; + this.highWaterMark = highWaterMark; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + const body = new Readable({ resume, abort, contentType, highWaterMark }); + this.callback = null; + this.res = body; + if (callback !== null) { + if (this.throwOnError && statusCode >= 400) { + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body, contentType, statusCode, statusMessage, headers } + ); + } else { + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + trailers: this.trailers, + opaque, + body, + context + }); + } + } + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + util.parseHeaders(trailers, this.trailers); + res.push(null); + } + onError(err) { + const { res, callback, body, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (res) { + this.res = null; + queueMicrotask(() => { + util.destroy(res, err); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function request(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + request.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); }); - if (!props.found) { - if (props.anchor || props.tag || value) { - if (value && value.type === 'block-seq') - onError(props.end, 'BAD_INDENT', 'All sequence items must start at the same column'); - else - onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator'); - } - else { - commentEnd = props.end; - if (props.comment) - seq.comment = props.comment; - continue; - } + } + try { + this.dispatch(opts, new RequestHandler(opts, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; } - const node = value - ? composeNode(ctx, value, props, onError) - : composeEmptyNode(ctx, props.end, start, null, props, onError); - if (ctx.schema.compat) - utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError); - offset = node.range[2]; - seq.items.push(node); + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } } - seq.range = [bs.offset, offset, commentEnd ?? offset]; - return seq; -} - -exports.resolveBlockSeq = resolveBlockSeq; - - -/***/ }), - -/***/ 7788: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - + module2.exports = request; + module2.exports.RequestHandler = RequestHandler; + } +}); -function resolveEnd(end, offset, reqSpace, onError) { - let comment = ''; - if (end) { - let hasSpace = false; - let sep = ''; - for (const token of end) { - const { source, type } = token; - switch (type) { - case 'space': - hasSpace = true; - break; - case 'comment': { - if (reqSpace && !hasSpace) - onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters'); - const cb = source.substring(1) || ' '; - if (!comment) - comment = cb; - else - comment += sep + cb; - sep = ''; - break; - } - case 'newline': - if (comment) - sep += source; - hasSpace = true; - break; - default: - onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${type} at node end`); +// node_modules/undici/lib/api/api-stream.js +var require_api_stream = __commonJS({ + "node_modules/undici/lib/api/api-stream.js"(exports2, module2) { + "use strict"; + var { finished, PassThrough } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors2(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var StreamHandler = class extends AsyncResource { + constructor(opts, factory, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("invalid factory"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_STREAM"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.factory = factory; + this.callback = callback; + this.res = null; + this.abort = null; + this.context = null; + this.trailers = null; + this.body = body; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError || false; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { factory, opaque, context, callback, responseHeaders } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + this.factory = null; + let res; + if (this.throwOnError && statusCode >= 400) { + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + res = new PassThrough(); + this.callback = null; + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body: res, contentType, statusCode, statusMessage, headers } + ); + } else { + if (factory === null) { + return; + } + res = this.runInAsyncScope(factory, null, { + statusCode, + headers, + opaque, + context + }); + if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") { + throw new InvalidReturnValueError("expected Writable"); + } + finished(res, { readable: false }, (err) => { + const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this; + this.res = null; + if (err || !res2.readable) { + util.destroy(res2, err); } - offset += source.length; - } - } - return { comment, offset }; -} - -exports.resolveEnd = resolveEnd; - - -/***/ }), - -/***/ 3142: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Pair = __nccwpck_require__(7165); -var YAMLMap = __nccwpck_require__(4454); -var YAMLSeq = __nccwpck_require__(2223); -var resolveEnd = __nccwpck_require__(7788); -var resolveProps = __nccwpck_require__(4631); -var utilContainsNewline = __nccwpck_require__(9499); -var utilMapIncludes = __nccwpck_require__(1187); - -const blockMsg = 'Block collections are not allowed within flow collections'; -const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq'); -function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) { - const isMap = fc.start.source === '{'; - const fcName = isMap ? 'flow map' : 'flow sequence'; - const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq)); - const coll = new NodeClass(ctx.schema); - coll.flow = true; - const atRoot = ctx.atRoot; - if (atRoot) - ctx.atRoot = false; - if (ctx.atKey) - ctx.atKey = false; - let offset = fc.offset + fc.start.source.length; - for (let i = 0; i < fc.items.length; ++i) { - const collItem = fc.items[i]; - const { start, key, sep, value } = collItem; - const props = resolveProps.resolveProps(start, { - flow: fcName, - indicator: 'explicit-key-ind', - next: key ?? sep?.[0], - offset, - onError, - parentIndent: fc.indent, - startOnNewline: false - }); - if (!props.found) { - if (!props.anchor && !props.tag && !sep && !value) { - if (i === 0 && props.comma) - onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`); - else if (i < fc.items.length - 1) - onError(props.start, 'UNEXPECTED_TOKEN', `Unexpected empty item in ${fcName}`); - if (props.comment) { - if (coll.comment) - coll.comment += '\n' + props.comment; - else - coll.comment = props.comment; - } - offset = props.end; - continue; + this.callback = null; + this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers }); + if (err) { + abort(); } - if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key)) - onError(key, // checked by containsNewline() - 'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line'); + }); } - if (i === 0) { - if (props.comma) - onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`); + res.on("drain", resume); + this.res = res; + const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain; + return needDrain !== true; + } + onData(chunk) { + const { res } = this; + return res ? res.write(chunk) : true; + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + if (!res) { + return; + } + this.trailers = util.parseHeaders(trailers); + res.end(); + } + onError(err) { + const { res, callback, opaque, body } = this; + removeSignal(this); + this.factory = null; + if (res) { + this.res = null; + util.destroy(res, err); + } else if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); } - else { - if (!props.comma) - onError(props.start, 'MISSING_CHAR', `Missing , between ${fcName} items`); - if (props.comment) { - let prevItemComment = ''; - loop: for (const st of start) { - switch (st.type) { - case 'comma': - case 'space': - break; - case 'comment': - prevItemComment = st.source.substring(1); - break loop; - default: - break loop; - } - } - if (prevItemComment) { - let prev = coll.items[coll.items.length - 1]; - if (identity.isPair(prev)) - prev = prev.value ?? prev.key; - if (prev.comment) - prev.comment += '\n' + prevItemComment; - else - prev.comment = prevItemComment; - props.comment = props.comment.substring(prevItemComment.length + 1); - } - } + if (body) { + this.body = null; + util.destroy(body, err); } - if (!isMap && !sep && !props.found) { - // item is a value in a seq - // → key & sep are empty, start does not include ? or : - const valueNode = value - ? composeNode(ctx, value, props, onError) - : composeEmptyNode(ctx, props.end, sep, null, props, onError); - coll.items.push(valueNode); - offset = valueNode.range[2]; - if (isBlock(value)) - onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg); + } + }; + function stream(opts, factory, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + stream.call(this, opts, factory, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + this.dispatch(opts, new StreamHandler(opts, factory, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; } - else { - // item is a key+value pair - // key value - ctx.atKey = true; - const keyStart = props.end; - const keyNode = key - ? composeNode(ctx, key, props, onError) - : composeEmptyNode(ctx, keyStart, start, null, props, onError); - if (isBlock(key)) - onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg); - ctx.atKey = false; - // value properties - const valueProps = resolveProps.resolveProps(sep ?? [], { - flow: fcName, - indicator: 'map-value-ind', - next: value, - offset: keyNode.range[2], - onError, - parentIndent: fc.indent, - startOnNewline: false - }); - if (valueProps.found) { - if (!isMap && !props.found && ctx.options.strict) { - if (sep) - for (const st of sep) { - if (st === valueProps.found) - break; - if (st.type === 'newline') { - onError(st, 'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line'); - break; - } - } - if (props.start < valueProps.found.offset - 1024) - onError(valueProps.found, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key'); - } - } - else if (value) { - if ('source' in value && value.source && value.source[0] === ':') - onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`); - else - onError(valueProps.start, 'MISSING_CHAR', `Missing , or : between ${fcName} items`); - } - // value value - const valueNode = value - ? composeNode(ctx, value, valueProps, onError) - : valueProps.found - ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) - : null; - if (valueNode) { - if (isBlock(value)) - onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg); + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = stream; + } +}); + +// node_modules/undici/lib/api/api-pipeline.js +var require_api_pipeline = __commonJS({ + "node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) { + "use strict"; + var { + Readable, + Duplex, + PassThrough + } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors2(); + var util = require_util(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var kResume = Symbol("resume"); + var PipelineRequest = class extends Readable { + constructor() { + super({ autoDestroy: true }); + this[kResume] = null; + } + _read() { + const { [kResume]: resume } = this; + if (resume) { + this[kResume] = null; + resume(); + } + } + _destroy(err, callback) { + this._read(); + callback(err); + } + }; + var PipelineResponse = class extends Readable { + constructor(resume) { + super({ autoDestroy: true }); + this[kResume] = resume; + } + _read() { + this[kResume](); + } + _destroy(err, callback) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + callback(err); + } + }; + var PipelineHandler = class extends AsyncResource { + constructor(opts, handler) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof handler !== "function") { + throw new InvalidArgumentError("invalid handler"); + } + const { signal, method, opaque, onInfo, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_PIPELINE"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.handler = handler; + this.abort = null; + this.context = null; + this.onInfo = onInfo || null; + this.req = new PipelineRequest().on("error", util.nop); + this.ret = new Duplex({ + readableObjectMode: opts.objectMode, + autoDestroy: true, + read: () => { + const { body } = this; + if (body && body.resume) { + body.resume(); } - else if (valueProps.comment) { - if (keyNode.comment) - keyNode.comment += '\n' + valueProps.comment; - else - keyNode.comment = valueProps.comment; + }, + write: (chunk, encoding, callback) => { + const { req } = this; + if (req.push(chunk, encoding) || req._readableState.destroyed) { + callback(); + } else { + req[kResume] = callback; } - const pair = new Pair.Pair(keyNode, valueNode); - if (ctx.options.keepSourceTokens) - pair.srcToken = collItem; - if (isMap) { - const map = coll; - if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode)) - onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique'); - map.items.push(pair); + }, + destroy: (err, callback) => { + const { body, req, res, ret, abort } = this; + if (!err && !ret._readableState.endEmitted) { + err = new RequestAbortedError(); } - else { - const map = new YAMLMap.YAMLMap(ctx.schema); - map.flow = true; - map.items.push(pair); - const endRange = (valueNode ?? keyNode).range; - map.range = [keyNode.range[0], endRange[1], endRange[2]]; - coll.items.push(map); + if (abort && err) { + abort(); } - offset = valueNode ? valueNode.range[2] : valueProps.end; + util.destroy(body, err); + util.destroy(req, err); + util.destroy(res, err); + removeSignal(this); + callback(err); + } + }).on("prefinish", () => { + const { req } = this; + req.push(null); + }); + this.res = null; + addSignal(this, signal); + } + onConnect(abort, context) { + const { ret, res } = this; + assert(!res, "pipeline cannot be retried"); + if (ret.destroyed) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders(statusCode, rawHeaders, resume) { + const { opaque, handler, context } = this; + if (statusCode < 200) { + if (this.onInfo) { + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.onInfo({ statusCode, headers }); + } + return; } - } - const expectedEnd = isMap ? '}' : ']'; - const [ce, ...ee] = fc.end; - let cePos = offset; - if (ce && ce.source === expectedEnd) - cePos = ce.offset + ce.source.length; - else { - const name = fcName[0].toUpperCase() + fcName.substring(1); - const msg = atRoot - ? `${name} must end with a ${expectedEnd}` - : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`; - onError(offset, atRoot ? 'MISSING_CHAR' : 'BAD_INDENT', msg); - if (ce && ce.source.length !== 1) - ee.unshift(ce); - } - if (ee.length > 0) { - const end = resolveEnd.resolveEnd(ee, cePos, ctx.options.strict, onError); - if (end.comment) { - if (coll.comment) - coll.comment += '\n' + end.comment; - else - coll.comment = end.comment; + this.res = new PipelineResponse(resume); + let body; + try { + this.handler = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + body = this.runInAsyncScope(handler, null, { + statusCode, + headers, + opaque, + body: this.res, + context + }); + } catch (err) { + this.res.on("error", util.nop); + throw err; } - coll.range = [fc.offset, cePos, end.offset]; - } - else { - coll.range = [fc.offset, cePos, cePos]; + if (!body || typeof body.on !== "function") { + throw new InvalidReturnValueError("expected Readable"); + } + body.on("data", (chunk) => { + const { ret, body: body2 } = this; + if (!ret.push(chunk) && body2.pause) { + body2.pause(); + } + }).on("error", (err) => { + const { ret } = this; + util.destroy(ret, err); + }).on("end", () => { + const { ret } = this; + ret.push(null); + }).on("close", () => { + const { ret } = this; + if (!ret._readableState.ended) { + util.destroy(ret, new RequestAbortedError()); + } + }); + this.body = body; + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + res.push(null); + } + onError(err) { + const { ret } = this; + this.handler = null; + util.destroy(ret, err); + } + }; + function pipeline(opts, handler) { + try { + const pipelineHandler = new PipelineHandler(opts, handler); + this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler); + return pipelineHandler.ret; + } catch (err) { + return new PassThrough().destroy(err); + } } - return coll; -} - -exports.resolveFlowCollection = resolveFlowCollection; - + module2.exports = pipeline; + } +}); -/***/ }), +// node_modules/undici/lib/api/api-upgrade.js +var require_api_upgrade = __commonJS({ + "node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors2(); + var { AsyncResource } = require("async_hooks"); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var UpgradeHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_UPGRADE"); + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.abort = null; + this.context = null; + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = null; + } + onHeaders() { + throw new SocketError("bad upgrade", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context } = this; + assert.strictEqual(statusCode, 101); + removeSignal(this); + this.callback = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.runInAsyncScope(callback, null, null, { + headers, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function upgrade(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + upgrade.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const upgradeHandler = new UpgradeHandler(opts, callback); + this.dispatch({ + ...opts, + method: opts.method || "GET", + upgrade: opts.protocol || "Websocket" + }, upgradeHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = upgrade; + } +}); -/***/ 6842: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +// node_modules/undici/lib/api/api-connect.js +var require_api_connect = __commonJS({ + "node_modules/undici/lib/api/api-connect.js"(exports2, module2) { + "use strict"; + var { AsyncResource } = require("async_hooks"); + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors2(); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var ConnectHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_CONNECT"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.callback = callback; + this.abort = null; + addSignal(this, signal); + } + onConnect(abort, context) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context; + } + onHeaders() { + throw new SocketError("bad connect", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context } = this; + removeSignal(this); + this.callback = null; + let headers = rawHeaders; + if (headers != null) { + headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + } + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + socket, + opaque, + context + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function connect(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + connect.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const connectHandler = new ConnectHandler(opts, callback); + this.dispatch({ ...opts, method: "CONNECT" }, connectHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = connect; + } +}); -"use strict"; +// node_modules/undici/lib/api/index.js +var require_api = __commonJS({ + "node_modules/undici/lib/api/index.js"(exports2, module2) { + "use strict"; + module2.exports.request = require_api_request(); + module2.exports.stream = require_api_stream(); + module2.exports.pipeline = require_api_pipeline(); + module2.exports.upgrade = require_api_upgrade(); + module2.exports.connect = require_api_connect(); + } +}); +// node_modules/undici/lib/mock/mock-errors.js +var require_mock_errors = __commonJS({ + "node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) { + "use strict"; + var { UndiciError } = require_errors2(); + var MockNotMatchedError = class _MockNotMatchedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _MockNotMatchedError); + this.name = "MockNotMatchedError"; + this.message = message || "The request does not match any registered mock dispatches"; + this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED"; + } + }; + module2.exports = { + MockNotMatchedError + }; + } +}); -var Scalar = __nccwpck_require__(3301); -var resolveEnd = __nccwpck_require__(7788); +// node_modules/undici/lib/mock/mock-symbols.js +var require_mock_symbols = __commonJS({ + "node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kAgent: Symbol("agent"), + kOptions: Symbol("options"), + kFactory: Symbol("factory"), + kDispatches: Symbol("dispatches"), + kDispatchKey: Symbol("dispatch key"), + kDefaultHeaders: Symbol("default headers"), + kDefaultTrailers: Symbol("default trailers"), + kContentLength: Symbol("content length"), + kMockAgent: Symbol("mock agent"), + kMockAgentSet: Symbol("mock agent set"), + kMockAgentGet: Symbol("mock agent get"), + kMockDispatch: Symbol("mock dispatch"), + kClose: Symbol("close"), + kOriginalClose: Symbol("original agent close"), + kOrigin: Symbol("origin"), + kIsMockActive: Symbol("is mock active"), + kNetConnect: Symbol("net connect"), + kGetNetConnect: Symbol("get net connect"), + kConnected: Symbol("connected") + }; + } +}); -function resolveFlowScalar(scalar, strict, onError) { - const { offset, type, source, end } = scalar; - let _type; - let value; - const _onError = (rel, code, msg) => onError(offset + rel, code, msg); - switch (type) { - case 'scalar': - _type = Scalar.Scalar.PLAIN; - value = plainValue(source, _onError); - break; - case 'single-quoted-scalar': - _type = Scalar.Scalar.QUOTE_SINGLE; - value = singleQuotedValue(source, _onError); - break; - case 'double-quoted-scalar': - _type = Scalar.Scalar.QUOTE_DOUBLE; - value = doubleQuotedValue(source, _onError); - break; - /* istanbul ignore next should not happen */ - default: - onError(scalar, 'UNEXPECTED_TOKEN', `Expected a flow scalar value, but found: ${type}`); - return { - value: '', - type: null, - comment: '', - range: [offset, offset + source.length, offset + source.length] - }; +// node_modules/undici/lib/mock/mock-utils.js +var require_mock_utils = __commonJS({ + "node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) { + "use strict"; + var { MockNotMatchedError } = require_mock_errors(); + var { + kDispatches, + kMockAgent, + kOriginalDispatch, + kOrigin, + kGetNetConnect + } = require_mock_symbols(); + var { buildURL, nop } = require_util(); + var { STATUS_CODES } = require("http"); + var { + types: { + isPromise + } + } = require("util"); + function matchValue(match, value) { + if (typeof match === "string") { + return match === value; + } + if (match instanceof RegExp) { + return match.test(value); + } + if (typeof match === "function") { + return match(value) === true; + } + return false; + } + function lowerCaseEntries(headers) { + return Object.fromEntries( + Object.entries(headers).map(([headerName, headerValue]) => { + return [headerName.toLocaleLowerCase(), headerValue]; + }) + ); } - const valueEnd = offset + source.length; - const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError); - return { - value, - type: _type, - comment: re.comment, - range: [offset, valueEnd, re.offset] - }; -} -function plainValue(source, onError) { - let badChar = ''; - switch (source[0]) { - /* istanbul ignore next should not happen */ - case '\t': - badChar = 'a tab character'; - break; - case ',': - badChar = 'flow indicator character ,'; - break; - case '%': - badChar = 'directive indicator character %'; - break; - case '|': - case '>': { - badChar = `block scalar indicator ${source[0]}`; - break; + function getHeaderByName(headers, key) { + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) { + return headers[i + 1]; + } } - case '@': - case '`': { - badChar = `reserved character ${source[0]}`; - break; + return void 0; + } else if (typeof headers.get === "function") { + return headers.get(key); + } else { + return lowerCaseEntries(headers)[key.toLocaleLowerCase()]; + } + } + function buildHeadersFromArray(headers) { + const clone = headers.slice(); + const entries = []; + for (let index = 0; index < clone.length; index += 2) { + entries.push([clone[index], clone[index + 1]]); + } + return Object.fromEntries(entries); + } + function matchHeaders(mockDispatch2, headers) { + if (typeof mockDispatch2.headers === "function") { + if (Array.isArray(headers)) { + headers = buildHeadersFromArray(headers); + } + return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {}); + } + if (typeof mockDispatch2.headers === "undefined") { + return true; + } + if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") { + return false; + } + for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) { + const headerValue = getHeaderByName(headers, matchHeaderName); + if (!matchValue(matchHeaderValue, headerValue)) { + return false; } + } + return true; + } + function safeUrl(path2) { + if (typeof path2 !== "string") { + return path2; + } + const pathSegments = path2.split("?"); + if (pathSegments.length !== 2) { + return path2; + } + const qp = new URLSearchParams(pathSegments.pop()); + qp.sort(); + return [...pathSegments, qp.toString()].join("?"); + } + function matchKey(mockDispatch2, { path: path2, method, body, headers }) { + const pathMatch = matchValue(mockDispatch2.path, path2); + const methodMatch = matchValue(mockDispatch2.method, method); + const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true; + const headersMatch = matchHeaders(mockDispatch2, headers); + return pathMatch && methodMatch && bodyMatch && headersMatch; } - if (badChar) - onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`); - return foldLines(source); -} -function singleQuotedValue(source, onError) { - if (source[source.length - 1] !== "'" || source.length === 1) - onError(source.length, 'MISSING_CHAR', "Missing closing 'quote"); - return foldLines(source.slice(1, -1)).replace(/''/g, "'"); -} -function foldLines(source) { - /** - * The negative lookbehind here and in the `re` RegExp is to - * prevent causing a polynomial search time in certain cases. - * - * The try-catch is for Safari, which doesn't support this yet: - * https://caniuse.com/js-regexp-lookbehind - */ - let first, line; - try { - first = new RegExp('(.*?)(? !consumed).filter(({ path: path2 }) => matchValue(safeUrl(path2), resolvedPath)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`); + } + matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`); + } + return matchedMockDispatches[0]; } - let match = first.exec(source); - if (!match) - return source; - let res = match[1]; - let sep = ' '; - let pos = first.lastIndex; - line.lastIndex = pos; - while ((match = line.exec(source))) { - if (match[1] === '') { - if (sep === '\n') - res += sep; - else - sep = '\n'; - } - else { - res += sep + match[1]; - sep = ' '; + function addMockDispatch(mockDispatches, key, data) { + const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false }; + const replyData = typeof data === "function" ? { callback: data } : { ...data }; + const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } }; + mockDispatches.push(newMockDispatch); + return newMockDispatch; + } + function deleteMockDispatch(mockDispatches, key) { + const index = mockDispatches.findIndex((dispatch) => { + if (!dispatch.consumed) { + return false; } - pos = line.lastIndex; + return matchKey(dispatch, key); + }); + if (index !== -1) { + mockDispatches.splice(index, 1); + } } - const last = /[ \t]*(.*)/sy; - last.lastIndex = pos; - match = last.exec(source); - return res + sep + (match?.[1] ?? ''); -} -function doubleQuotedValue(source, onError) { - let res = ''; - for (let i = 1; i < source.length - 1; ++i) { - const ch = source[i]; - if (ch === '\r' && source[i + 1] === '\n') - continue; - if (ch === '\n') { - const { fold, offset } = foldNewline(source, i); - res += fold; - i = offset; - } - else if (ch === '\\') { - let next = source[++i]; - const cc = escapeCodes[next]; - if (cc) - res += cc; - else if (next === '\n') { - // skip escaped newlines, but still trim the following line - next = source[i + 1]; - while (next === ' ' || next === '\t') - next = source[++i + 1]; - } - else if (next === '\r' && source[i + 1] === '\n') { - // skip escaped CRLF newlines, but still trim the following line - next = source[++i + 1]; - while (next === ' ' || next === '\t') - next = source[++i + 1]; - } - else if (next === 'x' || next === 'u' || next === 'U') { - const length = { x: 2, u: 4, U: 8 }[next]; - res += parseCharCode(source, i + 1, length, onError); - i += length; - } - else { - const raw = source.substr(i - 1, 2); - onError(i - 1, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`); - res += raw; + function buildKey(opts) { + const { path: path2, method, body, headers, query } = opts; + return { + path: path2, + method, + body, + headers, + query + }; + } + function generateKeyValues(data) { + return Object.entries(data).reduce((keyValuePairs, [key, value]) => [ + ...keyValuePairs, + Buffer.from(`${key}`), + Array.isArray(value) ? value.map((x) => Buffer.from(`${x}`)) : Buffer.from(`${value}`) + ], []); + } + function getStatusText(statusCode) { + return STATUS_CODES[statusCode] || "unknown"; + } + async function getResponse(body) { + const buffers = []; + for await (const data of body) { + buffers.push(data); + } + return Buffer.concat(buffers).toString("utf8"); + } + function mockDispatch(opts, handler) { + const key = buildKey(opts); + const mockDispatch2 = getMockDispatch(this[kDispatches], key); + mockDispatch2.timesInvoked++; + if (mockDispatch2.data.callback) { + mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) }; + } + const { data: { statusCode, data, headers, trailers, error: error2 }, delay, persist } = mockDispatch2; + const { timesInvoked, times } = mockDispatch2; + mockDispatch2.consumed = !persist && timesInvoked >= times; + mockDispatch2.pending = timesInvoked < times; + if (error2 !== null) { + deleteMockDispatch(this[kDispatches], key); + handler.onError(error2); + return true; + } + if (typeof delay === "number" && delay > 0) { + setTimeout(() => { + handleReply(this[kDispatches]); + }, delay); + } else { + handleReply(this[kDispatches]); + } + function handleReply(mockDispatches, _data = data) { + const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers; + const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data; + if (isPromise(body)) { + body.then((newData) => handleReply(mockDispatches, newData)); + return; + } + const responseData = getResponseData(body); + const responseHeaders = generateKeyValues(headers); + const responseTrailers = generateKeyValues(trailers); + handler.abort = nop; + handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode)); + handler.onData(Buffer.from(responseData)); + handler.onComplete(responseTrailers); + deleteMockDispatch(mockDispatches, key); + } + function resume() { + } + return true; + } + function buildMockDispatch() { + const agent = this[kMockAgent]; + const origin = this[kOrigin]; + const originalDispatch = this[kOriginalDispatch]; + return function dispatch(opts, handler) { + if (agent.isMockActive) { + try { + mockDispatch.call(this, opts, handler); + } catch (error2) { + if (error2 instanceof MockNotMatchedError) { + const netConnect = agent[kGetNetConnect](); + if (netConnect === false) { + throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`); + } + if (checkNetConnect(netConnect, origin)) { + originalDispatch.call(this, opts, handler); + } else { + throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`); + } + } else { + throw error2; } + } + } else { + originalDispatch.call(this, opts, handler); } - else if (ch === ' ' || ch === '\t') { - // trim trailing whitespace - const wsStart = i; - let next = source[i + 1]; - while (next === ' ' || next === '\t') - next = source[++i + 1]; - if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n')) - res += i > wsStart ? source.slice(wsStart, i + 1) : ch; - } - else { - res += ch; - } - } - if (source[source.length - 1] !== '"' || source.length === 1) - onError(source.length, 'MISSING_CHAR', 'Missing closing "quote'); - return res; -} -/** - * Fold a single newline into a space, multiple newlines to N - 1 newlines. - * Presumes `source[offset] === '\n'` - */ -function foldNewline(source, offset) { - let fold = ''; - let ch = source[offset + 1]; - while (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') { - if (ch === '\r' && source[offset + 2] !== '\n') - break; - if (ch === '\n') - fold += '\n'; - offset += 1; - ch = source[offset + 1]; - } - if (!fold) - fold = ' '; - return { fold, offset }; -} -const escapeCodes = { - '0': '\0', // null character - a: '\x07', // bell character - b: '\b', // backspace - e: '\x1b', // escape character - f: '\f', // form feed - n: '\n', // line feed - r: '\r', // carriage return - t: '\t', // horizontal tab - v: '\v', // vertical tab - N: '\u0085', // Unicode next line - _: '\u00a0', // Unicode non-breaking space - L: '\u2028', // Unicode line separator - P: '\u2029', // Unicode paragraph separator - ' ': ' ', - '"': '"', - '/': '/', - '\\': '\\', - '\t': '\t' -}; -function parseCharCode(source, offset, length, onError) { - const cc = source.substr(offset, length); - const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc); - const code = ok ? parseInt(cc, 16) : NaN; - if (isNaN(code)) { - const raw = source.substr(offset - 2, length + 2); - onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`); - return raw; + }; } - return String.fromCodePoint(code); -} - -exports.resolveFlowScalar = resolveFlowScalar; - - -/***/ }), - -/***/ 4631: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - + function checkNetConnect(netConnect, origin) { + const url = new URL(origin); + if (netConnect === true) { + return true; + } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) { + return true; + } + return false; + } + function buildMockOptions(opts) { + if (opts) { + const { agent, ...mockOptions } = opts; + return mockOptions; + } + } + module2.exports = { + getResponseData, + getMockDispatch, + addMockDispatch, + deleteMockDispatch, + buildKey, + generateKeyValues, + matchValue, + getResponse, + getStatusText, + mockDispatch, + buildMockDispatch, + checkNetConnect, + buildMockOptions, + getHeaderByName + }; + } +}); -function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) { - let spaceBefore = false; - let atNewline = startOnNewline; - let hasSpace = startOnNewline; - let comment = ''; - let commentSep = ''; - let hasNewline = false; - let reqSpace = false; - let tab = null; - let anchor = null; - let tag = null; - let newlineAfterProp = null; - let comma = null; - let found = null; - let start = null; - for (const token of tokens) { - if (reqSpace) { - if (token.type !== 'space' && - token.type !== 'newline' && - token.type !== 'comma') - onError(token.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space'); - reqSpace = false; +// node_modules/undici/lib/mock/mock-interceptor.js +var require_mock_interceptor = __commonJS({ + "node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) { + "use strict"; + var { getResponseData, buildKey, addMockDispatch } = require_mock_utils(); + var { + kDispatches, + kDispatchKey, + kDefaultHeaders, + kDefaultTrailers, + kContentLength, + kMockDispatch + } = require_mock_symbols(); + var { InvalidArgumentError } = require_errors2(); + var { buildURL } = require_util(); + var MockScope = class { + constructor(mockDispatch) { + this[kMockDispatch] = mockDispatch; + } + /** + * Delay a reply by a set amount in ms. + */ + delay(waitInMs) { + if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) { + throw new InvalidArgumentError("waitInMs must be a valid integer > 0"); } - if (tab) { - if (atNewline && token.type !== 'comment' && token.type !== 'newline') { - onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation'); - } - tab = null; + this[kMockDispatch].delay = waitInMs; + return this; + } + /** + * For a defined reply, never mark as consumed. + */ + persist() { + this[kMockDispatch].persist = true; + return this; + } + /** + * Allow one to define a reply for a set amount of matching requests. + */ + times(repeatTimes) { + if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) { + throw new InvalidArgumentError("repeatTimes must be a valid integer > 0"); } - switch (token.type) { - case 'space': - // At the doc level, tabs at line start may be parsed - // as leading white space rather than indentation. - // In a flow collection, only the parser handles indent. - if (!flow && - (indicator !== 'doc-start' || next?.type !== 'flow-collection') && - token.source.includes('\t')) { - tab = token; - } - hasSpace = true; - break; - case 'comment': { - if (!hasSpace) - onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters'); - const cb = token.source.substring(1) || ' '; - if (!comment) - comment = cb; - else - comment += commentSep + cb; - commentSep = ''; - atNewline = false; - break; - } - case 'newline': - if (atNewline) { - if (comment) - comment += token.source; - else if (!found || indicator !== 'seq-item-ind') - spaceBefore = true; - } - else - commentSep += token.source; - atNewline = true; - hasNewline = true; - if (anchor || tag) - newlineAfterProp = token; - hasSpace = true; - break; - case 'anchor': - if (anchor) - onError(token, 'MULTIPLE_ANCHORS', 'A node can have at most one anchor'); - if (token.source.endsWith(':')) - onError(token.offset + token.source.length - 1, 'BAD_ALIAS', 'Anchor ending in : is ambiguous', true); - anchor = token; - start ?? (start = token.offset); - atNewline = false; - hasSpace = false; - reqSpace = true; - break; - case 'tag': { - if (tag) - onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag'); - tag = token; - start ?? (start = token.offset); - atNewline = false; - hasSpace = false; - reqSpace = true; - break; + this[kMockDispatch].times = repeatTimes; + return this; + } + }; + var MockInterceptor = class { + constructor(opts, mockDispatches) { + if (typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object"); + } + if (typeof opts.path === "undefined") { + throw new InvalidArgumentError("opts.path must be defined"); + } + if (typeof opts.method === "undefined") { + opts.method = "GET"; + } + if (typeof opts.path === "string") { + if (opts.query) { + opts.path = buildURL(opts.path, opts.query); + } else { + const parsedURL = new URL(opts.path, "data://"); + opts.path = parsedURL.pathname + parsedURL.search; + } + } + if (typeof opts.method === "string") { + opts.method = opts.method.toUpperCase(); + } + this[kDispatchKey] = buildKey(opts); + this[kDispatches] = mockDispatches; + this[kDefaultHeaders] = {}; + this[kDefaultTrailers] = {}; + this[kContentLength] = false; + } + createMockScopeDispatchData(statusCode, data, responseOptions = {}) { + const responseData = getResponseData(data); + const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {}; + const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }; + const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }; + return { statusCode, data, headers, trailers }; + } + validateReplyParameters(statusCode, data, responseOptions) { + if (typeof statusCode === "undefined") { + throw new InvalidArgumentError("statusCode must be defined"); + } + if (typeof data === "undefined") { + throw new InvalidArgumentError("data must be defined"); + } + if (typeof responseOptions !== "object") { + throw new InvalidArgumentError("responseOptions must be an object"); + } + } + /** + * Mock an undici request with a defined reply. + */ + reply(replyData) { + if (typeof replyData === "function") { + const wrappedDefaultsCallback = (opts) => { + const resolvedData = replyData(opts); + if (typeof resolvedData !== "object") { + throw new InvalidArgumentError("reply options callback must return an object"); } - case indicator: - // Could here handle preceding comments differently - if (anchor || tag) - onError(token, 'BAD_PROP_ORDER', `Anchors and tags must be after the ${token.source} indicator`); - if (found) - onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.source} in ${flow ?? 'collection'}`); - found = token; - atNewline = - indicator === 'seq-item-ind' || indicator === 'explicit-key-ind'; - hasSpace = false; - break; - case 'comma': - if (flow) { - if (comma) - onError(token, 'UNEXPECTED_TOKEN', `Unexpected , in ${flow}`); - comma = token; - atNewline = false; - hasSpace = false; - break; - } - // else fallthrough - default: - onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.type} token`); - atNewline = false; - hasSpace = false; - } - } - const last = tokens[tokens.length - 1]; - const end = last ? last.offset + last.source.length : offset; - if (reqSpace && - next && - next.type !== 'space' && - next.type !== 'newline' && - next.type !== 'comma' && - (next.type !== 'scalar' || next.source !== '')) { - onError(next.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space'); - } - if (tab && - ((atNewline && tab.indent <= parentIndent) || - next?.type === 'block-map' || - next?.type === 'block-seq')) - onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation'); - return { - comma, - found, - spaceBefore, - comment, - hasNewline, - anchor, - tag, - newlineAfterProp, - end, - start: start ?? end + const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData; + this.validateReplyParameters(statusCode2, data2, responseOptions2); + return { + ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2) + }; + }; + const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback); + return new MockScope(newMockDispatch2); + } + const [statusCode, data = "", responseOptions = {}] = [...arguments]; + this.validateReplyParameters(statusCode, data, responseOptions); + const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions); + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData); + return new MockScope(newMockDispatch); + } + /** + * Mock an undici request with a defined error. + */ + replyWithError(error2) { + if (typeof error2 === "undefined") { + throw new InvalidArgumentError("error must be defined"); + } + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error: error2 }); + return new MockScope(newMockDispatch); + } + /** + * Set default reply headers on the interceptor for subsequent replies + */ + defaultReplyHeaders(headers) { + if (typeof headers === "undefined") { + throw new InvalidArgumentError("headers must be defined"); + } + this[kDefaultHeaders] = headers; + return this; + } + /** + * Set default reply trailers on the interceptor for subsequent replies + */ + defaultReplyTrailers(trailers) { + if (typeof trailers === "undefined") { + throw new InvalidArgumentError("trailers must be defined"); + } + this[kDefaultTrailers] = trailers; + return this; + } + /** + * Set reply content length header for replies on the interceptor + */ + replyContentLength() { + this[kContentLength] = true; + return this; + } }; -} + module2.exports.MockInterceptor = MockInterceptor; + module2.exports.MockScope = MockScope; + } +}); -exports.resolveProps = resolveProps; +// node_modules/undici/lib/mock/mock-client.js +var require_mock_client = __commonJS({ + "node_modules/undici/lib/mock/mock-client.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Client = require_client(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors2(); + var MockClient = class extends Client { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockClient; + } +}); +// node_modules/undici/lib/mock/mock-pool.js +var require_mock_pool = __commonJS({ + "node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Pool = require_pool(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors2(); + var MockPool = class extends Pool { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockPool; + } +}); -/***/ }), +// node_modules/undici/lib/mock/pluralizer.js +var require_pluralizer = __commonJS({ + "node_modules/undici/lib/mock/pluralizer.js"(exports2, module2) { + "use strict"; + var singulars = { + pronoun: "it", + is: "is", + was: "was", + this: "this" + }; + var plurals = { + pronoun: "they", + is: "are", + was: "were", + this: "these" + }; + module2.exports = class Pluralizer { + constructor(singular, plural) { + this.singular = singular; + this.plural = plural; + } + pluralize(count) { + const one = count === 1; + const keys = one ? singulars : plurals; + const noun = one ? this.singular : this.plural; + return { ...keys, count, noun }; + } + }; + } +}); -/***/ 9499: -/***/ ((__unused_webpack_module, exports) => { +// node_modules/undici/lib/mock/pending-interceptors-formatter.js +var require_pending_interceptors_formatter = __commonJS({ + "node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module2) { + "use strict"; + var { Transform } = require("stream"); + var { Console } = require("console"); + module2.exports = class PendingInterceptorsFormatter { + constructor({ disableColors } = {}) { + this.transform = new Transform({ + transform(chunk, _enc, cb) { + cb(null, chunk); + } + }); + this.logger = new Console({ + stdout: this.transform, + inspectOptions: { + colors: !disableColors && !process.env.CI + } + }); + } + format(pendingInterceptors) { + const withPrettyHeaders = pendingInterceptors.map( + ({ method, path: path2, data: { statusCode }, persist, times, timesInvoked, origin }) => ({ + Method: method, + Origin: origin, + Path: path2, + "Status code": statusCode, + Persistent: persist ? "\u2705" : "\u274C", + Invocations: timesInvoked, + Remaining: persist ? Infinity : times - timesInvoked + }) + ); + this.logger.table(withPrettyHeaders); + return this.transform.read().toString(); + } + }; + } +}); -"use strict"; +// node_modules/undici/lib/mock/mock-agent.js +var require_mock_agent = __commonJS({ + "node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) { + "use strict"; + var { kClients } = require_symbols(); + var Agent = require_agent(); + var { + kAgent, + kMockAgentSet, + kMockAgentGet, + kDispatches, + kIsMockActive, + kNetConnect, + kGetNetConnect, + kOptions, + kFactory + } = require_mock_symbols(); + var MockClient = require_mock_client(); + var MockPool = require_mock_pool(); + var { matchValue, buildMockOptions } = require_mock_utils(); + var { InvalidArgumentError, UndiciError } = require_errors2(); + var Dispatcher = require_dispatcher(); + var Pluralizer = require_pluralizer(); + var PendingInterceptorsFormatter = require_pending_interceptors_formatter(); + var FakeWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value; + } + }; + var MockAgent = class extends Dispatcher { + constructor(opts) { + super(opts); + this[kNetConnect] = true; + this[kIsMockActive] = true; + if (opts && opts.agent && typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + const agent = opts && opts.agent ? opts.agent : new Agent(opts); + this[kAgent] = agent; + this[kClients] = agent[kClients]; + this[kOptions] = buildMockOptions(opts); + } + get(origin) { + let dispatcher = this[kMockAgentGet](origin); + if (!dispatcher) { + dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + } + return dispatcher; + } + dispatch(opts, handler) { + this.get(opts.origin); + return this[kAgent].dispatch(opts, handler); + } + async close() { + await this[kAgent].close(); + this[kClients].clear(); + } + deactivate() { + this[kIsMockActive] = false; + } + activate() { + this[kIsMockActive] = true; + } + enableNetConnect(matcher) { + if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) { + if (Array.isArray(this[kNetConnect])) { + this[kNetConnect].push(matcher); + } else { + this[kNetConnect] = [matcher]; + } + } else if (typeof matcher === "undefined") { + this[kNetConnect] = true; + } else { + throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp."); + } + } + disableNetConnect() { + this[kNetConnect] = false; + } + // This is required to bypass issues caused by using global symbols - see: + // https://github.com/nodejs/undici/issues/1447 + get isMockActive() { + return this[kIsMockActive]; + } + [kMockAgentSet](origin, dispatcher) { + this[kClients].set(origin, new FakeWeakRef(dispatcher)); + } + [kFactory](origin) { + const mockOptions = Object.assign({ agent: this }, this[kOptions]); + return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions); + } + [kMockAgentGet](origin) { + const ref = this[kClients].get(origin); + if (ref) { + return ref.deref(); + } + if (typeof origin !== "string") { + const dispatcher = this[kFactory]("http://localhost:9999"); + this[kMockAgentSet](origin, dispatcher); + return dispatcher; + } + for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) { + const nonExplicitDispatcher = nonExplicitRef.deref(); + if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) { + const dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]; + return dispatcher; + } + } + } + [kGetNetConnect]() { + return this[kNetConnect]; + } + pendingInterceptors() { + const mockAgentClients = this[kClients]; + return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending); + } + assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) { + const pending = this.pendingInterceptors(); + if (pending.length === 0) { + return; + } + const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length); + throw new UndiciError(` +${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending: +${pendingInterceptorsFormatter.format(pending)} +`.trim()); + } + }; + module2.exports = MockAgent; + } +}); -function containsNewline(key) { - if (!key) - return null; - switch (key.type) { - case 'alias': - case 'scalar': - case 'double-quoted-scalar': - case 'single-quoted-scalar': - if (key.source.includes('\n')) - return true; - if (key.end) - for (const st of key.end) - if (st.type === 'newline') - return true; - return false; - case 'flow-collection': - for (const it of key.items) { - for (const st of it.start) - if (st.type === 'newline') - return true; - if (it.sep) - for (const st of it.sep) - if (st.type === 'newline') - return true; - if (containsNewline(it.key) || containsNewline(it.value)) - return true; +// node_modules/undici/lib/proxy-agent.js +var require_proxy_agent = __commonJS({ + "node_modules/undici/lib/proxy-agent.js"(exports2, module2) { + "use strict"; + var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols(); + var { URL: URL2 } = require("url"); + var Agent = require_agent(); + var Pool = require_pool(); + var DispatcherBase = require_dispatcher_base(); + var { InvalidArgumentError, RequestAbortedError } = require_errors2(); + var buildConnector = require_connect(); + var kAgent = Symbol("proxy agent"); + var kClient = Symbol("proxy client"); + var kProxyHeaders = Symbol("proxy headers"); + var kRequestTls = Symbol("request tls settings"); + var kProxyTls = Symbol("proxy tls settings"); + var kConnectEndpoint = Symbol("connect endpoint function"); + function defaultProtocolPort(protocol) { + return protocol === "https:" ? 443 : 80; + } + function buildProxyOptions(opts) { + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + return { + uri: opts.uri, + protocol: opts.protocol || "https" + }; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var ProxyAgent = class extends DispatcherBase { + constructor(opts) { + super(opts); + this[kProxy] = buildProxyOptions(opts); + this[kAgent] = new Agent(opts); + this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : []; + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + const { clientFactory = defaultFactory } = opts; + if (typeof clientFactory !== "function") { + throw new InvalidArgumentError("Proxy opts.clientFactory must be a function."); + } + this[kRequestTls] = opts.requestTls; + this[kProxyTls] = opts.proxyTls; + this[kProxyHeaders] = opts.headers || {}; + const resolvedUrl = new URL2(opts.uri); + const { origin, port, host, username, password } = resolvedUrl; + if (opts.auth && opts.token) { + throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token"); + } else if (opts.auth) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`; + } else if (opts.token) { + this[kProxyHeaders]["proxy-authorization"] = opts.token; + } else if (username && password) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`; + } + const connect = buildConnector({ ...opts.proxyTls }); + this[kConnectEndpoint] = buildConnector({ ...opts.requestTls }); + this[kClient] = clientFactory(resolvedUrl, { connect }); + this[kAgent] = new Agent({ + ...opts, + connect: async (opts2, callback) => { + let requestedHost = opts2.host; + if (!opts2.port) { + requestedHost += `:${defaultProtocolPort(opts2.protocol)}`; } - return false; - default: - return true; - } -} - -exports.containsNewline = containsNewline; - - -/***/ }), - -/***/ 2599: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -function emptyScalarPosition(offset, before, pos) { - if (before) { - pos ?? (pos = before.length); - for (let i = pos - 1; i >= 0; --i) { - let st = before[i]; - switch (st.type) { - case 'space': - case 'comment': - case 'newline': - offset -= st.source.length; - continue; + try { + const { socket, statusCode } = await this[kClient].connect({ + origin, + port, + path: requestedHost, + signal: opts2.signal, + headers: { + ...this[kProxyHeaders], + host + } + }); + if (statusCode !== 200) { + socket.on("error", () => { + }).destroy(); + callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`)); + } + if (opts2.protocol !== "https:") { + callback(null, socket); + return; + } + let servername; + if (this[kRequestTls]) { + servername = this[kRequestTls].servername; + } else { + servername = opts2.servername; + } + this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback); + } catch (err) { + callback(err); } - // Technically, an empty scalar is immediately after the last non-empty - // node, but it's more useful to place it after any whitespace. - st = before[++i]; - while (st?.type === 'space') { - offset += st.source.length; - st = before[++i]; + } + }); + } + dispatch(opts, handler) { + const { host } = new URL2(opts.origin); + const headers = buildHeaders2(opts.headers); + throwIfProxyAuthIsSent(headers); + return this[kAgent].dispatch( + { + ...opts, + headers: { + ...headers, + host } - break; + }, + handler + ); + } + async [kClose]() { + await this[kAgent].close(); + await this[kClient].close(); + } + async [kDestroy]() { + await this[kAgent].destroy(); + await this[kClient].destroy(); + } + }; + function buildHeaders2(headers) { + if (Array.isArray(headers)) { + const headersPair = {}; + for (let i = 0; i < headers.length; i += 2) { + headersPair[headers[i]] = headers[i + 1]; } + return headersPair; + } + return headers; } - return offset; -} - -exports.emptyScalarPosition = emptyScalarPosition; - - -/***/ }), - -/***/ 4051: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var utilContainsNewline = __nccwpck_require__(9499); - -function flowIndentCheck(indent, fc, onError) { - if (fc?.type === 'flow-collection') { - const end = fc.end[0]; - if (end.indent === indent && - (end.source === ']' || end.source === '}') && - utilContainsNewline.containsNewline(fc)) { - const msg = 'Flow end indicator should be more indented than parent'; - onError(end, 'BAD_INDENT', msg, true); - } + function throwIfProxyAuthIsSent(headers) { + const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization"); + if (existProxyAuth) { + throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor"); + } } -} - -exports.flowIndentCheck = flowIndentCheck; - - -/***/ }), - -/***/ 1187: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); + module2.exports = ProxyAgent; + } +}); -function mapIncludes(ctx, items, search) { - const { uniqueKeys } = ctx.options; - if (uniqueKeys === false) +// node_modules/undici/lib/handler/RetryHandler.js +var require_RetryHandler = __commonJS({ + "node_modules/undici/lib/handler/RetryHandler.js"(exports2, module2) { + var assert = require("assert"); + var { kRetryHandlerDefaultRetry } = require_symbols(); + var { RequestRetryError } = require_errors2(); + var { isDisturbed, parseHeaders, parseRangeHeader } = require_util(); + function calculateRetryAfterHeader(retryAfter) { + const current = Date.now(); + const diff = new Date(retryAfter).getTime() - current; + return diff; + } + var RetryHandler = class _RetryHandler { + constructor(opts, handlers) { + const { retryOptions, ...dispatchOpts } = opts; + const { + // Retry scoped + retry: retryFn, + maxRetries, + maxTimeout, + minTimeout, + timeoutFactor, + // Response scoped + methods, + errorCodes, + retryAfter, + statusCodes + } = retryOptions ?? {}; + this.dispatch = handlers.dispatch; + this.handler = handlers.handler; + this.opts = dispatchOpts; + this.abort = null; + this.aborted = false; + this.retryOpts = { + retry: retryFn ?? _RetryHandler[kRetryHandlerDefaultRetry], + retryAfter: retryAfter ?? true, + maxTimeout: maxTimeout ?? 30 * 1e3, + // 30s, + timeout: minTimeout ?? 500, + // .5s + timeoutFactor: timeoutFactor ?? 2, + maxRetries: maxRetries ?? 5, + // What errors we should retry + methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"], + // Indicates which errors to retry + statusCodes: statusCodes ?? [500, 502, 503, 504, 429], + // List of errors to retry + errorCodes: errorCodes ?? [ + "ECONNRESET", + "ECONNREFUSED", + "ENOTFOUND", + "ENETDOWN", + "ENETUNREACH", + "EHOSTDOWN", + "EHOSTUNREACH", + "EPIPE" + ] + }; + this.retryCount = 0; + this.start = 0; + this.end = null; + this.etag = null; + this.resume = null; + this.handler.onConnect((reason) => { + this.aborted = true; + if (this.abort) { + this.abort(reason); + } else { + this.reason = reason; + } + }); + } + onRequestSent() { + if (this.handler.onRequestSent) { + this.handler.onRequestSent(); + } + } + onUpgrade(statusCode, headers, socket) { + if (this.handler.onUpgrade) { + this.handler.onUpgrade(statusCode, headers, socket); + } + } + onConnect(abort) { + if (this.aborted) { + abort(this.reason); + } else { + this.abort = abort; + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) return this.handler.onBodySent(chunk); + } + static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) { + const { statusCode, code, headers } = err; + const { method, retryOptions } = opts; + const { + maxRetries, + timeout, + maxTimeout, + timeoutFactor, + statusCodes, + errorCodes, + methods + } = retryOptions; + let { counter, currentTimeout } = state; + currentTimeout = currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout; + if (code && code !== "UND_ERR_REQ_RETRY" && code !== "UND_ERR_SOCKET" && !errorCodes.includes(code)) { + cb(err); + return; + } + if (Array.isArray(methods) && !methods.includes(method)) { + cb(err); + return; + } + if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) { + cb(err); + return; + } + if (counter > maxRetries) { + cb(err); + return; + } + let retryAfterHeader = headers != null && headers["retry-after"]; + if (retryAfterHeader) { + retryAfterHeader = Number(retryAfterHeader); + retryAfterHeader = isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3; + } + const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout); + state.currentTimeout = retryTimeout; + setTimeout(() => cb(null), retryTimeout); + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const headers = parseHeaders(rawHeaders); + this.retryCount += 1; + if (statusCode >= 300) { + this.abort( + new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.resume != null) { + this.resume = null; + if (statusCode !== 206) { + return true; + } + const contentRange = parseRangeHeader(headers["content-range"]); + if (!contentRange) { + this.abort( + new RequestRetryError("Content-Range mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.etag != null && this.etag !== headers.etag) { + this.abort( + new RequestRetryError("ETag mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + const { start, size, end = size } = contentRange; + assert(this.start === start, "content-range mismatch"); + assert(this.end == null || this.end === end, "content-range mismatch"); + this.resume = resume; + return true; + } + if (this.end == null) { + if (statusCode === 206) { + const range = parseRangeHeader(headers["content-range"]); + if (range == null) { + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const { start, size, end = size } = range; + assert( + start != null && Number.isFinite(start) && this.start !== start, + "content-range mismatch" + ); + assert(Number.isFinite(start)); + assert( + end != null && Number.isFinite(end) && this.end !== end, + "invalid content-length" + ); + this.start = start; + this.end = end; + } + if (this.end == null) { + const contentLength = headers["content-length"]; + this.end = contentLength != null ? Number(contentLength) : null; + } + assert(Number.isFinite(this.start)); + assert( + this.end == null || Number.isFinite(this.end), + "invalid content-length" + ); + this.resume = resume; + this.etag = headers.etag != null ? headers.etag : null; + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const err = new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }); + this.abort(err); return false; - const isEqual = typeof uniqueKeys === 'function' - ? uniqueKeys - : (a, b) => a === b || (identity.isScalar(a) && identity.isScalar(b) && a.value === b.value); - return items.some(pair => isEqual(pair.key, search)); -} - -exports.mapIncludes = mapIncludes; - - -/***/ }), - -/***/ 3021: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; + } + onData(chunk) { + this.start += chunk.length; + return this.handler.onData(chunk); + } + onComplete(rawTrailers) { + this.retryCount = 0; + return this.handler.onComplete(rawTrailers); + } + onError(err) { + if (this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err); + } + this.retryOpts.retry( + err, + { + state: { counter: this.retryCount++, currentTimeout: this.retryAfter }, + opts: { retryOptions: this.retryOpts, ...this.opts } + }, + onRetry.bind(this) + ); + function onRetry(err2) { + if (err2 != null || this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err2); + } + if (this.start !== 0) { + this.opts = { + ...this.opts, + headers: { + ...this.opts.headers, + range: `bytes=${this.start}-${this.end ?? ""}` + } + }; + } + try { + this.dispatch(this.opts, this); + } catch (err3) { + this.handler.onError(err3); + } + } + } + }; + module2.exports = RetryHandler; + } +}); +// node_modules/undici/lib/global.js +var require_global2 = __commonJS({ + "node_modules/undici/lib/global.js"(exports2, module2) { + "use strict"; + var globalDispatcher = Symbol.for("undici.globalDispatcher.1"); + var { InvalidArgumentError } = require_errors2(); + var Agent = require_agent(); + if (getGlobalDispatcher() === void 0) { + setGlobalDispatcher(new Agent()); + } + function setGlobalDispatcher(agent) { + if (!agent || typeof agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument agent must implement Agent"); + } + Object.defineProperty(globalThis, globalDispatcher, { + value: agent, + writable: true, + enumerable: false, + configurable: false + }); + } + function getGlobalDispatcher() { + return globalThis[globalDispatcher]; + } + module2.exports = { + setGlobalDispatcher, + getGlobalDispatcher + }; + } +}); -var Alias = __nccwpck_require__(4065); -var Collection = __nccwpck_require__(101); -var identity = __nccwpck_require__(1127); -var Pair = __nccwpck_require__(7165); -var toJS = __nccwpck_require__(4043); -var Schema = __nccwpck_require__(5840); -var stringifyDocument = __nccwpck_require__(6829); -var anchors = __nccwpck_require__(1596); -var applyReviver = __nccwpck_require__(3661); -var createNode = __nccwpck_require__(2404); -var directives = __nccwpck_require__(1342); +// node_modules/undici/lib/handler/DecoratorHandler.js +var require_DecoratorHandler = __commonJS({ + "node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module2) { + "use strict"; + module2.exports = class DecoratorHandler { + constructor(handler) { + this.handler = handler; + } + onConnect(...args) { + return this.handler.onConnect(...args); + } + onError(...args) { + return this.handler.onError(...args); + } + onUpgrade(...args) { + return this.handler.onUpgrade(...args); + } + onHeaders(...args) { + return this.handler.onHeaders(...args); + } + onData(...args) { + return this.handler.onData(...args); + } + onComplete(...args) { + return this.handler.onComplete(...args); + } + onBodySent(...args) { + return this.handler.onBodySent(...args); + } + }; + } +}); -class Document { - constructor(value, replacer, options) { - /** A comment before this Document */ - this.commentBefore = null; - /** A comment immediately after this Document */ - this.comment = null; - /** Errors encountered during parsing. */ - this.errors = []; - /** Warnings encountered during parsing. */ - this.warnings = []; - Object.defineProperty(this, identity.NODE_TYPE, { value: identity.DOC }); - let _replacer = null; - if (typeof replacer === 'function' || Array.isArray(replacer)) { - _replacer = replacer; - } - else if (options === undefined && replacer) { - options = replacer; - replacer = undefined; +// node_modules/undici/lib/fetch/headers.js +var require_headers = __commonJS({ + "node_modules/undici/lib/fetch/headers.js"(exports2, module2) { + "use strict"; + var { kHeadersList, kConstruct } = require_symbols(); + var { kGuard } = require_symbols2(); + var { kEnumerableProperty } = require_util(); + var { + makeIterator, + isValidHeaderName, + isValidHeaderValue + } = require_util2(); + var util = require("util"); + var { webidl } = require_webidl(); + var assert = require("assert"); + var kHeadersMap = Symbol("headers map"); + var kHeadersSortedMap = Symbol("headers map sorted"); + function isHTTPWhiteSpaceCharCode(code) { + return code === 10 || code === 13 || code === 9 || code === 32; + } + function headerValueNormalize(potentialValue) { + let i = 0; + let j = potentialValue.length; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i; + return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j); + } + function fill(headers, object) { + if (Array.isArray(object)) { + for (let i = 0; i < object.length; ++i) { + const header = object[i]; + if (header.length !== 2) { + throw webidl.errors.exception({ + header: "Headers constructor", + message: `expected name/value pair to be length 2, found ${header.length}.` + }); + } + appendHeader(headers, header[0], header[1]); } - const opt = Object.assign({ - intAsBigInt: false, - keepSourceTokens: false, - logLevel: 'warn', - prettyErrors: true, - strict: true, - stringKeys: false, - uniqueKeys: true, - version: '1.2' - }, options); - this.options = opt; - let { version } = opt; - if (options?._directives) { - this.directives = options._directives.atDocument(); - if (this.directives.yaml.explicit) - version = this.directives.yaml.version; + } else if (typeof object === "object" && object !== null) { + const keys = Object.keys(object); + for (let i = 0; i < keys.length; ++i) { + appendHeader(headers, keys[i], object[keys[i]]); } - else - this.directives = new directives.Directives({ version }); - this.setSchema(version, options); - // @ts-expect-error We can't really know that this matches Contents. - this.contents = - value === undefined ? null : this.createNode(value, _replacer, options); - } - /** - * Create a deep copy of this Document and its contents. - * - * Custom Node values that inherit from `Object` still refer to their original instances. - */ - clone() { - const copy = Object.create(Document.prototype, { - [identity.NODE_TYPE]: { value: identity.DOC } + } else { + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] }); - copy.commentBefore = this.commentBefore; - copy.comment = this.comment; - copy.errors = this.errors.slice(); - copy.warnings = this.warnings.slice(); - copy.options = Object.assign({}, this.options); - if (this.directives) - copy.directives = this.directives.clone(); - copy.schema = this.schema.clone(); - // @ts-expect-error We can't really know that this matches Contents. - copy.contents = identity.isNode(this.contents) - ? this.contents.clone(copy.schema) - : this.contents; - if (this.range) - copy.range = this.range.slice(); - return copy; + } } - /** Adds a value to the document. */ - add(value) { - if (assertCollection(this.contents)) - this.contents.add(value); + function appendHeader(headers, name, value) { + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value, + type: "header value" + }); + } + if (headers[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (headers[kGuard] === "request-no-cors") { + } + return headers[kHeadersList].append(name, value); } - /** Adds a value to the document. */ - addIn(path, value) { - if (assertCollection(this.contents)) - this.contents.addIn(path, value); - } - /** - * Create a new `Alias` node, ensuring that the target `node` has the required anchor. - * - * If `node` already has an anchor, `name` is ignored. - * Otherwise, the `node.anchor` value will be set to `name`, - * or if an anchor with that name is already present in the document, - * `name` will be used as a prefix for a new unique anchor. - * If `name` is undefined, the generated anchor will use 'a' as a prefix. - */ - createAlias(node, name) { - if (!node.anchor) { - const prev = anchors.anchorNames(this); - node.anchor = - // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing - !name || prev.has(name) ? anchors.findNewAnchor(name || 'a', prev) : name; + var HeadersList = class _HeadersList { + /** @type {[string, string][]|null} */ + cookies = null; + constructor(init) { + if (init instanceof _HeadersList) { + this[kHeadersMap] = new Map(init[kHeadersMap]); + this[kHeadersSortedMap] = init[kHeadersSortedMap]; + this.cookies = init.cookies === null ? null : [...init.cookies]; + } else { + this[kHeadersMap] = new Map(init); + this[kHeadersSortedMap] = null; + } + } + // https://fetch.spec.whatwg.org/#header-list-contains + contains(name) { + name = name.toLowerCase(); + return this[kHeadersMap].has(name); + } + clear() { + this[kHeadersMap].clear(); + this[kHeadersSortedMap] = null; + this.cookies = null; + } + // https://fetch.spec.whatwg.org/#concept-header-list-append + append(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + const exists = this[kHeadersMap].get(lowercaseName); + if (exists) { + const delimiter = lowercaseName === "cookie" ? "; " : ", "; + this[kHeadersMap].set(lowercaseName, { + name: exists.name, + value: `${exists.value}${delimiter}${value}` + }); + } else { + this[kHeadersMap].set(lowercaseName, { name, value }); } - return new Alias.Alias(node.anchor); - } - createNode(value, replacer, options) { - let _replacer = undefined; - if (typeof replacer === 'function') { - value = replacer.call({ '': value }, '', value); - _replacer = replacer; + if (lowercaseName === "set-cookie") { + this.cookies ??= []; + this.cookies.push(value); } - else if (Array.isArray(replacer)) { - const keyToStr = (v) => typeof v === 'number' || v instanceof String || v instanceof Number; - const asStr = replacer.filter(keyToStr).map(String); - if (asStr.length > 0) - replacer = replacer.concat(asStr); - _replacer = replacer; + } + // https://fetch.spec.whatwg.org/#concept-header-list-set + set(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + if (lowercaseName === "set-cookie") { + this.cookies = [value]; } - else if (options === undefined && replacer) { - options = replacer; - replacer = undefined; + this[kHeadersMap].set(lowercaseName, { name, value }); + } + // https://fetch.spec.whatwg.org/#concept-header-list-delete + delete(name) { + this[kHeadersSortedMap] = null; + name = name.toLowerCase(); + if (name === "set-cookie") { + this.cookies = null; } - const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {}; - const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, - // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing - anchorPrefix || 'a'); - const ctx = { - aliasDuplicateObjects: aliasDuplicateObjects ?? true, - keepUndefined: keepUndefined ?? false, - onAnchor, - onTagObj, - replacer: _replacer, - schema: this.schema, - sourceObjects - }; - const node = createNode.createNode(value, tag, ctx); - if (flow && identity.isCollection(node)) - node.flow = true; - setAnchors(); - return node; - } - /** - * Convert a key and a value into a `Pair` using the current schema, - * recursively wrapping all values as `Scalar` or `Collection` nodes. - */ - createPair(key, value, options = {}) { - const k = this.createNode(key, null, options); - const v = this.createNode(value, null, options); - return new Pair.Pair(k, v); - } - /** - * Removes a value from the document. - * @returns `true` if the item was found and removed. - */ - delete(key) { - return assertCollection(this.contents) ? this.contents.delete(key) : false; - } - /** - * Removes a value from the document. - * @returns `true` if the item was found and removed. - */ - deleteIn(path) { - if (Collection.isEmptyPath(path)) { - if (this.contents == null) - return false; - // @ts-expect-error Presumed impossible if Strict extends false - this.contents = null; - return true; + this[kHeadersMap].delete(name); + } + // https://fetch.spec.whatwg.org/#concept-header-list-get + get(name) { + const value = this[kHeadersMap].get(name.toLowerCase()); + return value === void 0 ? null : value.value; + } + *[Symbol.iterator]() { + for (const [name, { value }] of this[kHeadersMap]) { + yield [name, value]; } - return assertCollection(this.contents) - ? this.contents.deleteIn(path) - : false; - } - /** - * Returns item at `key`, or `undefined` if not found. By default unwraps - * scalar values from their surrounding node; to disable set `keepScalar` to - * `true` (collections are always returned intact). - */ - get(key, keepScalar) { - return identity.isCollection(this.contents) - ? this.contents.get(key, keepScalar) - : undefined; - } - /** - * Returns item at `path`, or `undefined` if not found. By default unwraps - * scalar values from their surrounding node; to disable set `keepScalar` to - * `true` (collections are always returned intact). - */ - getIn(path, keepScalar) { - if (Collection.isEmptyPath(path)) - return !keepScalar && identity.isScalar(this.contents) - ? this.contents.value - : this.contents; - return identity.isCollection(this.contents) - ? this.contents.getIn(path, keepScalar) - : undefined; - } - /** - * Checks if the document includes a value with the key `key`. - */ - has(key) { - return identity.isCollection(this.contents) ? this.contents.has(key) : false; - } - /** - * Checks if the document includes a value at `path`. - */ - hasIn(path) { - if (Collection.isEmptyPath(path)) - return this.contents !== undefined; - return identity.isCollection(this.contents) ? this.contents.hasIn(path) : false; - } - /** - * Sets a value in this document. For `!!set`, `value` needs to be a - * boolean to add/remove the item from the set. - */ - set(key, value) { - if (this.contents == null) { - // @ts-expect-error We can't really know that this matches Contents. - this.contents = Collection.collectionFromPath(this.schema, [key], value); - } - else if (assertCollection(this.contents)) { - this.contents.set(key, value); - } - } - /** - * Sets a value in this document. For `!!set`, `value` needs to be a - * boolean to add/remove the item from the set. - */ - setIn(path, value) { - if (Collection.isEmptyPath(path)) { - // @ts-expect-error We can't really know that this matches Contents. - this.contents = value; - } - else if (this.contents == null) { - // @ts-expect-error We can't really know that this matches Contents. - this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value); - } - else if (assertCollection(this.contents)) { - this.contents.setIn(path, value); - } - } - /** - * Change the YAML version and schema used by the document. - * A `null` version disables support for directives, explicit tags, anchors, and aliases. - * It also requires the `schema` option to be given as a `Schema` instance value. - * - * Overrides all previously set schema options. - */ - setSchema(version, options = {}) { - if (typeof version === 'number') - version = String(version); - let opt; - switch (version) { - case '1.1': - if (this.directives) - this.directives.yaml.version = '1.1'; - else - this.directives = new directives.Directives({ version: '1.1' }); - opt = { resolveKnownTags: false, schema: 'yaml-1.1' }; - break; - case '1.2': - case 'next': - if (this.directives) - this.directives.yaml.version = version; - else - this.directives = new directives.Directives({ version }); - opt = { resolveKnownTags: true, schema: 'core' }; - break; - case null: - if (this.directives) - delete this.directives; - opt = null; - break; - default: { - const sv = JSON.stringify(version); - throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`); + } + get entries() { + const headers = {}; + if (this[kHeadersMap].size) { + for (const { name, value } of this[kHeadersMap].values()) { + headers[name] = value; + } + } + return headers; + } + }; + var Headers2 = class _Headers { + constructor(init = void 0) { + if (init === kConstruct) { + return; + } + this[kHeadersList] = new HeadersList(); + this[kGuard] = "none"; + if (init !== void 0) { + init = webidl.converters.HeadersInit(init); + fill(this, init); + } + } + // https://fetch.spec.whatwg.org/#dom-headers-append + append(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + return appendHeader(this, name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-delete + delete(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.delete", + value: name, + type: "header name" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + if (!this[kHeadersList].contains(name)) { + return; + } + this[kHeadersList].delete(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-get + get(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.get", + value: name, + type: "header name" + }); + } + return this[kHeadersList].get(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-has + has(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.has", + value: name, + type: "header name" + }); + } + return this[kHeadersList].contains(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-set + set(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value, + type: "header value" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + this[kHeadersList].set(name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie + getSetCookie() { + webidl.brandCheck(this, _Headers); + const list = this[kHeadersList].cookies; + if (list) { + return [...list]; + } + return []; + } + // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine + get [kHeadersSortedMap]() { + if (this[kHeadersList][kHeadersSortedMap]) { + return this[kHeadersList][kHeadersSortedMap]; + } + const headers = []; + const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1); + const cookies = this[kHeadersList].cookies; + for (let i = 0; i < names.length; ++i) { + const [name, value] = names[i]; + if (name === "set-cookie") { + for (let j = 0; j < cookies.length; ++j) { + headers.push([name, cookies[j]]); } + } else { + assert(value !== null); + headers.push([name, value]); + } } - // Not using `instanceof Schema` to allow for duck typing - if (options.schema instanceof Object) - this.schema = options.schema; - else if (opt) - this.schema = new Schema.Schema(Object.assign(opt, options)); - else - throw new Error(`With a null YAML version, the { schema: Schema } option is required`); - } - // json & jsonArg are only used from toJSON() - toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) { - const ctx = { - anchors: new Map(), - doc: this, - keep: !json, - mapAsMap: mapAsMap === true, - mapKeyWarned: false, - maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100 - }; - const res = toJS.toJS(this.contents, jsonArg ?? '', ctx); - if (typeof onAnchor === 'function') - for (const { count, res } of ctx.anchors.values()) - onAnchor(res, count); - return typeof reviver === 'function' - ? applyReviver.applyReviver(reviver, { '': res }, '', res) - : res; - } - /** - * A JSON representation of the document `contents`. - * - * @param jsonArg Used by `JSON.stringify` to indicate the array index or - * property name. - */ - toJSON(jsonArg, onAnchor) { - return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor }); - } - /** A YAML representation of the document. */ - toString(options = {}) { - if (this.errors.length > 0) - throw new Error('Document with errors cannot be stringified'); - if ('indent' in options && - (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) { - const s = JSON.stringify(options.indent); - throw new Error(`"indent" option must be a positive integer, not ${s}`); + this[kHeadersList][kHeadersSortedMap] = headers; + return headers; + } + keys() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key" + ); + } + values() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "value" + ); + } + entries() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key+value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key+value" + ); + } + /** + * @param {(value: string, key: string, self: Headers) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'." + ); } - return stringifyDocument.stringifyDocument(this, options); - } -} -function assertCollection(contents) { - if (identity.isCollection(contents)) - return true; - throw new Error('Expected a YAML collection as document contents'); -} - -exports.Document = Document; - - -/***/ }), - -/***/ 1596: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var visit = __nccwpck_require__(204); + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); + } + } + [Symbol.for("nodejs.util.inspect.custom")]() { + webidl.brandCheck(this, _Headers); + return this[kHeadersList]; + } + }; + Headers2.prototype[Symbol.iterator] = Headers2.prototype.entries; + Object.defineProperties(Headers2.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + getSetCookie: kEnumerableProperty, + keys: kEnumerableProperty, + values: kEnumerableProperty, + entries: kEnumerableProperty, + forEach: kEnumerableProperty, + [Symbol.iterator]: { enumerable: false }, + [Symbol.toStringTag]: { + value: "Headers", + configurable: true + }, + [util.inspect.custom]: { + enumerable: false + } + }); + webidl.converters.HeadersInit = function(V) { + if (webidl.util.Type(V) === "Object") { + if (V[Symbol.iterator]) { + return webidl.converters["sequence>"](V); + } + return webidl.converters["record"](V); + } + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + }; + module2.exports = { + fill, + Headers: Headers2, + HeadersList + }; + } +}); -/** - * Verify that the input string is a valid anchor. - * - * Will throw on errors. - */ -function anchorIsValid(anchor) { - if (/[\x00-\x19\s,[\]{}]/.test(anchor)) { - const sa = JSON.stringify(anchor); - const msg = `Anchor must not contain whitespace or control characters: ${sa}`; - throw new Error(msg); +// node_modules/undici/lib/fetch/response.js +var require_response = __commonJS({ + "node_modules/undici/lib/fetch/response.js"(exports2, module2) { + "use strict"; + var { Headers: Headers2, HeadersList, fill } = require_headers(); + var { extractBody, cloneBody, mixinBody } = require_body(); + var util = require_util(); + var { kEnumerableProperty } = util; + var { + isValidReasonPhrase, + isCancelled, + isAborted, + isBlobLike: isBlobLike2, + serializeJavascriptValueToJSONString, + isErrorLike, + isomorphicEncode + } = require_util2(); + var { + redirectStatusSet, + nullBodyStatus, + DOMException: DOMException2 + } = require_constants2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { FormData: FormData2 } = require_formdata(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { types } = require("util"); + var ReadableStream = globalThis.ReadableStream || require("stream/web").ReadableStream; + var textEncoder = new TextEncoder("utf-8"); + var Response2 = class _Response { + // Creates network error Response. + static error() { + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kState] = makeNetworkError(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response-json + static json(data, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" }); + if (init !== null) { + init = webidl.converters.ResponseInit(init); + } + const bytes = textEncoder.encode( + serializeJavascriptValueToJSONString(data) + ); + const body = extractBody(bytes); + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "response"; + responseObject[kHeaders][kRealm] = relevantRealm; + initializeResponse(responseObject, init, { body: body[0], type: "application/json" }); + return responseObject; + } + // Creates a redirect Response that redirects to url with status status. + static redirect(url, status = 302) { + const relevantRealm = { settingsObject: {} }; + webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" }); + url = webidl.converters.USVString(url); + status = webidl.converters["unsigned short"](status); + let parsedURL; + try { + parsedURL = new URL(url, getGlobalOrigin()); + } catch (err) { + throw Object.assign(new TypeError("Failed to parse URL from " + url), { + cause: err + }); + } + if (!redirectStatusSet.has(status)) { + throw new RangeError("Invalid status code " + status); + } + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + responseObject[kState].status = status; + const value = isomorphicEncode(URLSerializer(parsedURL)); + responseObject[kState].headersList.append("location", value); + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response + constructor(body = null, init = {}) { + if (body !== null) { + body = webidl.converters.BodyInit(body); + } + init = webidl.converters.ResponseInit(init); + this[kRealm] = { settingsObject: {} }; + this[kState] = makeResponse({}); + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kGuard] = "response"; + this[kHeaders][kHeadersList] = this[kState].headersList; + this[kHeaders][kRealm] = this[kRealm]; + let bodyWithType = null; + if (body != null) { + const [extractedBody, type] = extractBody(body); + bodyWithType = { body: extractedBody, type }; + } + initializeResponse(this, init, bodyWithType); + } + // Returns response’s type, e.g., "cors". + get type() { + webidl.brandCheck(this, _Response); + return this[kState].type; + } + // Returns response’s URL, if it has one; otherwise the empty string. + get url() { + webidl.brandCheck(this, _Response); + const urlList = this[kState].urlList; + const url = urlList[urlList.length - 1] ?? null; + if (url === null) { + return ""; + } + return URLSerializer(url, true); + } + // Returns whether response was obtained through a redirect. + get redirected() { + webidl.brandCheck(this, _Response); + return this[kState].urlList.length > 1; + } + // Returns response’s status. + get status() { + webidl.brandCheck(this, _Response); + return this[kState].status; + } + // Returns whether response’s status is an ok status. + get ok() { + webidl.brandCheck(this, _Response); + return this[kState].status >= 200 && this[kState].status <= 299; + } + // Returns response’s status message. + get statusText() { + webidl.brandCheck(this, _Response); + return this[kState].statusText; + } + // Returns response’s headers as Headers. + get headers() { + webidl.brandCheck(this, _Response); + return this[kHeaders]; + } + get body() { + webidl.brandCheck(this, _Response); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Response); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + // Returns a clone of response. + clone() { + webidl.brandCheck(this, _Response); + if (this.bodyUsed || this.body && this.body.locked) { + throw webidl.errors.exception({ + header: "Response.clone", + message: "Body has already been consumed." + }); + } + const clonedResponse = cloneResponse(this[kState]); + const clonedResponseObject = new _Response(); + clonedResponseObject[kState] = clonedResponse; + clonedResponseObject[kRealm] = this[kRealm]; + clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList; + clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + return clonedResponseObject; + } + }; + mixinBody(Response2); + Object.defineProperties(Response2.prototype, { + type: kEnumerableProperty, + url: kEnumerableProperty, + status: kEnumerableProperty, + ok: kEnumerableProperty, + redirected: kEnumerableProperty, + statusText: kEnumerableProperty, + headers: kEnumerableProperty, + clone: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Response", + configurable: true + } + }); + Object.defineProperties(Response2, { + json: kEnumerableProperty, + redirect: kEnumerableProperty, + error: kEnumerableProperty + }); + function cloneResponse(response) { + if (response.internalResponse) { + return filterResponse( + cloneResponse(response.internalResponse), + response.type + ); + } + const newResponse = makeResponse({ ...response, body: null }); + if (response.body != null) { + newResponse.body = cloneBody(response.body); + } + return newResponse; + } + function makeResponse(init) { + return { + aborted: false, + rangeRequested: false, + timingAllowPassed: false, + requestIncludesCredentials: false, + type: "default", + status: 200, + timingInfo: null, + cacheState: "", + statusText: "", + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList(), + urlList: init.urlList ? [...init.urlList] : [] + }; + } + function makeNetworkError(reason) { + const isError = isErrorLike(reason); + return makeResponse({ + type: "error", + status: 0, + error: isError ? reason : new Error(reason ? String(reason) : reason), + aborted: reason && reason.name === "AbortError" + }); + } + function makeFilteredResponse(response, state) { + state = { + internalResponse: response, + ...state + }; + return new Proxy(response, { + get(target, p) { + return p in state ? state[p] : target[p]; + }, + set(target, p, value) { + assert(!(p in state)); + target[p] = value; + return true; + } + }); + } + function filterResponse(response, type) { + if (type === "basic") { + return makeFilteredResponse(response, { + type: "basic", + headersList: response.headersList + }); + } else if (type === "cors") { + return makeFilteredResponse(response, { + type: "cors", + headersList: response.headersList + }); + } else if (type === "opaque") { + return makeFilteredResponse(response, { + type: "opaque", + urlList: Object.freeze([]), + status: 0, + statusText: "", + body: null + }); + } else if (type === "opaqueredirect") { + return makeFilteredResponse(response, { + type: "opaqueredirect", + status: 0, + statusText: "", + headersList: [], + body: null + }); + } else { + assert(false); + } } - return true; -} -function anchorNames(root) { - const anchors = new Set(); - visit.visit(root, { - Value(_key, node) { - if (node.anchor) - anchors.add(node.anchor); + function makeAppropriateNetworkError(fetchParams, err = null) { + assert(isCancelled(fetchParams)); + return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException2("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException2("Request was cancelled."), { cause: err })); + } + function initializeResponse(response, init, body) { + if (init.status !== null && (init.status < 200 || init.status > 599)) { + throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.'); + } + if ("statusText" in init && init.statusText != null) { + if (!isValidReasonPhrase(String(init.statusText))) { + throw new TypeError("Invalid statusText"); } - }); - return anchors; -} -/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */ -function findNewAnchor(prefix, exclude) { - for (let i = 1; true; ++i) { - const name = `${prefix}${i}`; - if (!exclude.has(name)) - return name; + } + if ("status" in init && init.status != null) { + response[kState].status = init.status; + } + if ("statusText" in init && init.statusText != null) { + response[kState].statusText = init.statusText; + } + if ("headers" in init && init.headers != null) { + fill(response[kHeaders], init.headers); + } + if (body) { + if (nullBodyStatus.includes(response.status)) { + throw webidl.errors.exception({ + header: "Response constructor", + message: "Invalid response status code " + response.status + }); + } + response[kState].body = body.body; + if (body.type != null && !response[kState].headersList.contains("Content-Type")) { + response[kState].headersList.append("content-type", body.type); + } + } } -} -function createNodeAnchors(doc, prefix) { - const aliasObjects = []; - const sourceObjects = new Map(); - let prevAnchors = null; - return { - onAnchor: (source) => { - aliasObjects.push(source); - prevAnchors ?? (prevAnchors = anchorNames(doc)); - const anchor = findNewAnchor(prefix, prevAnchors); - prevAnchors.add(anchor); - return anchor; - }, - /** - * With circular references, the source node is only resolved after all - * of its child nodes are. This is why anchors are set only after all of - * the nodes have been created. - */ - setAnchors: () => { - for (const source of aliasObjects) { - const ref = sourceObjects.get(source); - if (typeof ref === 'object' && - ref.anchor && - (identity.isScalar(ref.node) || identity.isCollection(ref.node))) { - ref.node.anchor = ref.anchor; - } - else { - const error = new Error('Failed to resolve repeated object (this should not happen)'); - error.source = source; - throw error; - } - } - }, - sourceObjects + webidl.converters.ReadableStream = webidl.interfaceConverter( + ReadableStream + ); + webidl.converters.FormData = webidl.interfaceConverter( + FormData2 + ); + webidl.converters.URLSearchParams = webidl.interfaceConverter( + URLSearchParams + ); + webidl.converters.XMLHttpRequestBodyInit = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (types.isArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) { + return webidl.converters.BufferSource(V); + } + if (util.isFormDataLike(V)) { + return webidl.converters.FormData(V, { strict: false }); + } + if (V instanceof URLSearchParams) { + return webidl.converters.URLSearchParams(V); + } + return webidl.converters.DOMString(V); }; -} - -exports.anchorIsValid = anchorIsValid; -exports.anchorNames = anchorNames; -exports.createNodeAnchors = createNodeAnchors; -exports.findNewAnchor = findNewAnchor; - - -/***/ }), - -/***/ 3661: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - + webidl.converters.BodyInit = function(V) { + if (V instanceof ReadableStream) { + return webidl.converters.ReadableStream(V); + } + if (V?.[Symbol.asyncIterator]) { + return V; + } + return webidl.converters.XMLHttpRequestBodyInit(V); + }; + webidl.converters.ResponseInit = webidl.dictionaryConverter([ + { + key: "status", + converter: webidl.converters["unsigned short"], + defaultValue: 200 + }, + { + key: "statusText", + converter: webidl.converters.ByteString, + defaultValue: "" + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + } + ]); + module2.exports = { + makeNetworkError, + makeResponse, + makeAppropriateNetworkError, + filterResponse, + Response: Response2, + cloneResponse + }; + } +}); -/** - * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec, - * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the - * 2021 edition: https://tc39.es/ecma262/#sec-json.parse - * - * Includes extensions for handling Map and Set objects. - */ -function applyReviver(reviver, obj, key, val) { - if (val && typeof val === 'object') { - if (Array.isArray(val)) { - for (let i = 0, len = val.length; i < len; ++i) { - const v0 = val[i]; - const v1 = applyReviver(reviver, val, String(i), v0); - // eslint-disable-next-line @typescript-eslint/no-array-delete - if (v1 === undefined) - delete val[i]; - else if (v1 !== v0) - val[i] = v1; +// node_modules/undici/lib/fetch/request.js +var require_request2 = __commonJS({ + "node_modules/undici/lib/fetch/request.js"(exports2, module2) { + "use strict"; + var { extractBody, mixinBody, cloneBody } = require_body(); + var { Headers: Headers2, fill: fillHeaders, HeadersList } = require_headers(); + var { FinalizationRegistry } = require_dispatcher_weakref()(); + var util = require_util(); + var { + isValidHTTPToken, + sameOrigin, + normalizeMethod, + makePolicyContainer, + normalizeMethodRecord + } = require_util2(); + var { + forbiddenMethodsSet, + corsSafeListedMethodsSet, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + requestDuplex + } = require_constants2(); + var { kEnumerableProperty } = util; + var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events"); + var TransformStream = globalThis.TransformStream; + var kAbortController = Symbol("abortController"); + var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => { + signal.removeEventListener("abort", abort); + }); + var Request = class _Request { + // https://fetch.spec.whatwg.org/#dom-request + constructor(input, init = {}) { + if (input === kConstruct) { + return; + } + webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" }); + input = webidl.converters.RequestInfo(input); + init = webidl.converters.RequestInit(init); + this[kRealm] = { + settingsObject: { + baseUrl: getGlobalOrigin(), + get origin() { + return this.baseUrl?.origin; + }, + policyContainer: makePolicyContainer() + } + }; + let request = null; + let fallbackMode = null; + const baseUrl = this[kRealm].settingsObject.baseUrl; + let signal = null; + if (typeof input === "string") { + let parsedURL; + try { + parsedURL = new URL(input, baseUrl); + } catch (err) { + throw new TypeError("Failed to parse URL from " + input, { cause: err }); + } + if (parsedURL.username || parsedURL.password) { + throw new TypeError( + "Request cannot be constructed from a URL that includes credentials: " + input + ); + } + request = makeRequest({ urlList: [parsedURL] }); + fallbackMode = "cors"; + } else { + assert(input instanceof _Request); + request = input[kState]; + signal = input[kSignal]; + } + const origin = this[kRealm].settingsObject.origin; + let window2 = "client"; + if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) { + window2 = request.window; + } + if (init.window != null) { + throw new TypeError(`'window' option '${window2}' must be null`); + } + if ("window" in init) { + window2 = "no-window"; + } + request = makeRequest({ + // URL request’s URL. + // undici implementation note: this is set as the first item in request's urlList in makeRequest + // method request’s method. + method: request.method, + // header list A copy of request’s header list. + // undici implementation note: headersList is cloned in makeRequest + headersList: request.headersList, + // unsafe-request flag Set. + unsafeRequest: request.unsafeRequest, + // client This’s relevant settings object. + client: this[kRealm].settingsObject, + // window window. + window: window2, + // priority request’s priority. + priority: request.priority, + // origin request’s origin. The propagation of the origin is only significant for navigation requests + // being handled by a service worker. In this scenario a request can have an origin that is different + // from the current client. + origin: request.origin, + // referrer request’s referrer. + referrer: request.referrer, + // referrer policy request’s referrer policy. + referrerPolicy: request.referrerPolicy, + // mode request’s mode. + mode: request.mode, + // credentials mode request’s credentials mode. + credentials: request.credentials, + // cache mode request’s cache mode. + cache: request.cache, + // redirect mode request’s redirect mode. + redirect: request.redirect, + // integrity metadata request’s integrity metadata. + integrity: request.integrity, + // keepalive request’s keepalive. + keepalive: request.keepalive, + // reload-navigation flag request’s reload-navigation flag. + reloadNavigation: request.reloadNavigation, + // history-navigation flag request’s history-navigation flag. + historyNavigation: request.historyNavigation, + // URL list A clone of request’s URL list. + urlList: [...request.urlList] + }); + const initHasKey = Object.keys(init).length !== 0; + if (initHasKey) { + if (request.mode === "navigate") { + request.mode = "same-origin"; + } + request.reloadNavigation = false; + request.historyNavigation = false; + request.origin = "client"; + request.referrer = "client"; + request.referrerPolicy = ""; + request.url = request.urlList[request.urlList.length - 1]; + request.urlList = [request.url]; + } + if (init.referrer !== void 0) { + const referrer = init.referrer; + if (referrer === "") { + request.referrer = "no-referrer"; + } else { + let parsedReferrer; + try { + parsedReferrer = new URL(referrer, baseUrl); + } catch (err) { + throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err }); } - } - else if (val instanceof Map) { - for (const k of Array.from(val.keys())) { - const v0 = val.get(k); - const v1 = applyReviver(reviver, val, k, v0); - if (v1 === undefined) - val.delete(k); - else if (v1 !== v0) - val.set(k, v1); + if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) { + request.referrer = "client"; + } else { + request.referrer = parsedReferrer; } + } } - else if (val instanceof Set) { - for (const v0 of Array.from(val)) { - const v1 = applyReviver(reviver, val, v0, v0); - if (v1 === undefined) - val.delete(v0); - else if (v1 !== v0) { - val.delete(v0); - val.add(v1); - } - } + if (init.referrerPolicy !== void 0) { + request.referrerPolicy = init.referrerPolicy; } - else { - for (const [k, v0] of Object.entries(val)) { - const v1 = applyReviver(reviver, val, k, v0); - if (v1 === undefined) - delete val[k]; - else if (v1 !== v0) - val[k] = v1; - } + let mode; + if (init.mode !== void 0) { + mode = init.mode; + } else { + mode = fallbackMode; } - } - return reviver.call(obj, key, val); -} - -exports.applyReviver = applyReviver; - - -/***/ }), - -/***/ 2404: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Alias = __nccwpck_require__(4065); -var identity = __nccwpck_require__(1127); -var Scalar = __nccwpck_require__(3301); - -const defaultTagPrefix = 'tag:yaml.org,2002:'; -function findTagObject(value, tagName, tags) { - if (tagName) { - const match = tags.filter(t => t.tag === tagName); - const tagObj = match.find(t => !t.format) ?? match[0]; - if (!tagObj) - throw new Error(`Tag ${tagName} not found`); - return tagObj; - } - return tags.find(t => t.identify?.(value) && !t.format); -} -function createNode(value, tagName, ctx) { - if (identity.isDocument(value)) - value = value.contents; - if (identity.isNode(value)) - return value; - if (identity.isPair(value)) { - const map = ctx.schema[identity.MAP].createNode?.(ctx.schema, null, ctx); - map.items.push(value); - return map; - } - if (value instanceof String || - value instanceof Number || - value instanceof Boolean || - (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere - ) { - // https://tc39.es/ecma262/#sec-serializejsonproperty - value = value.valueOf(); - } - const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx; - // Detect duplicate references to the same object & use Alias nodes for all - // after first. The `ref` wrapper allows for circular references to resolve. - let ref = undefined; - if (aliasDuplicateObjects && value && typeof value === 'object') { - ref = sourceObjects.get(value); - if (ref) { - ref.anchor ?? (ref.anchor = onAnchor(value)); - return new Alias.Alias(ref.anchor); + if (mode === "navigate") { + throw webidl.errors.exception({ + header: "Request constructor", + message: "invalid request mode navigate." + }); } - else { - ref = { anchor: null, node: null }; - sourceObjects.set(value, ref); + if (mode != null) { + request.mode = mode; } - } - if (tagName?.startsWith('!!')) - tagName = defaultTagPrefix + tagName.slice(2); - let tagObj = findTagObject(value, tagName, schema.tags); - if (!tagObj) { - if (value && typeof value.toJSON === 'function') { - // eslint-disable-next-line @typescript-eslint/no-unsafe-call - value = value.toJSON(); - } - if (!value || typeof value !== 'object') { - const node = new Scalar.Scalar(value); - if (ref) - ref.node = node; - return node; - } - tagObj = - value instanceof Map - ? schema[identity.MAP] - : Symbol.iterator in Object(value) - ? schema[identity.SEQ] - : schema[identity.MAP]; - } - if (onTagObj) { - onTagObj(tagObj); - delete ctx.onTagObj; - } - const node = tagObj?.createNode - ? tagObj.createNode(ctx.schema, value, ctx) - : typeof tagObj?.nodeClass?.from === 'function' - ? tagObj.nodeClass.from(ctx.schema, value, ctx) - : new Scalar.Scalar(value); - if (tagName) - node.tag = tagName; - else if (!tagObj.default) - node.tag = tagObj.tag; - if (ref) - ref.node = node; - return node; -} - -exports.createNode = createNode; - - -/***/ }), - -/***/ 1342: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var visit = __nccwpck_require__(204); - -const escapeChars = { - '!': '%21', - ',': '%2C', - '[': '%5B', - ']': '%5D', - '{': '%7B', - '}': '%7D' -}; -const escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, ch => escapeChars[ch]); -class Directives { - constructor(yaml, tags) { - /** - * The directives-end/doc-start marker `---`. If `null`, a marker may still be - * included in the document's stringified representation. - */ - this.docStart = null; - /** The doc-end marker `...`. */ - this.docEnd = false; - this.yaml = Object.assign({}, Directives.defaultYaml, yaml); - this.tags = Object.assign({}, Directives.defaultTags, tags); - } - clone() { - const copy = new Directives(this.yaml, this.tags); - copy.docStart = this.docStart; - return copy; - } - /** - * During parsing, get a Directives instance for the current document and - * update the stream state according to the current version's spec. - */ - atDocument() { - const res = new Directives(this.yaml, this.tags); - switch (this.yaml.version) { - case '1.1': - this.atNextDocument = true; - break; - case '1.2': - this.atNextDocument = false; - this.yaml = { - explicit: Directives.defaultYaml.explicit, - version: '1.2' - }; - this.tags = Object.assign({}, Directives.defaultTags); - break; + if (init.credentials !== void 0) { + request.credentials = init.credentials; } - return res; - } - /** - * @param onError - May be called even if the action was successful - * @returns `true` on success - */ - add(line, onError) { - if (this.atNextDocument) { - this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' }; - this.tags = Object.assign({}, Directives.defaultTags); - this.atNextDocument = false; + if (init.cache !== void 0) { + request.cache = init.cache; } - const parts = line.trim().split(/[ \t]+/); - const name = parts.shift(); - switch (name) { - case '%TAG': { - if (parts.length !== 2) { - onError(0, '%TAG directive should contain exactly two parts'); - if (parts.length < 2) - return false; - } - const [handle, prefix] = parts; - this.tags[handle] = prefix; - return true; - } - case '%YAML': { - this.yaml.explicit = true; - if (parts.length !== 1) { - onError(0, '%YAML directive should contain exactly one part'); - return false; - } - const [version] = parts; - if (version === '1.1' || version === '1.2') { - this.yaml.version = version; - return true; - } - else { - const isValid = /^\d+\.\d+$/.test(version); - onError(6, `Unsupported YAML version ${version}`, isValid); - return false; - } - } - default: - onError(0, `Unknown directive ${name}`, true); - return false; + if (request.cache === "only-if-cached" && request.mode !== "same-origin") { + throw new TypeError( + "'only-if-cached' can be set only with 'same-origin' mode" + ); } - } - /** - * Resolves a tag, matching handles to those defined in %TAG directives. - * - * @returns Resolved tag, which may also be the non-specific tag `'!'` or a - * `'!local'` tag, or `null` if unresolvable. - */ - tagName(source, onError) { - if (source === '!') - return '!'; // non-specific tag - if (source[0] !== '!') { - onError(`Not a valid tag: ${source}`); - return null; + if (init.redirect !== void 0) { + request.redirect = init.redirect; } - if (source[1] === '<') { - const verbatim = source.slice(2, -1); - if (verbatim === '!' || verbatim === '!!') { - onError(`Verbatim tags aren't resolved, so ${source} is invalid.`); - return null; - } - if (source[source.length - 1] !== '>') - onError('Verbatim tags must end with a >'); - return verbatim; + if (init.integrity != null) { + request.integrity = String(init.integrity); } - const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s); - if (!suffix) - onError(`The ${source} tag has no suffix`); - const prefix = this.tags[handle]; - if (prefix) { + if (init.keepalive !== void 0) { + request.keepalive = Boolean(init.keepalive); + } + if (init.method !== void 0) { + let method = init.method; + if (!isValidHTTPToken(method)) { + throw new TypeError(`'${method}' is not a valid HTTP method.`); + } + if (forbiddenMethodsSet.has(method.toUpperCase())) { + throw new TypeError(`'${method}' HTTP method is unsupported.`); + } + method = normalizeMethodRecord[method] ?? normalizeMethod(method); + request.method = method; + } + if (init.signal !== void 0) { + signal = init.signal; + } + this[kState] = request; + const ac = new AbortController(); + this[kSignal] = ac.signal; + this[kSignal][kRealm] = this[kRealm]; + if (signal != null) { + if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") { + throw new TypeError( + "Failed to construct 'Request': member signal is not of type AbortSignal." + ); + } + if (signal.aborted) { + ac.abort(signal.reason); + } else { + this[kAbortController] = ac; + const acRef = new WeakRef(ac); + const abort = function() { + const ac2 = acRef.deref(); + if (ac2 !== void 0) { + ac2.abort(this.reason); + } + }; try { - return prefix + decodeURIComponent(suffix); - } - catch (error) { - onError(String(error)); - return null; + if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) { + setMaxListeners(100, signal); + } else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) { + setMaxListeners(100, signal); + } + } catch { } + util.addAbortListener(signal, abort); + requestFinalizer.register(ac, { signal, abort }); + } } - if (handle === '!') - return source; // local tag - onError(`Could not resolve tag: ${source}`); - return null; - } - /** - * Given a fully resolved tag, returns its printable string form, - * taking into account current tag prefixes and defaults. - */ - tagString(tag) { - for (const [handle, prefix] of Object.entries(this.tags)) { - if (tag.startsWith(prefix)) - return handle + escapeTagName(tag.substring(prefix.length)); + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kHeadersList] = request.headersList; + this[kHeaders][kGuard] = "request"; + this[kHeaders][kRealm] = this[kRealm]; + if (mode === "no-cors") { + if (!corsSafeListedMethodsSet.has(request.method)) { + throw new TypeError( + `'${request.method} is unsupported in no-cors mode.` + ); + } + this[kHeaders][kGuard] = "request-no-cors"; + } + if (initHasKey) { + const headersList = this[kHeaders][kHeadersList]; + const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList); + headersList.clear(); + if (headers instanceof HeadersList) { + for (const [key, val] of headers) { + headersList.append(key, val); + } + headersList.cookies = headers.cookies; + } else { + fillHeaders(this[kHeaders], headers); + } } - return tag[0] === '!' ? tag : `!<${tag}>`; - } - toString(doc) { - const lines = this.yaml.explicit - ? [`%YAML ${this.yaml.version || '1.2'}`] - : []; - const tagEntries = Object.entries(this.tags); - let tagNames; - if (doc && tagEntries.length > 0 && identity.isNode(doc.contents)) { - const tags = {}; - visit.visit(doc.contents, (_key, node) => { - if (identity.isNode(node) && node.tag) - tags[node.tag] = true; - }); - tagNames = Object.keys(tags); + const inputBody = input instanceof _Request ? input[kState].body : null; + if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) { + throw new TypeError("Request with GET/HEAD method cannot have body."); + } + let initBody = null; + if (init.body != null) { + const [extractedBody, contentType] = extractBody( + init.body, + request.keepalive + ); + initBody = extractedBody; + if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) { + this[kHeaders].append("content-type", contentType); + } } - else - tagNames = []; - for (const [handle, prefix] of tagEntries) { - if (handle === '!!' && prefix === 'tag:yaml.org,2002:') - continue; - if (!doc || tagNames.some(tn => tn.startsWith(prefix))) - lines.push(`%TAG ${handle} ${prefix}`); + const inputOrInitBody = initBody ?? inputBody; + if (inputOrInitBody != null && inputOrInitBody.source == null) { + if (initBody != null && init.duplex == null) { + throw new TypeError("RequestInit: duplex option is required when sending a body."); + } + if (request.mode !== "same-origin" && request.mode !== "cors") { + throw new TypeError( + 'If request is made from ReadableStream, mode should be "same-origin" or "cors"' + ); + } + request.useCORSPreflightFlag = true; + } + let finalBody = inputOrInitBody; + if (initBody == null && inputBody != null) { + if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) { + throw new TypeError( + "Cannot construct a Request with a Request object that has already been used." + ); + } + if (!TransformStream) { + TransformStream = require("stream/web").TransformStream; + } + const identityTransform = new TransformStream(); + inputBody.stream.pipeThrough(identityTransform); + finalBody = { + source: inputBody.source, + length: inputBody.length, + stream: identityTransform.readable + }; + } + this[kState].body = finalBody; + } + // Returns request’s HTTP method, which is "GET" by default. + get method() { + webidl.brandCheck(this, _Request); + return this[kState].method; + } + // Returns the URL of request as a string. + get url() { + webidl.brandCheck(this, _Request); + return URLSerializer(this[kState].url); + } + // Returns a Headers object consisting of the headers associated with request. + // Note that headers added in the network layer by the user agent will not + // be accounted for in this object, e.g., the "Host" header. + get headers() { + webidl.brandCheck(this, _Request); + return this[kHeaders]; + } + // Returns the kind of resource requested by request, e.g., "document" + // or "script". + get destination() { + webidl.brandCheck(this, _Request); + return this[kState].destination; + } + // Returns the referrer of request. Its value can be a same-origin URL if + // explicitly set in init, the empty string to indicate no referrer, and + // "about:client" when defaulting to the global’s default. This is used + // during fetching to determine the value of the `Referer` header of the + // request being made. + get referrer() { + webidl.brandCheck(this, _Request); + if (this[kState].referrer === "no-referrer") { + return ""; + } + if (this[kState].referrer === "client") { + return "about:client"; + } + return this[kState].referrer.toString(); + } + // Returns the referrer policy associated with request. + // This is used during fetching to compute the value of the request’s + // referrer. + get referrerPolicy() { + webidl.brandCheck(this, _Request); + return this[kState].referrerPolicy; + } + // Returns the mode associated with request, which is a string indicating + // whether the request will use CORS, or will be restricted to same-origin + // URLs. + get mode() { + webidl.brandCheck(this, _Request); + return this[kState].mode; + } + // Returns the credentials mode associated with request, + // which is a string indicating whether credentials will be sent with the + // request always, never, or only when sent to a same-origin URL. + get credentials() { + return this[kState].credentials; + } + // Returns the cache mode associated with request, + // which is a string indicating how the request will + // interact with the browser’s cache when fetching. + get cache() { + webidl.brandCheck(this, _Request); + return this[kState].cache; + } + // Returns the redirect mode associated with request, + // which is a string indicating how redirects for the + // request will be handled during fetching. A request + // will follow redirects by default. + get redirect() { + webidl.brandCheck(this, _Request); + return this[kState].redirect; + } + // Returns request’s subresource integrity metadata, which is a + // cryptographic hash of the resource being fetched. Its value + // consists of multiple hashes separated by whitespace. [SRI] + get integrity() { + webidl.brandCheck(this, _Request); + return this[kState].integrity; + } + // Returns a boolean indicating whether or not request can outlive the + // global in which it was created. + get keepalive() { + webidl.brandCheck(this, _Request); + return this[kState].keepalive; + } + // Returns a boolean indicating whether or not request is for a reload + // navigation. + get isReloadNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].reloadNavigation; + } + // Returns a boolean indicating whether or not request is for a history + // navigation (a.k.a. back-foward navigation). + get isHistoryNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].historyNavigation; + } + // Returns the signal associated with request, which is an AbortSignal + // object indicating whether or not request has been aborted, and its + // abort event handler. + get signal() { + webidl.brandCheck(this, _Request); + return this[kSignal]; + } + get body() { + webidl.brandCheck(this, _Request); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Request); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + get duplex() { + webidl.brandCheck(this, _Request); + return "half"; + } + // Returns a clone of request. + clone() { + webidl.brandCheck(this, _Request); + if (this.bodyUsed || this.body?.locked) { + throw new TypeError("unusable"); + } + const clonedRequest = cloneRequest(this[kState]); + const clonedRequestObject = new _Request(kConstruct); + clonedRequestObject[kState] = clonedRequest; + clonedRequestObject[kRealm] = this[kRealm]; + clonedRequestObject[kHeaders] = new Headers2(kConstruct); + clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList; + clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + const ac = new AbortController(); + if (this.signal.aborted) { + ac.abort(this.signal.reason); + } else { + util.addAbortListener( + this.signal, + () => { + ac.abort(this.signal.reason); + } + ); } - return lines.join('\n'); - } -} -Directives.defaultYaml = { explicit: false, version: '1.2' }; -Directives.defaultTags = { '!!': 'tag:yaml.org,2002:' }; - -exports.Directives = Directives; - - -/***/ }), - -/***/ 1464: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - + clonedRequestObject[kSignal] = ac.signal; + return clonedRequestObject; + } + }; + mixinBody(Request); + function makeRequest(init) { + const request = { + method: "GET", + localURLsOnly: false, + unsafeRequest: false, + body: null, + client: null, + reservedClient: null, + replacesClientId: "", + window: "client", + keepalive: false, + serviceWorkers: "all", + initiator: "", + destination: "", + priority: null, + origin: "client", + policyContainer: "client", + referrer: "client", + referrerPolicy: "", + mode: "no-cors", + useCORSPreflightFlag: false, + credentials: "same-origin", + useCredentials: false, + cache: "default", + redirect: "follow", + integrity: "", + cryptoGraphicsNonceMetadata: "", + parserMetadata: "", + reloadNavigation: false, + historyNavigation: false, + userActivation: false, + taintedOrigin: false, + redirectCount: 0, + responseTainting: "basic", + preventNoCacheCacheControlHeaderModification: false, + done: false, + timingAllowFailed: false, + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList() + }; + request.url = request.urlList[0]; + return request; + } + function cloneRequest(request) { + const newRequest = makeRequest({ ...request, body: null }); + if (request.body != null) { + newRequest.body = cloneBody(request.body); + } + return newRequest; + } + Object.defineProperties(Request.prototype, { + method: kEnumerableProperty, + url: kEnumerableProperty, + headers: kEnumerableProperty, + redirect: kEnumerableProperty, + clone: kEnumerableProperty, + signal: kEnumerableProperty, + duplex: kEnumerableProperty, + destination: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + isHistoryNavigation: kEnumerableProperty, + isReloadNavigation: kEnumerableProperty, + keepalive: kEnumerableProperty, + integrity: kEnumerableProperty, + cache: kEnumerableProperty, + credentials: kEnumerableProperty, + attribute: kEnumerableProperty, + referrerPolicy: kEnumerableProperty, + referrer: kEnumerableProperty, + mode: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Request", + configurable: true + } + }); + webidl.converters.Request = webidl.interfaceConverter( + Request + ); + webidl.converters.RequestInfo = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (V instanceof Request) { + return webidl.converters.Request(V); + } + return webidl.converters.USVString(V); + }; + webidl.converters.AbortSignal = webidl.interfaceConverter( + AbortSignal + ); + webidl.converters.RequestInit = webidl.dictionaryConverter([ + { + key: "method", + converter: webidl.converters.ByteString + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + }, + { + key: "body", + converter: webidl.nullableConverter( + webidl.converters.BodyInit + ) + }, + { + key: "referrer", + converter: webidl.converters.USVString + }, + { + key: "referrerPolicy", + converter: webidl.converters.DOMString, + // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy + allowedValues: referrerPolicy + }, + { + key: "mode", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#concept-request-mode + allowedValues: requestMode + }, + { + key: "credentials", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcredentials + allowedValues: requestCredentials + }, + { + key: "cache", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcache + allowedValues: requestCache + }, + { + key: "redirect", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestredirect + allowedValues: requestRedirect + }, + { + key: "integrity", + converter: webidl.converters.DOMString + }, + { + key: "keepalive", + converter: webidl.converters.boolean + }, + { + key: "signal", + converter: webidl.nullableConverter( + (signal) => webidl.converters.AbortSignal( + signal, + { strict: false } + ) + ) + }, + { + key: "window", + converter: webidl.converters.any + }, + { + key: "duplex", + converter: webidl.converters.DOMString, + allowedValues: requestDuplex + } + ]); + module2.exports = { Request, makeRequest }; + } +}); -class YAMLError extends Error { - constructor(name, pos, code, message) { +// node_modules/undici/lib/fetch/index.js +var require_fetch = __commonJS({ + "node_modules/undici/lib/fetch/index.js"(exports2, module2) { + "use strict"; + var { + Response: Response2, + makeNetworkError, + makeAppropriateNetworkError, + filterResponse, + makeResponse + } = require_response(); + var { Headers: Headers2 } = require_headers(); + var { Request, makeRequest } = require_request2(); + var zlib = require("zlib"); + var { + bytesMatch, + makePolicyContainer, + clonePolicyContainer, + requestBadPort, + TAOCheck, + appendRequestOriginHeader, + responseLocationURL, + requestCurrentURL, + setRequestReferrerPolicyOnRedirect, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + createOpaqueTimingInfo, + appendFetchMetadata, + corsCheck, + crossOriginResourcePolicyCheck, + determineRequestsReferrer, + coarsenedSharedCurrentTime, + createDeferredPromise, + isBlobLike: isBlobLike2, + sameOrigin, + isCancelled, + isAborted, + isErrorLike, + fullyReadBody, + readableStreamClose, + isomorphicEncode, + urlIsLocal, + urlIsHttpHttpsScheme, + urlHasHttpsScheme + } = require_util2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var assert = require("assert"); + var { safelyExtractBody } = require_body(); + var { + redirectStatusSet, + nullBodyStatus, + safeMethodsSet, + requestBodyHeader, + subresourceSet, + DOMException: DOMException2 + } = require_constants2(); + var { kHeadersList } = require_symbols(); + var EE = require("events"); + var { Readable, pipeline } = require("stream"); + var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util(); + var { dataURLProcessor, serializeAMimeType } = require_dataURL(); + var { TransformStream } = require("stream/web"); + var { getGlobalDispatcher } = require_global2(); + var { webidl } = require_webidl(); + var { STATUS_CODES } = require("http"); + var GET_OR_HEAD = ["GET", "HEAD"]; + var resolveObjectURL; + var ReadableStream = globalThis.ReadableStream; + var Fetch = class extends EE { + constructor(dispatcher) { super(); - this.name = name; - this.code = code; - this.message = message; - this.pos = pos; - } -} -class YAMLParseError extends YAMLError { - constructor(pos, code, message) { - super('YAMLParseError', pos, code, message); - } -} -class YAMLWarning extends YAMLError { - constructor(pos, code, message) { - super('YAMLWarning', pos, code, message); - } -} -const prettifyError = (src, lc) => (error) => { - if (error.pos[0] === -1) + this.dispatcher = dispatcher; + this.connection = null; + this.dump = false; + this.state = "ongoing"; + this.setMaxListeners(21); + } + terminate(reason) { + if (this.state !== "ongoing") { + return; + } + this.state = "terminated"; + this.connection?.destroy(reason); + this.emit("terminated", reason); + } + // https://fetch.spec.whatwg.org/#fetch-controller-abort + abort(error2) { + if (this.state !== "ongoing") { + return; + } + this.state = "aborted"; + if (!error2) { + error2 = new DOMException2("The operation was aborted.", "AbortError"); + } + this.serializedAbortReason = error2; + this.connection?.destroy(error2); + this.emit("terminated", error2); + } + }; + function fetch2(input, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" }); + const p = createDeferredPromise(); + let requestObject; + try { + requestObject = new Request(input, init); + } catch (e) { + p.reject(e); + return p.promise; + } + const request = requestObject[kState]; + if (requestObject.signal.aborted) { + abortFetch(p, request, null, requestObject.signal.reason); + return p.promise; + } + const globalObject = request.client.globalObject; + if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") { + request.serviceWorkers = "none"; + } + let responseObject = null; + const relevantRealm = null; + let locallyAborted = false; + let controller = null; + addAbortListener( + requestObject.signal, + () => { + locallyAborted = true; + assert(controller != null); + controller.abort(requestObject.signal.reason); + abortFetch(p, request, responseObject, requestObject.signal.reason); + } + ); + const handleFetchDone = (response) => finalizeAndReportTiming(response, "fetch"); + const processResponse = (response) => { + if (locallyAborted) { + return Promise.resolve(); + } + if (response.aborted) { + abortFetch(p, request, responseObject, controller.serializedAbortReason); + return Promise.resolve(); + } + if (response.type === "error") { + p.reject( + Object.assign(new TypeError("fetch failed"), { cause: response.error }) + ); + return Promise.resolve(); + } + responseObject = new Response2(); + responseObject[kState] = response; + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + p.resolve(responseObject); + }; + controller = fetching({ + request, + processResponseEndOfBody: handleFetchDone, + processResponse, + dispatcher: init.dispatcher ?? getGlobalDispatcher() + // undici + }); + return p.promise; + } + function finalizeAndReportTiming(response, initiatorType = "other") { + if (response.type === "error" && response.aborted) { return; - error.linePos = error.pos.map(pos => lc.linePos(pos)); - const { line, col } = error.linePos[0]; - error.message += ` at line ${line}, column ${col}`; - let ci = col - 1; - let lineStr = src - .substring(lc.lineStarts[line - 1], lc.lineStarts[line]) - .replace(/[\n\r]+$/, ''); - // Trim to max 80 chars, keeping col position near the middle - if (ci >= 60 && lineStr.length > 80) { - const trimStart = Math.min(ci - 39, lineStr.length - 79); - lineStr = '…' + lineStr.substring(trimStart); - ci -= trimStart - 1; + } + if (!response.urlList?.length) { + return; + } + const originalURL = response.urlList[0]; + let timingInfo = response.timingInfo; + let cacheState = response.cacheState; + if (!urlIsHttpHttpsScheme(originalURL)) { + return; + } + if (timingInfo === null) { + return; + } + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo({ + startTime: timingInfo.startTime + }); + cacheState = ""; + } + timingInfo.endTime = coarsenedSharedCurrentTime(); + response.timingInfo = timingInfo; + markResourceTiming( + timingInfo, + originalURL, + initiatorType, + globalThis, + cacheState + ); + } + function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) { + if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) { + performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState); + } + } + function abortFetch(p, request, responseObject, error2) { + if (!error2) { + error2 = new DOMException2("The operation was aborted.", "AbortError"); + } + p.reject(error2); + if (request.body != null && isReadable(request.body?.stream)) { + request.body.stream.cancel(error2).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + if (responseObject == null) { + return; + } + const response = responseObject[kState]; + if (response.body != null && isReadable(response.body?.stream)) { + response.body.stream.cancel(error2).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } } - if (lineStr.length > 80) - lineStr = lineStr.substring(0, 79) + '…'; - // Include previous line in context if pointing at line start - if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) { - // Regexp won't match if start is trimmed - let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]); - if (prev.length > 80) - prev = prev.substring(0, 79) + '…\n'; - lineStr = prev + lineStr; + function fetching({ + request, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseEndOfBody, + processResponseConsumeBody, + useParallelQueue = false, + dispatcher + // undici + }) { + let taskDestination = null; + let crossOriginIsolatedCapability = false; + if (request.client != null) { + taskDestination = request.client.globalObject; + crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability; + } + const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability); + const timingInfo = createOpaqueTimingInfo({ + startTime: currenTime + }); + const fetchParams = { + controller: new Fetch(dispatcher), + request, + timingInfo, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseConsumeBody, + processResponseEndOfBody, + taskDestination, + crossOriginIsolatedCapability + }; + assert(!request.body || request.body.stream); + if (request.window === "client") { + request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window"; + } + if (request.origin === "client") { + request.origin = request.client?.origin; + } + if (request.policyContainer === "client") { + if (request.client != null) { + request.policyContainer = clonePolicyContainer( + request.client.policyContainer + ); + } else { + request.policyContainer = makePolicyContainer(); + } + } + if (!request.headersList.contains("accept")) { + const value = "*/*"; + request.headersList.append("accept", value); + } + if (!request.headersList.contains("accept-language")) { + request.headersList.append("accept-language", "*"); + } + if (request.priority === null) { + } + if (subresourceSet.has(request.destination)) { + } + mainFetch(fetchParams).catch((err) => { + fetchParams.controller.terminate(err); + }); + return fetchParams.controller; + } + async function mainFetch(fetchParams, recursive = false) { + const request = fetchParams.request; + let response = null; + if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) { + response = makeNetworkError("local URLs only"); + } + tryUpgradeRequestToAPotentiallyTrustworthyURL(request); + if (requestBadPort(request) === "blocked") { + response = makeNetworkError("bad port"); + } + if (request.referrerPolicy === "") { + request.referrerPolicy = request.policyContainer.referrerPolicy; + } + if (request.referrer !== "no-referrer") { + request.referrer = determineRequestsReferrer(request); + } + if (response === null) { + response = await (async () => { + const currentURL = requestCurrentURL(request); + if ( + // - request’s current URL’s origin is same origin with request’s origin, + // and request’s response tainting is "basic" + sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data" + currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket" + (request.mode === "navigate" || request.mode === "websocket") + ) { + request.responseTainting = "basic"; + return await schemeFetch(fetchParams); + } + if (request.mode === "same-origin") { + return makeNetworkError('request mode cannot be "same-origin"'); + } + if (request.mode === "no-cors") { + if (request.redirect !== "follow") { + return makeNetworkError( + 'redirect mode cannot be "follow" for "no-cors" request' + ); + } + request.responseTainting = "opaque"; + return await schemeFetch(fetchParams); + } + if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) { + return makeNetworkError("URL scheme must be a HTTP(S) scheme"); + } + request.responseTainting = "cors"; + return await httpFetch(fetchParams); + })(); + } + if (recursive) { + return response; + } + if (response.status !== 0 && !response.internalResponse) { + if (request.responseTainting === "cors") { + } + if (request.responseTainting === "basic") { + response = filterResponse(response, "basic"); + } else if (request.responseTainting === "cors") { + response = filterResponse(response, "cors"); + } else if (request.responseTainting === "opaque") { + response = filterResponse(response, "opaque"); + } else { + assert(false); + } + } + let internalResponse = response.status === 0 ? response : response.internalResponse; + if (internalResponse.urlList.length === 0) { + internalResponse.urlList.push(...request.urlList); + } + if (!request.timingAllowFailed) { + response.timingAllowPassed = true; + } + if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range")) { + response = internalResponse = makeNetworkError(); + } + if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) { + internalResponse.body = null; + fetchParams.controller.dump = true; + } + if (request.integrity) { + const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason)); + if (request.responseTainting === "opaque" || response.body == null) { + processBodyError(response.error); + return; + } + const processBody = (bytes) => { + if (!bytesMatch(bytes, request.integrity)) { + processBodyError("integrity mismatch"); + return; + } + response.body = safelyExtractBody(bytes)[0]; + fetchFinale(fetchParams, response); + }; + await fullyReadBody(response.body, processBody, processBodyError); + } else { + fetchFinale(fetchParams, response); + } } - if (/[^ ]/.test(lineStr)) { - let count = 1; - const end = error.linePos[1]; - if (end && end.line === line && end.col > col) { - count = Math.max(1, Math.min(end.col - col, 80 - ci)); + function schemeFetch(fetchParams) { + if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) { + return Promise.resolve(makeAppropriateNetworkError(fetchParams)); + } + const { request } = fetchParams; + const { protocol: scheme } = requestCurrentURL(request); + switch (scheme) { + case "about:": { + return Promise.resolve(makeNetworkError("about scheme is not supported")); + } + case "blob:": { + if (!resolveObjectURL) { + resolveObjectURL = require("buffer").resolveObjectURL; + } + const blobURLEntry = requestCurrentURL(request); + if (blobURLEntry.search.length !== 0) { + return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource.")); + } + const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString()); + if (request.method !== "GET" || !isBlobLike2(blobURLEntryObject)) { + return Promise.resolve(makeNetworkError("invalid method")); + } + const bodyWithType = safelyExtractBody(blobURLEntryObject); + const body = bodyWithType[0]; + const length = isomorphicEncode(`${body.length}`); + const type = bodyWithType[1] ?? ""; + const response = makeResponse({ + statusText: "OK", + headersList: [ + ["content-length", { name: "Content-Length", value: length }], + ["content-type", { name: "Content-Type", value: type }] + ] + }); + response.body = body; + return Promise.resolve(response); + } + case "data:": { + const currentURL = requestCurrentURL(request); + const dataURLStruct = dataURLProcessor(currentURL); + if (dataURLStruct === "failure") { + return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + } + const mimeType = serializeAMimeType(dataURLStruct.mimeType); + return Promise.resolve(makeResponse({ + statusText: "OK", + headersList: [ + ["content-type", { name: "Content-Type", value: mimeType }] + ], + body: safelyExtractBody(dataURLStruct.body)[0] + })); + } + case "file:": { + return Promise.resolve(makeNetworkError("not implemented... yet...")); + } + case "http:": + case "https:": { + return httpFetch(fetchParams).catch((err) => makeNetworkError(err)); + } + default: { + return Promise.resolve(makeNetworkError("unknown scheme")); } - const pointer = ' '.repeat(ci) + '^'.repeat(count); - error.message += `:\n\n${lineStr}\n${pointer}\n`; + } } -}; - -exports.YAMLError = YAMLError; -exports.YAMLParseError = YAMLParseError; -exports.YAMLWarning = YAMLWarning; -exports.prettifyError = prettifyError; - - -/***/ }), - -/***/ 8815: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var composer = __nccwpck_require__(9984); -var Document = __nccwpck_require__(3021); -var Schema = __nccwpck_require__(5840); -var errors = __nccwpck_require__(1464); -var Alias = __nccwpck_require__(4065); -var identity = __nccwpck_require__(1127); -var Pair = __nccwpck_require__(7165); -var Scalar = __nccwpck_require__(3301); -var YAMLMap = __nccwpck_require__(4454); -var YAMLSeq = __nccwpck_require__(2223); -var cst = __nccwpck_require__(3461); -var lexer = __nccwpck_require__(361); -var lineCounter = __nccwpck_require__(6628); -var parser = __nccwpck_require__(3456); -var publicApi = __nccwpck_require__(4047); -var visit = __nccwpck_require__(204); - - - -exports.Composer = composer.Composer; -exports.Document = Document.Document; -exports.Schema = Schema.Schema; -exports.YAMLError = errors.YAMLError; -exports.YAMLParseError = errors.YAMLParseError; -exports.YAMLWarning = errors.YAMLWarning; -exports.Alias = Alias.Alias; -exports.isAlias = identity.isAlias; -exports.isCollection = identity.isCollection; -exports.isDocument = identity.isDocument; -exports.isMap = identity.isMap; -exports.isNode = identity.isNode; -exports.isPair = identity.isPair; -exports.isScalar = identity.isScalar; -exports.isSeq = identity.isSeq; -exports.Pair = Pair.Pair; -exports.Scalar = Scalar.Scalar; -exports.YAMLMap = YAMLMap.YAMLMap; -exports.YAMLSeq = YAMLSeq.YAMLSeq; -exports.CST = cst; -exports.Lexer = lexer.Lexer; -exports.LineCounter = lineCounter.LineCounter; -exports.Parser = parser.Parser; -exports.parse = publicApi.parse; -exports.parseAllDocuments = publicApi.parseAllDocuments; -exports.parseDocument = publicApi.parseDocument; -exports.stringify = publicApi.stringify; -exports.visit = visit.visit; -exports.visitAsync = visit.visitAsync; - - -/***/ }), - -/***/ 7249: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var node_process = __nccwpck_require__(932); - -function debug(logLevel, ...messages) { - if (logLevel === 'debug') - console.log(...messages); -} -function warn(logLevel, warning) { - if (logLevel === 'debug' || logLevel === 'warn') { - if (typeof node_process.emitWarning === 'function') - node_process.emitWarning(warning); - else - console.warn(warning); + function finalizeResponse(fetchParams, response) { + fetchParams.request.done = true; + if (fetchParams.processResponseDone != null) { + queueMicrotask(() => fetchParams.processResponseDone(response)); + } } -} - -exports.debug = debug; -exports.warn = warn; - - -/***/ }), - -/***/ 4065: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var anchors = __nccwpck_require__(1596); -var visit = __nccwpck_require__(204); -var identity = __nccwpck_require__(1127); -var Node = __nccwpck_require__(6673); -var toJS = __nccwpck_require__(4043); - -class Alias extends Node.NodeBase { - constructor(source) { - super(identity.ALIAS); - this.source = source; - Object.defineProperty(this, 'tag', { - set() { - throw new Error('Alias nodes cannot have tags'); - } + function fetchFinale(fetchParams, response) { + if (response.type === "error") { + response.urlList = [fetchParams.request.urlList[0]]; + response.timingInfo = createOpaqueTimingInfo({ + startTime: fetchParams.timingInfo.startTime + }); + } + const processResponseEndOfBody = () => { + fetchParams.request.done = true; + if (fetchParams.processResponseEndOfBody != null) { + queueMicrotask(() => fetchParams.processResponseEndOfBody(response)); + } + }; + if (fetchParams.processResponse != null) { + queueMicrotask(() => fetchParams.processResponse(response)); + } + if (response.body == null) { + processResponseEndOfBody(); + } else { + const identityTransformAlgorithm = (chunk, controller) => { + controller.enqueue(chunk); + }; + const transformStream = new TransformStream({ + start() { + }, + transform: identityTransformAlgorithm, + flush: processResponseEndOfBody + }, { + size() { + return 1; + } + }, { + size() { + return 1; + } }); + response.body = { stream: response.body.stream.pipeThrough(transformStream) }; + } + if (fetchParams.processResponseConsumeBody != null) { + const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes); + const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure); + if (response.body == null) { + queueMicrotask(() => processBody(null)); + } else { + return fullyReadBody(response.body, processBody, processBodyError); + } + return Promise.resolve(); + } } - /** - * Resolve the value of this alias within `doc`, finding the last - * instance of the `source` anchor before this node. - */ - resolve(doc, ctx) { - let nodes; - if (ctx?.aliasResolveCache) { - nodes = ctx.aliasResolveCache; + async function httpFetch(fetchParams) { + const request = fetchParams.request; + let response = null; + let actualResponse = null; + const timingInfo = fetchParams.timingInfo; + if (request.serviceWorkers === "all") { + } + if (response === null) { + if (request.redirect === "follow") { + request.serviceWorkers = "none"; } - else { - nodes = []; - visit.visit(doc, { - Node: (_key, node) => { - if (identity.isAlias(node) || identity.hasAnchor(node)) - nodes.push(node); - } - }); - if (ctx) - ctx.aliasResolveCache = nodes; + actualResponse = response = await httpNetworkOrCacheFetch(fetchParams); + if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") { + return makeNetworkError("cors failure"); } - let found = undefined; - for (const node of nodes) { - if (node === this) - break; - if (node.anchor === this.source) - found = node; + if (TAOCheck(request, response) === "failure") { + request.timingAllowFailed = true; } - return found; + } + if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck( + request.origin, + request.client, + request.destination, + actualResponse + ) === "blocked") { + return makeNetworkError("blocked"); + } + if (redirectStatusSet.has(actualResponse.status)) { + if (request.redirect !== "manual") { + fetchParams.controller.connection.destroy(); + } + if (request.redirect === "error") { + response = makeNetworkError("unexpected redirect"); + } else if (request.redirect === "manual") { + response = actualResponse; + } else if (request.redirect === "follow") { + response = await httpRedirectFetch(fetchParams, response); + } else { + assert(false); + } + } + response.timingInfo = timingInfo; + return response; } - toJSON(_arg, ctx) { - if (!ctx) - return { source: this.source }; - const { anchors, doc, maxAliasCount } = ctx; - const source = this.resolve(doc, ctx); - if (!source) { - const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`; - throw new ReferenceError(msg); + function httpRedirectFetch(fetchParams, response) { + const request = fetchParams.request; + const actualResponse = response.internalResponse ? response.internalResponse : response; + let locationURL; + try { + locationURL = responseLocationURL( + actualResponse, + requestCurrentURL(request).hash + ); + if (locationURL == null) { + return response; } - let data = anchors.get(source); - if (!data) { - // Resolve anchors for Node.prototype.toJS() - toJS.toJS(source, null, ctx); - data = anchors.get(source); + } catch (err) { + return Promise.resolve(makeNetworkError(err)); + } + if (!urlIsHttpHttpsScheme(locationURL)) { + return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme")); + } + if (request.redirectCount === 20) { + return Promise.resolve(makeNetworkError("redirect count exceeded")); + } + request.redirectCount += 1; + if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) { + return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"')); + } + if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) { + return Promise.resolve(makeNetworkError( + 'URL cannot contain credentials for request mode "cors"' + )); + } + if (actualResponse.status !== 303 && request.body != null && request.body.source == null) { + return Promise.resolve(makeNetworkError()); + } + if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) { + request.method = "GET"; + request.body = null; + for (const headerName of requestBodyHeader) { + request.headersList.delete(headerName); + } + } + if (!sameOrigin(requestCurrentURL(request), locationURL)) { + request.headersList.delete("authorization"); + request.headersList.delete("proxy-authorization", true); + request.headersList.delete("cookie"); + request.headersList.delete("host"); + } + if (request.body != null) { + assert(request.body.source != null); + request.body = safelyExtractBody(request.body.source)[0]; + } + const timingInfo = fetchParams.timingInfo; + timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + if (timingInfo.redirectStartTime === 0) { + timingInfo.redirectStartTime = timingInfo.startTime; + } + request.urlList.push(locationURL); + setRequestReferrerPolicyOnRedirect(request, actualResponse); + return mainFetch(fetchParams, true); + } + async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) { + const request = fetchParams.request; + let httpFetchParams = null; + let httpRequest = null; + let response = null; + const httpCache = null; + const revalidatingFlag = false; + if (request.window === "no-window" && request.redirect === "error") { + httpFetchParams = fetchParams; + httpRequest = request; + } else { + httpRequest = makeRequest(request); + httpFetchParams = { ...fetchParams }; + httpFetchParams.request = httpRequest; + } + const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic"; + const contentLength = httpRequest.body ? httpRequest.body.length : null; + let contentLengthHeaderValue = null; + if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) { + contentLengthHeaderValue = "0"; + } + if (contentLength != null) { + contentLengthHeaderValue = isomorphicEncode(`${contentLength}`); + } + if (contentLengthHeaderValue != null) { + httpRequest.headersList.append("content-length", contentLengthHeaderValue); + } + if (contentLength != null && httpRequest.keepalive) { + } + if (httpRequest.referrer instanceof URL) { + httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href)); + } + appendRequestOriginHeader(httpRequest); + appendFetchMetadata(httpRequest); + if (!httpRequest.headersList.contains("user-agent")) { + httpRequest.headersList.append("user-agent", typeof esbuildDetection === "undefined" ? "undici" : "node"); + } + if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) { + httpRequest.cache = "no-store"; + } + if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "max-age=0"); + } + if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") { + if (!httpRequest.headersList.contains("pragma")) { + httpRequest.headersList.append("pragma", "no-cache"); } - /* istanbul ignore if */ - if (!data || data.res === undefined) { - const msg = 'This should not happen: Alias anchor was not resolved?'; - throw new ReferenceError(msg); + if (!httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "no-cache"); } - if (maxAliasCount >= 0) { - data.count += 1; - if (data.aliasCount === 0) - data.aliasCount = getAliasCount(doc, source, anchors); - if (data.count * data.aliasCount > maxAliasCount) { - const msg = 'Excessive alias count indicates a resource exhaustion attack'; - throw new ReferenceError(msg); - } + } + if (httpRequest.headersList.contains("range")) { + httpRequest.headersList.append("accept-encoding", "identity"); + } + if (!httpRequest.headersList.contains("accept-encoding")) { + if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) { + httpRequest.headersList.append("accept-encoding", "br, gzip, deflate"); + } else { + httpRequest.headersList.append("accept-encoding", "gzip, deflate"); } - return data.res; - } - toString(ctx, _onComment, _onChompKeep) { - const src = `*${this.source}`; - if (ctx) { - anchors.anchorIsValid(this.source); - if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) { - const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`; - throw new Error(msg); - } - if (ctx.implicitKey) - return `${src} `; + } + httpRequest.headersList.delete("host"); + if (includeCredentials) { + } + if (httpCache == null) { + httpRequest.cache = "no-store"; + } + if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") { + } + if (response == null) { + if (httpRequest.mode === "only-if-cached") { + return makeNetworkError("only if cached"); } - return src; - } -} -function getAliasCount(doc, node, anchors) { - if (identity.isAlias(node)) { - const source = node.resolve(doc); - const anchor = anchors && source && anchors.get(source); - return anchor ? anchor.count * anchor.aliasCount : 0; - } - else if (identity.isCollection(node)) { - let count = 0; - for (const item of node.items) { - const c = getAliasCount(doc, item, anchors); - if (c > count) - count = c; + const forwardResponse = await httpNetworkFetch( + httpFetchParams, + includeCredentials, + isNewConnectionFetch + ); + if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) { } - return count; - } - else if (identity.isPair(node)) { - const kc = getAliasCount(doc, node.key, anchors); - const vc = getAliasCount(doc, node.value, anchors); - return Math.max(kc, vc); - } - return 1; -} - -exports.Alias = Alias; - - -/***/ }), - -/***/ 101: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var createNode = __nccwpck_require__(2404); -var identity = __nccwpck_require__(1127); -var Node = __nccwpck_require__(6673); - -function collectionFromPath(schema, path, value) { - let v = value; - for (let i = path.length - 1; i >= 0; --i) { - const k = path[i]; - if (typeof k === 'number' && Number.isInteger(k) && k >= 0) { - const a = []; - a[k] = v; - v = a; + if (revalidatingFlag && forwardResponse.status === 304) { } - else { - v = new Map([[k, v]]); + if (response == null) { + response = forwardResponse; + } + } + response.urlList = [...httpRequest.urlList]; + if (httpRequest.headersList.contains("range")) { + response.rangeRequested = true; + } + response.requestIncludesCredentials = includeCredentials; + if (response.status === 407) { + if (request.window === "no-window") { + return makeNetworkError(); + } + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); } + return makeNetworkError("proxy authentication required"); + } + if ( + // response’s status is 421 + response.status === 421 && // isNewConnectionFetch is false + !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null + (request.body == null || request.body.source != null) + ) { + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + fetchParams.controller.connection.destroy(); + response = await httpNetworkOrCacheFetch( + fetchParams, + isAuthenticationFetch, + true + ); + } + if (isAuthenticationFetch) { + } + return response; } - return createNode.createNode(v, undefined, { - aliasDuplicateObjects: false, - keepUndefined: false, - onAnchor: () => { - throw new Error('This should not happen, please report a bug.'); + async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) { + assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed); + fetchParams.controller.connection = { + abort: null, + destroyed: false, + destroy(err) { + if (!this.destroyed) { + this.destroyed = true; + this.abort?.(err ?? new DOMException2("The operation was aborted.", "AbortError")); + } + } + }; + const request = fetchParams.request; + let response = null; + const timingInfo = fetchParams.timingInfo; + const httpCache = null; + if (httpCache == null) { + request.cache = "no-store"; + } + const newConnection = forceNewConnection ? "yes" : "no"; + if (request.mode === "websocket") { + } else { + } + let requestBody = null; + if (request.body == null && fetchParams.processRequestEndOfBody) { + queueMicrotask(() => fetchParams.processRequestEndOfBody()); + } else if (request.body != null) { + const processBodyChunk = async function* (bytes) { + if (isCancelled(fetchParams)) { + return; + } + yield bytes; + fetchParams.processRequestBodyChunkLength?.(bytes.byteLength); + }; + const processEndOfBody = () => { + if (isCancelled(fetchParams)) { + return; + } + if (fetchParams.processRequestEndOfBody) { + fetchParams.processRequestEndOfBody(); + } + }; + const processBodyError = (e) => { + if (isCancelled(fetchParams)) { + return; + } + if (e.name === "AbortError") { + fetchParams.controller.abort(); + } else { + fetchParams.controller.terminate(e); + } + }; + requestBody = async function* () { + try { + for await (const bytes of request.body.stream) { + yield* processBodyChunk(bytes); + } + processEndOfBody(); + } catch (err) { + processBodyError(err); + } + }(); + } + try { + const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody }); + if (socket) { + response = makeResponse({ status, statusText, headersList, socket }); + } else { + const iterator = body[Symbol.asyncIterator](); + fetchParams.controller.next = () => iterator.next(); + response = makeResponse({ status, statusText, headersList }); + } + } catch (err) { + if (err.name === "AbortError") { + fetchParams.controller.connection.destroy(); + return makeAppropriateNetworkError(fetchParams, err); + } + return makeNetworkError(err); + } + const pullAlgorithm = () => { + fetchParams.controller.resume(); + }; + const cancelAlgorithm = (reason) => { + fetchParams.controller.abort(reason); + }; + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + const stream = new ReadableStream( + { + async start(controller) { + fetchParams.controller.controller = controller; + }, + async pull(controller) { + await pullAlgorithm(controller); + }, + async cancel(reason) { + await cancelAlgorithm(reason); + } }, - schema, - sourceObjects: new Map() - }); -} -// Type guard is intentionally a little wrong so as to be more useful, -// as it does not cover untypable empty non-string iterables (e.g. []). -const isEmptyPath = (path) => path == null || - (typeof path === 'object' && !!path[Symbol.iterator]().next().done); -class Collection extends Node.NodeBase { - constructor(type, schema) { - super(type); - Object.defineProperty(this, 'schema', { - value: schema, - configurable: true, - enumerable: false, - writable: true - }); - } - /** - * Create a copy of this collection. - * - * @param schema - If defined, overwrites the original's schema - */ - clone(schema) { - const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this)); - if (schema) - copy.schema = schema; - copy.items = copy.items.map(it => identity.isNode(it) || identity.isPair(it) ? it.clone(schema) : it); - if (this.range) - copy.range = this.range.slice(); - return copy; - } - /** - * Adds a value to the collection. For `!!map` and `!!omap` the value must - * be a Pair instance or a `{ key, value }` object, which may not have a key - * that already exists in the map. - */ - addIn(path, value) { - if (isEmptyPath(path)) - this.add(value); - else { - const [key, ...rest] = path; - const node = this.get(key, true); - if (identity.isCollection(node)) - node.addIn(rest, value); - else if (node === undefined && this.schema) - this.set(key, collectionFromPath(this.schema, rest, value)); - else - throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + { + highWaterMark: 0, + size() { + return 1; + } } - } - /** - * Removes a value from the collection. - * @returns `true` if the item was found and removed. - */ - deleteIn(path) { - const [key, ...rest] = path; - if (rest.length === 0) - return this.delete(key); - const node = this.get(key, true); - if (identity.isCollection(node)) - return node.deleteIn(rest); - else - throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); - } - /** - * Returns item at `key`, or `undefined` if not found. By default unwraps - * scalar values from their surrounding node; to disable set `keepScalar` to - * `true` (collections are always returned intact). - */ - getIn(path, keepScalar) { - const [key, ...rest] = path; - const node = this.get(key, true); - if (rest.length === 0) - return !keepScalar && identity.isScalar(node) ? node.value : node; - else - return identity.isCollection(node) ? node.getIn(rest, keepScalar) : undefined; - } - hasAllNullValues(allowScalar) { - return this.items.every(node => { - if (!identity.isPair(node)) - return false; - const n = node.value; - return (n == null || - (allowScalar && - identity.isScalar(n) && - n.value == null && - !n.commentBefore && - !n.comment && - !n.tag)); - }); - } - /** - * Checks if the collection includes a value with the key `key`. - */ - hasIn(path) { - const [key, ...rest] = path; - if (rest.length === 0) - return this.has(key); - const node = this.get(key, true); - return identity.isCollection(node) ? node.hasIn(rest) : false; - } - /** - * Sets a value in this collection. For `!!set`, `value` needs to be a - * boolean to add/remove the item from the set. - */ - setIn(path, value) { - const [key, ...rest] = path; - if (rest.length === 0) { - this.set(key, value); + ); + response.body = { stream }; + fetchParams.controller.on("terminated", onAborted); + fetchParams.controller.resume = async () => { + while (true) { + let bytes; + let isFailure; + try { + const { done, value } = await fetchParams.controller.next(); + if (isAborted(fetchParams)) { + break; + } + bytes = done ? void 0 : value; + } catch (err) { + if (fetchParams.controller.ended && !timingInfo.encodedBodySize) { + bytes = void 0; + } else { + bytes = err; + isFailure = true; + } + } + if (bytes === void 0) { + readableStreamClose(fetchParams.controller.controller); + finalizeResponse(fetchParams, response); + return; + } + timingInfo.decodedBodySize += bytes?.byteLength ?? 0; + if (isFailure) { + fetchParams.controller.terminate(bytes); + return; + } + fetchParams.controller.controller.enqueue(new Uint8Array(bytes)); + if (isErrored(stream)) { + fetchParams.controller.terminate(); + return; + } + if (!fetchParams.controller.controller.desiredSize) { + return; + } } - else { - const node = this.get(key, true); - if (identity.isCollection(node)) - node.setIn(rest, value); - else if (node === undefined && this.schema) - this.set(key, collectionFromPath(this.schema, rest, value)); - else - throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`); + }; + function onAborted(reason) { + if (isAborted(fetchParams)) { + response.aborted = true; + if (isReadable(stream)) { + fetchParams.controller.controller.error( + fetchParams.controller.serializedAbortReason + ); + } + } else { + if (isReadable(stream)) { + fetchParams.controller.controller.error(new TypeError("terminated", { + cause: isErrorLike(reason) ? reason : void 0 + })); + } } + fetchParams.controller.connection.destroy(); + } + return response; + async function dispatch({ body }) { + const url = requestCurrentURL(request); + const agent = fetchParams.controller.dispatcher; + return new Promise((resolve, reject) => agent.dispatch( + { + path: url.pathname + url.search, + origin: url.origin, + method: request.method, + body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body, + headers: request.headersList.entries, + maxRedirections: 0, + upgrade: request.mode === "websocket" ? "websocket" : void 0 + }, + { + body: null, + abort: null, + onConnect(abort) { + const { connection } = fetchParams.controller; + if (connection.destroyed) { + abort(new DOMException2("The operation was aborted.", "AbortError")); + } else { + fetchParams.controller.on("terminated", abort); + this.abort = connection.abort = abort; + } + }, + onHeaders(status, headersList, resume, statusText) { + if (status < 200) { + return; + } + let codings = []; + let location = ""; + const headers = new Headers2(); + if (Array.isArray(headersList)) { + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } else { + const keys = Object.keys(headersList); + for (const key of keys) { + const val = headersList[key]; + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()).reverse(); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } + this.body = new Readable({ read: resume }); + const decoders = []; + const willFollow = request.redirect === "follow" && location && redirectStatusSet.has(status); + if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) { + for (const coding of codings) { + if (coding === "x-gzip" || coding === "gzip") { + decoders.push(zlib.createGunzip({ + // 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. + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + } else if (coding === "deflate") { + decoders.push(zlib.createInflate()); + } else if (coding === "br") { + decoders.push(zlib.createBrotliDecompress()); + } else { + decoders.length = 0; + break; + } + } + } + resolve({ + status, + statusText, + headersList: headers[kHeadersList], + body: decoders.length ? pipeline(this.body, ...decoders, () => { + }) : this.body.on("error", () => { + }) + }); + return true; + }, + onData(chunk) { + if (fetchParams.controller.dump) { + return; + } + const bytes = chunk; + timingInfo.encodedBodySize += bytes.byteLength; + return this.body.push(bytes); + }, + onComplete() { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + fetchParams.controller.ended = true; + this.body.push(null); + }, + onError(error2) { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + this.body?.destroy(error2); + fetchParams.controller.terminate(error2); + reject(error2); + }, + onUpgrade(status, headersList, socket) { + if (status !== 101) { + return; + } + const headers = new Headers2(); + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + headers[kHeadersList].append(key, val); + } + resolve({ + status, + statusText: STATUS_CODES[status], + headersList: headers[kHeadersList], + socket + }); + return true; + } + } + )); + } } -} - -exports.Collection = Collection; -exports.collectionFromPath = collectionFromPath; -exports.isEmptyPath = isEmptyPath; - - -/***/ }), - -/***/ 6673: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - + module2.exports = { + fetch: fetch2, + Fetch, + fetching, + finalizeAndReportTiming + }; + } +}); -var applyReviver = __nccwpck_require__(3661); -var identity = __nccwpck_require__(1127); -var toJS = __nccwpck_require__(4043); +// node_modules/undici/lib/fileapi/symbols.js +var require_symbols3 = __commonJS({ + "node_modules/undici/lib/fileapi/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kState: Symbol("FileReader state"), + kResult: Symbol("FileReader result"), + kError: Symbol("FileReader error"), + kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"), + kEvents: Symbol("FileReader events"), + kAborted: Symbol("FileReader aborted") + }; + } +}); -class NodeBase { - constructor(type) { - Object.defineProperty(this, identity.NODE_TYPE, { value: type }); - } - /** Create a copy of this node. */ - clone() { - const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this)); - if (this.range) - copy.range = this.range.slice(); - return copy; - } - /** A plain JavaScript representation of this node. */ - toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) { - if (!identity.isDocument(doc)) - throw new TypeError('A document argument is required'); - const ctx = { - anchors: new Map(), - doc, - keep: true, - mapAsMap: mapAsMap === true, - mapKeyWarned: false, - maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100 +// node_modules/undici/lib/fileapi/progressevent.js +var require_progressevent = __commonJS({ + "node_modules/undici/lib/fileapi/progressevent.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var kState = Symbol("ProgressEvent state"); + var ProgressEvent = class _ProgressEvent extends Event { + constructor(type, eventInitDict = {}) { + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {}); + super(type, eventInitDict); + this[kState] = { + lengthComputable: eventInitDict.lengthComputable, + loaded: eventInitDict.loaded, + total: eventInitDict.total }; - const res = toJS.toJS(this, '', ctx); - if (typeof onAnchor === 'function') - for (const { count, res } of ctx.anchors.values()) - onAnchor(res, count); - return typeof reviver === 'function' - ? applyReviver.applyReviver(reviver, { '': res }, '', res) - : res; - } -} - -exports.NodeBase = NodeBase; - - -/***/ }), - -/***/ 7165: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var createNode = __nccwpck_require__(2404); -var stringifyPair = __nccwpck_require__(9748); -var addPairToJSMap = __nccwpck_require__(7104); -var identity = __nccwpck_require__(1127); - -function createPair(key, value, ctx) { - const k = createNode.createNode(key, undefined, ctx); - const v = createNode.createNode(value, undefined, ctx); - return new Pair(k, v); -} -class Pair { - constructor(key, value = null) { - Object.defineProperty(this, identity.NODE_TYPE, { value: identity.PAIR }); - this.key = key; - this.value = value; - } - clone(schema) { - let { key, value } = this; - if (identity.isNode(key)) - key = key.clone(schema); - if (identity.isNode(value)) - value = value.clone(schema); - return new Pair(key, value); - } - toJSON(_, ctx) { - const pair = ctx?.mapAsMap ? new Map() : {}; - return addPairToJSMap.addPairToJSMap(ctx, pair, this); - } - toString(ctx, onComment, onChompKeep) { - return ctx?.doc - ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep) - : JSON.stringify(this); - } -} - -exports.Pair = Pair; -exports.createPair = createPair; - - -/***/ }), - -/***/ 3301: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Node = __nccwpck_require__(6673); -var toJS = __nccwpck_require__(4043); + } + get lengthComputable() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].lengthComputable; + } + get loaded() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].loaded; + } + get total() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].total; + } + }; + webidl.converters.ProgressEventInit = webidl.dictionaryConverter([ + { + key: "lengthComputable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "loaded", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "total", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]); + module2.exports = { + ProgressEvent + }; + } +}); -const isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object'); -class Scalar extends Node.NodeBase { - constructor(value) { - super(identity.SCALAR); - this.value = value; - } - toJSON(arg, ctx) { - return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx); - } - toString() { - return String(this.value); +// node_modules/undici/lib/fileapi/encoding.js +var require_encoding = __commonJS({ + "node_modules/undici/lib/fileapi/encoding.js"(exports2, module2) { + "use strict"; + function getEncoding(label) { + if (!label) { + return "failure"; + } + switch (label.trim().toLowerCase()) { + case "unicode-1-1-utf-8": + case "unicode11utf8": + case "unicode20utf8": + case "utf-8": + case "utf8": + case "x-unicode20utf8": + return "UTF-8"; + case "866": + case "cp866": + case "csibm866": + case "ibm866": + return "IBM866"; + case "csisolatin2": + case "iso-8859-2": + case "iso-ir-101": + case "iso8859-2": + case "iso88592": + case "iso_8859-2": + case "iso_8859-2:1987": + case "l2": + case "latin2": + return "ISO-8859-2"; + case "csisolatin3": + case "iso-8859-3": + case "iso-ir-109": + case "iso8859-3": + case "iso88593": + case "iso_8859-3": + case "iso_8859-3:1988": + case "l3": + case "latin3": + return "ISO-8859-3"; + case "csisolatin4": + case "iso-8859-4": + case "iso-ir-110": + case "iso8859-4": + case "iso88594": + case "iso_8859-4": + case "iso_8859-4:1988": + case "l4": + case "latin4": + return "ISO-8859-4"; + case "csisolatincyrillic": + case "cyrillic": + case "iso-8859-5": + case "iso-ir-144": + case "iso8859-5": + case "iso88595": + case "iso_8859-5": + case "iso_8859-5:1988": + return "ISO-8859-5"; + case "arabic": + case "asmo-708": + case "csiso88596e": + case "csiso88596i": + case "csisolatinarabic": + case "ecma-114": + case "iso-8859-6": + case "iso-8859-6-e": + case "iso-8859-6-i": + case "iso-ir-127": + case "iso8859-6": + case "iso88596": + case "iso_8859-6": + case "iso_8859-6:1987": + return "ISO-8859-6"; + case "csisolatingreek": + case "ecma-118": + case "elot_928": + case "greek": + case "greek8": + case "iso-8859-7": + case "iso-ir-126": + case "iso8859-7": + case "iso88597": + case "iso_8859-7": + case "iso_8859-7:1987": + case "sun_eu_greek": + return "ISO-8859-7"; + case "csiso88598e": + case "csisolatinhebrew": + case "hebrew": + case "iso-8859-8": + case "iso-8859-8-e": + case "iso-ir-138": + case "iso8859-8": + case "iso88598": + case "iso_8859-8": + case "iso_8859-8:1988": + case "visual": + return "ISO-8859-8"; + case "csiso88598i": + case "iso-8859-8-i": + case "logical": + return "ISO-8859-8-I"; + case "csisolatin6": + case "iso-8859-10": + case "iso-ir-157": + case "iso8859-10": + case "iso885910": + case "l6": + case "latin6": + return "ISO-8859-10"; + case "iso-8859-13": + case "iso8859-13": + case "iso885913": + return "ISO-8859-13"; + case "iso-8859-14": + case "iso8859-14": + case "iso885914": + return "ISO-8859-14"; + case "csisolatin9": + case "iso-8859-15": + case "iso8859-15": + case "iso885915": + case "iso_8859-15": + case "l9": + return "ISO-8859-15"; + case "iso-8859-16": + return "ISO-8859-16"; + case "cskoi8r": + case "koi": + case "koi8": + case "koi8-r": + case "koi8_r": + return "KOI8-R"; + case "koi8-ru": + case "koi8-u": + return "KOI8-U"; + case "csmacintosh": + case "mac": + case "macintosh": + case "x-mac-roman": + return "macintosh"; + case "iso-8859-11": + case "iso8859-11": + case "iso885911": + case "tis-620": + case "windows-874": + return "windows-874"; + case "cp1250": + case "windows-1250": + case "x-cp1250": + return "windows-1250"; + case "cp1251": + case "windows-1251": + case "x-cp1251": + return "windows-1251"; + case "ansi_x3.4-1968": + case "ascii": + case "cp1252": + case "cp819": + case "csisolatin1": + case "ibm819": + case "iso-8859-1": + case "iso-ir-100": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "iso_8859-1:1987": + case "l1": + case "latin1": + case "us-ascii": + case "windows-1252": + case "x-cp1252": + return "windows-1252"; + case "cp1253": + case "windows-1253": + case "x-cp1253": + return "windows-1253"; + case "cp1254": + case "csisolatin5": + case "iso-8859-9": + case "iso-ir-148": + case "iso8859-9": + case "iso88599": + case "iso_8859-9": + case "iso_8859-9:1989": + case "l5": + case "latin5": + case "windows-1254": + case "x-cp1254": + return "windows-1254"; + case "cp1255": + case "windows-1255": + case "x-cp1255": + return "windows-1255"; + case "cp1256": + case "windows-1256": + case "x-cp1256": + return "windows-1256"; + case "cp1257": + case "windows-1257": + case "x-cp1257": + return "windows-1257"; + case "cp1258": + case "windows-1258": + case "x-cp1258": + return "windows-1258"; + case "x-mac-cyrillic": + case "x-mac-ukrainian": + return "x-mac-cyrillic"; + case "chinese": + case "csgb2312": + case "csiso58gb231280": + case "gb2312": + case "gb_2312": + case "gb_2312-80": + case "gbk": + case "iso-ir-58": + case "x-gbk": + return "GBK"; + case "gb18030": + return "gb18030"; + case "big5": + case "big5-hkscs": + case "cn-big5": + case "csbig5": + case "x-x-big5": + return "Big5"; + case "cseucpkdfmtjapanese": + case "euc-jp": + case "x-euc-jp": + return "EUC-JP"; + case "csiso2022jp": + case "iso-2022-jp": + return "ISO-2022-JP"; + case "csshiftjis": + case "ms932": + case "ms_kanji": + case "shift-jis": + case "shift_jis": + case "sjis": + case "windows-31j": + case "x-sjis": + return "Shift_JIS"; + case "cseuckr": + case "csksc56011987": + case "euc-kr": + case "iso-ir-149": + case "korean": + case "ks_c_5601-1987": + case "ks_c_5601-1989": + case "ksc5601": + case "ksc_5601": + case "windows-949": + return "EUC-KR"; + case "csiso2022kr": + case "hz-gb-2312": + case "iso-2022-cn": + case "iso-2022-cn-ext": + case "iso-2022-kr": + case "replacement": + return "replacement"; + case "unicodefffe": + case "utf-16be": + return "UTF-16BE"; + case "csunicode": + case "iso-10646-ucs-2": + case "ucs-2": + case "unicode": + case "unicodefeff": + case "utf-16": + case "utf-16le": + return "UTF-16LE"; + case "x-user-defined": + return "x-user-defined"; + default: + return "failure"; + } } -} -Scalar.BLOCK_FOLDED = 'BLOCK_FOLDED'; -Scalar.BLOCK_LITERAL = 'BLOCK_LITERAL'; -Scalar.PLAIN = 'PLAIN'; -Scalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE'; -Scalar.QUOTE_SINGLE = 'QUOTE_SINGLE'; - -exports.Scalar = Scalar; -exports.isScalarValue = isScalarValue; - - -/***/ }), - -/***/ 4454: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var stringifyCollection = __nccwpck_require__(1212); -var addPairToJSMap = __nccwpck_require__(7104); -var Collection = __nccwpck_require__(101); -var identity = __nccwpck_require__(1127); -var Pair = __nccwpck_require__(7165); -var Scalar = __nccwpck_require__(3301); + module2.exports = { + getEncoding + }; + } +}); -function findPair(items, key) { - const k = identity.isScalar(key) ? key.value : key; - for (const it of items) { - if (identity.isPair(it)) { - if (it.key === key || it.key === k) - return it; - if (identity.isScalar(it.key) && it.key.value === k) - return it; +// node_modules/undici/lib/fileapi/util.js +var require_util4 = __commonJS({ + "node_modules/undici/lib/fileapi/util.js"(exports2, module2) { + "use strict"; + var { + kState, + kError, + kResult, + kAborted, + kLastProgressEventFired + } = require_symbols3(); + var { ProgressEvent } = require_progressevent(); + var { getEncoding } = require_encoding(); + var { DOMException: DOMException2 } = require_constants2(); + var { serializeAMimeType, parseMIMEType } = require_dataURL(); + var { types } = require("util"); + var { StringDecoder } = require("string_decoder"); + var { btoa: btoa2 } = require("buffer"); + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + function readOperation(fr, blob, type, encodingName) { + if (fr[kState] === "loading") { + throw new DOMException2("Invalid state", "InvalidStateError"); + } + fr[kState] = "loading"; + fr[kResult] = null; + fr[kError] = null; + const stream = blob.stream(); + const reader = stream.getReader(); + const bytes = []; + let chunkPromise = reader.read(); + let isFirstChunk = true; + (async () => { + while (!fr[kAborted]) { + try { + const { done, value } = await chunkPromise; + if (isFirstChunk && !fr[kAborted]) { + queueMicrotask(() => { + fireAProgressEvent("loadstart", fr); + }); + } + isFirstChunk = false; + if (!done && types.isUint8Array(value)) { + bytes.push(value); + if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) { + fr[kLastProgressEventFired] = Date.now(); + queueMicrotask(() => { + fireAProgressEvent("progress", fr); + }); + } + chunkPromise = reader.read(); + } else if (done) { + queueMicrotask(() => { + fr[kState] = "done"; + try { + const result = packageData(bytes, type, blob.type, encodingName); + if (fr[kAborted]) { + return; + } + fr[kResult] = result; + fireAProgressEvent("load", fr); + } catch (error2) { + fr[kError] = error2; + fireAProgressEvent("error", fr); + } + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } catch (error2) { + if (fr[kAborted]) { + return; + } + queueMicrotask(() => { + fr[kState] = "done"; + fr[kError] = error2; + fireAProgressEvent("error", fr); + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } + })(); + } + function fireAProgressEvent(e, reader) { + const event = new ProgressEvent(e, { + bubbles: false, + cancelable: false + }); + reader.dispatchEvent(event); + } + function packageData(bytes, type, mimeType, encodingName) { + switch (type) { + case "DataURL": { + let dataURL = "data:"; + const parsed = parseMIMEType(mimeType || "application/octet-stream"); + if (parsed !== "failure") { + dataURL += serializeAMimeType(parsed); + } + dataURL += ";base64,"; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + dataURL += btoa2(decoder.write(chunk)); + } + dataURL += btoa2(decoder.end()); + return dataURL; + } + case "Text": { + let encoding = "failure"; + if (encodingName) { + encoding = getEncoding(encodingName); + } + if (encoding === "failure" && mimeType) { + const type2 = parseMIMEType(mimeType); + if (type2 !== "failure") { + encoding = getEncoding(type2.parameters.get("charset")); + } + } + if (encoding === "failure") { + encoding = "UTF-8"; + } + return decode(bytes, encoding); + } + case "ArrayBuffer": { + const sequence = combineByteSequences(bytes); + return sequence.buffer; + } + case "BinaryString": { + let binaryString = ""; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + binaryString += decoder.write(chunk); + } + binaryString += decoder.end(); + return binaryString; } + } } - return undefined; -} -class YAMLMap extends Collection.Collection { - static get tagName() { - return 'tag:yaml.org,2002:map'; + function decode(ioQueue, encoding) { + const bytes = combineByteSequences(ioQueue); + const BOMEncoding = BOMSniffing(bytes); + let slice = 0; + if (BOMEncoding !== null) { + encoding = BOMEncoding; + slice = BOMEncoding === "UTF-8" ? 3 : 2; + } + const sliced = bytes.slice(slice); + return new TextDecoder(encoding).decode(sliced); } - constructor(schema) { - super(identity.MAP, schema); - this.items = []; + function BOMSniffing(ioQueue) { + const [a, b, c] = ioQueue; + if (a === 239 && b === 187 && c === 191) { + return "UTF-8"; + } else if (a === 254 && b === 255) { + return "UTF-16BE"; + } else if (a === 255 && b === 254) { + return "UTF-16LE"; + } + return null; } - /** - * A generic collection parsing method that can be extended - * to other node classes that inherit from YAMLMap - */ - static from(schema, obj, ctx) { - const { keepUndefined, replacer } = ctx; - const map = new this(schema); - const add = (key, value) => { - if (typeof replacer === 'function') - value = replacer.call(obj, key, value); - else if (Array.isArray(replacer) && !replacer.includes(key)) - return; - if (value !== undefined || keepUndefined) - map.items.push(Pair.createPair(key, value, ctx)); + function combineByteSequences(sequences) { + const size = sequences.reduce((a, b) => { + return a + b.byteLength; + }, 0); + let offset = 0; + return sequences.reduce((a, b) => { + a.set(b, offset); + offset += b.byteLength; + return a; + }, new Uint8Array(size)); + } + module2.exports = { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + }; + } +}); + +// node_modules/undici/lib/fileapi/filereader.js +var require_filereader = __commonJS({ + "node_modules/undici/lib/fileapi/filereader.js"(exports2, module2) { + "use strict"; + var { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + } = require_util4(); + var { + kState, + kError, + kResult, + kEvents, + kAborted + } = require_symbols3(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var FileReader = class _FileReader extends EventTarget { + constructor() { + super(); + this[kState] = "empty"; + this[kResult] = null; + this[kError] = null; + this[kEvents] = { + loadend: null, + error: null, + abort: null, + load: null, + progress: null, + loadstart: null }; - if (obj instanceof Map) { - for (const [key, value] of obj) - add(key, value); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer + * @param {import('buffer').Blob} blob + */ + readAsArrayBuffer(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "ArrayBuffer"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsBinaryString + * @param {import('buffer').Blob} blob + */ + readAsBinaryString(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "BinaryString"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsDataText + * @param {import('buffer').Blob} blob + * @param {string?} encoding + */ + readAsText(blob, encoding = void 0) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" }); + blob = webidl.converters.Blob(blob, { strict: false }); + if (encoding !== void 0) { + encoding = webidl.converters.DOMString(encoding); + } + readOperation(this, blob, "Text", encoding); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL + * @param {import('buffer').Blob} blob + */ + readAsDataURL(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "DataURL"); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-abort + */ + abort() { + if (this[kState] === "empty" || this[kState] === "done") { + this[kResult] = null; + return; } - else if (obj && typeof obj === 'object') { - for (const key of Object.keys(obj)) - add(key, obj[key]); + if (this[kState] === "loading") { + this[kState] = "done"; + this[kResult] = null; } - if (typeof schema.sortMapEntries === 'function') { - map.items.sort(schema.sortMapEntries); + this[kAborted] = true; + fireAProgressEvent("abort", this); + if (this[kState] !== "loading") { + fireAProgressEvent("loadend", this); } - return map; - } - /** - * Adds a value to the collection. - * - * @param overwrite - If not set `true`, using a key that is already in the - * collection will throw. Otherwise, overwrites the previous value. - */ - add(pair, overwrite) { - let _pair; - if (identity.isPair(pair)) - _pair = pair; - else if (!pair || typeof pair !== 'object' || !('key' in pair)) { - // In TypeScript, this never happens. - _pair = new Pair.Pair(pair, pair?.value); + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate + */ + get readyState() { + webidl.brandCheck(this, _FileReader); + switch (this[kState]) { + case "empty": + return this.EMPTY; + case "loading": + return this.LOADING; + case "done": + return this.DONE; } - else - _pair = new Pair.Pair(pair.key, pair.value); - const prev = findPair(this.items, _pair.key); - const sortEntries = this.schema?.sortMapEntries; - if (prev) { - if (!overwrite) - throw new Error(`Key ${_pair.key} already set`); - // For scalars, keep the old node & its comments and anchors - if (identity.isScalar(prev.value) && Scalar.isScalarValue(_pair.value)) - prev.value.value = _pair.value; - else - prev.value = _pair.value; + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-result + */ + get result() { + webidl.brandCheck(this, _FileReader); + return this[kResult]; + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-error + */ + get error() { + webidl.brandCheck(this, _FileReader); + return this[kError]; + } + get onloadend() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadend; + } + set onloadend(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadend) { + this.removeEventListener("loadend", this[kEvents].loadend); + } + if (typeof fn === "function") { + this[kEvents].loadend = fn; + this.addEventListener("loadend", fn); + } else { + this[kEvents].loadend = null; } - else if (sortEntries) { - const i = this.items.findIndex(item => sortEntries(_pair, item) < 0); - if (i === -1) - this.items.push(_pair); - else - this.items.splice(i, 0, _pair); + } + get onerror() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].error; + } + set onerror(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].error) { + this.removeEventListener("error", this[kEvents].error); } - else { - this.items.push(_pair); + if (typeof fn === "function") { + this[kEvents].error = fn; + this.addEventListener("error", fn); + } else { + this[kEvents].error = null; } - } - delete(key) { - const it = findPair(this.items, key); - if (!it) - return false; - const del = this.items.splice(this.items.indexOf(it), 1); - return del.length > 0; - } - get(key, keepScalar) { - const it = findPair(this.items, key); - const node = it?.value; - return (!keepScalar && identity.isScalar(node) ? node.value : node) ?? undefined; - } - has(key) { - return !!findPair(this.items, key); - } - set(key, value) { - this.add(new Pair.Pair(key, value), true); - } - /** - * @param ctx - Conversion context, originally set in Document#toJS() - * @param {Class} Type - If set, forces the returned collection type - * @returns Instance of Type, Map, or Object - */ - toJSON(_, ctx, Type) { - const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {}; - if (ctx?.onCreate) - ctx.onCreate(map); - for (const item of this.items) - addPairToJSMap.addPairToJSMap(ctx, map, item); - return map; - } - toString(ctx, onComment, onChompKeep) { - if (!ctx) - return JSON.stringify(this); - for (const item of this.items) { - if (!identity.isPair(item)) - throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`); + } + get onloadstart() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadstart; + } + set onloadstart(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadstart) { + this.removeEventListener("loadstart", this[kEvents].loadstart); } - if (!ctx.allNullValues && this.hasAllNullValues(false)) - ctx = Object.assign({}, ctx, { allNullValues: true }); - return stringifyCollection.stringifyCollection(this, ctx, { - blockItemPrefix: '', - flowChars: { start: '{', end: '}' }, - itemIndent: ctx.indent || '', - onChompKeep, - onComment - }); - } -} - -exports.YAMLMap = YAMLMap; -exports.findPair = findPair; - - -/***/ }), - -/***/ 2223: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var createNode = __nccwpck_require__(2404); -var stringifyCollection = __nccwpck_require__(1212); -var Collection = __nccwpck_require__(101); -var identity = __nccwpck_require__(1127); -var Scalar = __nccwpck_require__(3301); -var toJS = __nccwpck_require__(4043); - -class YAMLSeq extends Collection.Collection { - static get tagName() { - return 'tag:yaml.org,2002:seq'; - } - constructor(schema) { - super(identity.SEQ, schema); - this.items = []; - } - add(value) { - this.items.push(value); - } - /** - * Removes a value from the collection. - * - * `key` must contain a representation of an integer for this to succeed. - * It may be wrapped in a `Scalar`. - * - * @returns `true` if the item was found and removed. - */ - delete(key) { - const idx = asItemIndex(key); - if (typeof idx !== 'number') - return false; - const del = this.items.splice(idx, 1); - return del.length > 0; - } - get(key, keepScalar) { - const idx = asItemIndex(key); - if (typeof idx !== 'number') - return undefined; - const it = this.items[idx]; - return !keepScalar && identity.isScalar(it) ? it.value : it; - } - /** - * Checks if the collection includes a value with the key `key`. - * - * `key` must contain a representation of an integer for this to succeed. - * It may be wrapped in a `Scalar`. - */ - has(key) { - const idx = asItemIndex(key); - return typeof idx === 'number' && idx < this.items.length; - } - /** - * Sets a value in this collection. For `!!set`, `value` needs to be a - * boolean to add/remove the item from the set. - * - * If `key` does not contain a representation of an integer, this will throw. - * It may be wrapped in a `Scalar`. - */ - set(key, value) { - const idx = asItemIndex(key); - if (typeof idx !== 'number') - throw new Error(`Expected a valid index, not ${key}.`); - const prev = this.items[idx]; - if (identity.isScalar(prev) && Scalar.isScalarValue(value)) - prev.value = value; - else - this.items[idx] = value; - } - toJSON(_, ctx) { - const seq = []; - if (ctx?.onCreate) - ctx.onCreate(seq); - let i = 0; - for (const item of this.items) - seq.push(toJS.toJS(item, String(i++), ctx)); - return seq; - } - toString(ctx, onComment, onChompKeep) { - if (!ctx) - return JSON.stringify(this); - return stringifyCollection.stringifyCollection(this, ctx, { - blockItemPrefix: '- ', - flowChars: { start: '[', end: ']' }, - itemIndent: (ctx.indent || '') + ' ', - onChompKeep, - onComment - }); - } - static from(schema, obj, ctx) { - const { replacer } = ctx; - const seq = new this(schema); - if (obj && Symbol.iterator in Object(obj)) { - let i = 0; - for (let it of obj) { - if (typeof replacer === 'function') { - const key = obj instanceof Set ? it : String(i++); - it = replacer.call(obj, key, it); - } - seq.items.push(createNode.createNode(it, undefined, ctx)); - } + if (typeof fn === "function") { + this[kEvents].loadstart = fn; + this.addEventListener("loadstart", fn); + } else { + this[kEvents].loadstart = null; + } + } + get onprogress() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].progress; + } + set onprogress(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].progress) { + this.removeEventListener("progress", this[kEvents].progress); + } + if (typeof fn === "function") { + this[kEvents].progress = fn; + this.addEventListener("progress", fn); + } else { + this[kEvents].progress = null; + } + } + get onload() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].load; + } + set onload(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].load) { + this.removeEventListener("load", this[kEvents].load); + } + if (typeof fn === "function") { + this[kEvents].load = fn; + this.addEventListener("load", fn); + } else { + this[kEvents].load = null; } - return seq; - } -} -function asItemIndex(key) { - let idx = identity.isScalar(key) ? key.value : key; - if (idx && typeof idx === 'string') - idx = Number(idx); - return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0 - ? idx - : null; -} - -exports.YAMLSeq = YAMLSeq; - - -/***/ }), - -/***/ 7104: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; + } + get onabort() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].abort; + } + set onabort(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].abort) { + this.removeEventListener("abort", this[kEvents].abort); + } + if (typeof fn === "function") { + this[kEvents].abort = fn; + this.addEventListener("abort", fn); + } else { + this[kEvents].abort = null; + } + } + }; + FileReader.EMPTY = FileReader.prototype.EMPTY = 0; + FileReader.LOADING = FileReader.prototype.LOADING = 1; + FileReader.DONE = FileReader.prototype.DONE = 2; + Object.defineProperties(FileReader.prototype, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors, + readAsArrayBuffer: kEnumerableProperty, + readAsBinaryString: kEnumerableProperty, + readAsText: kEnumerableProperty, + readAsDataURL: kEnumerableProperty, + abort: kEnumerableProperty, + readyState: kEnumerableProperty, + result: kEnumerableProperty, + error: kEnumerableProperty, + onloadstart: kEnumerableProperty, + onprogress: kEnumerableProperty, + onload: kEnumerableProperty, + onabort: kEnumerableProperty, + onerror: kEnumerableProperty, + onloadend: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FileReader", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(FileReader, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors + }); + module2.exports = { + FileReader + }; + } +}); +// node_modules/undici/lib/cache/symbols.js +var require_symbols4 = __commonJS({ + "node_modules/undici/lib/cache/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kConstruct: require_symbols().kConstruct + }; + } +}); -var log = __nccwpck_require__(7249); -var merge = __nccwpck_require__(452); -var stringify = __nccwpck_require__(2148); -var identity = __nccwpck_require__(1127); -var toJS = __nccwpck_require__(4043); +// node_modules/undici/lib/cache/util.js +var require_util5 = __commonJS({ + "node_modules/undici/lib/cache/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { URLSerializer } = require_dataURL(); + var { isValidHeaderName } = require_util2(); + function urlEquals(A, B, excludeFragment = false) { + const serializedA = URLSerializer(A, excludeFragment); + const serializedB = URLSerializer(B, excludeFragment); + return serializedA === serializedB; + } + function fieldValues(header) { + assert(header !== null); + const values = []; + for (let value of header.split(",")) { + value = value.trim(); + if (!value.length) { + continue; + } else if (!isValidHeaderName(value)) { + continue; + } + values.push(value); + } + return values; + } + module2.exports = { + urlEquals, + fieldValues + }; + } +}); -function addPairToJSMap(ctx, map, { key, value }) { - if (identity.isNode(key) && key.addToJSMap) - key.addToJSMap(ctx, map, value); - // TODO: Should drop this special case for bare << handling - else if (merge.isMergeKey(ctx, key)) - merge.addMergeToJSMap(ctx, map, value); - else { - const jsKey = toJS.toJS(key, '', ctx); - if (map instanceof Map) { - map.set(jsKey, toJS.toJS(value, jsKey, ctx)); +// node_modules/undici/lib/cache/cache.js +var require_cache = __commonJS({ + "node_modules/undici/lib/cache/cache.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { urlEquals, fieldValues: getFieldValues } = require_util5(); + var { kEnumerableProperty, isDisturbed } = require_util(); + var { kHeadersList } = require_symbols(); + var { webidl } = require_webidl(); + var { Response: Response2, cloneResponse } = require_response(); + var { Request } = require_request2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { fetching } = require_fetch(); + var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util2(); + var assert = require("assert"); + var { getGlobalDispatcher } = require_global2(); + var Cache = class _Cache { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list + * @type {requestResponseList} + */ + #relevantRequestResponseList; + constructor() { + if (arguments[0] !== kConstruct) { + webidl.illegalConstructor(); + } + this.#relevantRequestResponseList = arguments[1]; + } + async match(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.match" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + const p = await this.matchAll(request, options); + if (p.length === 0) { + return; + } + return p[0]; + } + async matchAll(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } } - else if (map instanceof Set) { - map.add(jsKey); + const responses = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + responses.push(requestResponse[1]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + responses.push(requestResponse[1]); + } } - else { - const stringKey = stringifyKey(key, jsKey, ctx); - const jsValue = toJS.toJS(value, stringKey, ctx); - if (stringKey in map) - Object.defineProperty(map, stringKey, { - value: jsValue, - writable: true, - enumerable: true, - configurable: true - }); - else - map[stringKey] = jsValue; + const responseList = []; + for (const response of responses) { + const responseObject = new Response2(response.body?.source ?? null); + const body = responseObject[kState].body; + responseObject[kState] = response; + responseObject[kState].body = body; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseList.push(responseObject); + } + return Object.freeze(responseList); + } + async add(request) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.add" }); + request = webidl.converters.RequestInfo(request); + const requests = [request]; + const responseArrayPromise = this.addAll(requests); + return await responseArrayPromise; + } + async addAll(requests) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.addAll" }); + requests = webidl.converters["sequence"](requests); + const responsePromises = []; + const requestList = []; + for (const request of requests) { + if (typeof request === "string") { + continue; + } + const r = request[kState]; + if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme when method is not GET." + }); + } } - } - return map; -} -function stringifyKey(key, jsKey, ctx) { - if (jsKey === null) - return ''; - // eslint-disable-next-line @typescript-eslint/no-base-to-string - if (typeof jsKey !== 'object') - return String(jsKey); - if (identity.isNode(key) && ctx?.doc) { - const strCtx = stringify.createStringifyContext(ctx.doc, {}); - strCtx.anchors = new Set(); - for (const node of ctx.anchors.keys()) - strCtx.anchors.add(node.anchor); - strCtx.inFlow = true; - strCtx.inStringifyKey = true; - const strKey = key.toString(strCtx); - if (!ctx.mapKeyWarned) { - let jsonStr = JSON.stringify(strKey); - if (jsonStr.length > 40) - jsonStr = jsonStr.substring(0, 36) + '..."'; - log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`); - ctx.mapKeyWarned = true; + const fetchControllers = []; + for (const request of requests) { + const r = new Request(request)[kState]; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme." + }); + } + r.initiator = "fetch"; + r.destination = "subresource"; + requestList.push(r); + const responsePromise = createDeferredPromise(); + fetchControllers.push(fetching({ + request: r, + dispatcher: getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "Received an invalid status code or the request failed." + })); + } else if (response.headersList.contains("vary")) { + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "invalid vary field value" + })); + for (const controller of fetchControllers) { + controller.abort(); + } + return; + } + } + } + }, + processResponseEndOfBody(response) { + if (response.aborted) { + responsePromise.reject(new DOMException("aborted", "AbortError")); + return; + } + responsePromise.resolve(response); + } + })); + responsePromises.push(responsePromise.promise); + } + const p = Promise.all(responsePromises); + const responses = await p; + const operations = []; + let index = 0; + for (const response of responses) { + const operation = { + type: "put", + // 7.3.2 + request: requestList[index], + // 7.3.3 + response + // 7.3.4 + }; + operations.push(operation); + index++; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; } - return strKey; - } - return JSON.stringify(jsKey); -} - -exports.addPairToJSMap = addPairToJSMap; - - -/***/ }), - -/***/ 1127: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -const ALIAS = Symbol.for('yaml.alias'); -const DOC = Symbol.for('yaml.document'); -const MAP = Symbol.for('yaml.map'); -const PAIR = Symbol.for('yaml.pair'); -const SCALAR = Symbol.for('yaml.scalar'); -const SEQ = Symbol.for('yaml.seq'); -const NODE_TYPE = Symbol.for('yaml.node.type'); -const isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS; -const isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC; -const isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP; -const isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR; -const isScalar = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR; -const isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ; -function isCollection(node) { - if (node && typeof node === 'object') - switch (node[NODE_TYPE]) { - case MAP: - case SEQ: - return true; + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(void 0); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async put(request, response) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 2, { header: "Cache.put" }); + request = webidl.converters.RequestInfo(request); + response = webidl.converters.Response(response); + let innerRequest = null; + if (request instanceof Request) { + innerRequest = request[kState]; + } else { + innerRequest = new Request(request)[kState]; } - return false; -} -function isNode(node) { - if (node && typeof node === 'object') - switch (node[NODE_TYPE]) { - case ALIAS: - case MAP: - case SCALAR: - case SEQ: - return true; + if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Expected an http/s scheme when method is not GET" + }); } - return false; -} -const hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor; - -exports.ALIAS = ALIAS; -exports.DOC = DOC; -exports.MAP = MAP; -exports.NODE_TYPE = NODE_TYPE; -exports.PAIR = PAIR; -exports.SCALAR = SCALAR; -exports.SEQ = SEQ; -exports.hasAnchor = hasAnchor; -exports.isAlias = isAlias; -exports.isCollection = isCollection; -exports.isDocument = isDocument; -exports.isMap = isMap; -exports.isNode = isNode; -exports.isPair = isPair; -exports.isScalar = isScalar; -exports.isSeq = isSeq; - - -/***/ }), - -/***/ 4043: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); - -/** - * Recursively convert any node or its contents to native JavaScript - * - * @param value - The input value - * @param arg - If `value` defines a `toJSON()` method, use this - * as its first argument - * @param ctx - Conversion context, originally set in Document#toJS(). If - * `{ keep: true }` is not set, output should be suitable for JSON - * stringification. - */ -function toJS(value, arg, ctx) { - // eslint-disable-next-line @typescript-eslint/no-unsafe-return - if (Array.isArray(value)) - return value.map((v, i) => toJS(v, String(i), ctx)); - if (value && typeof value.toJSON === 'function') { - // eslint-disable-next-line @typescript-eslint/no-unsafe-call - if (!ctx || !identity.hasAnchor(value)) - return value.toJSON(arg, ctx); - const data = { aliasCount: 0, count: 1, res: undefined }; - ctx.anchors.set(value, data); - ctx.onCreate = res => { - data.res = res; - delete ctx.onCreate; - }; - const res = value.toJSON(arg, ctx); - if (ctx.onCreate) - ctx.onCreate(res); - return res; - } - if (typeof value === 'bigint' && !ctx?.keep) - return Number(value); - return value; -} - -exports.toJS = toJS; - - -/***/ }), - -/***/ 110: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var resolveBlockScalar = __nccwpck_require__(8913); -var resolveFlowScalar = __nccwpck_require__(6842); -var errors = __nccwpck_require__(1464); -var stringifyString = __nccwpck_require__(3069); - -function resolveAsScalar(token, strict = true, onError) { - if (token) { - const _onError = (pos, code, message) => { - const offset = typeof pos === 'number' ? pos : Array.isArray(pos) ? pos[0] : pos.offset; - if (onError) - onError(offset, code, message); - else - throw new errors.YAMLParseError([offset, offset + 1], code, message); + const innerResponse = response[kState]; + if (innerResponse.status === 206) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got 206 status" + }); + } + if (innerResponse.headersList.contains("vary")) { + const fieldValues = getFieldValues(innerResponse.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got * vary field value" + }); + } + } + } + if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Response body is locked or disturbed" + }); + } + const clonedResponse = cloneResponse(innerResponse); + const bodyReadPromise = createDeferredPromise(); + if (innerResponse.body != null) { + const stream = innerResponse.body.stream; + const reader = stream.getReader(); + readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject); + } else { + bodyReadPromise.resolve(void 0); + } + const operations = []; + const operation = { + type: "put", + // 14. + request: innerRequest, + // 15. + response: clonedResponse + // 16. }; - switch (token.type) { - case 'scalar': - case 'single-quoted-scalar': - case 'double-quoted-scalar': - return resolveFlowScalar.resolveFlowScalar(token, strict, _onError); - case 'block-scalar': - return resolveBlockScalar.resolveBlockScalar({ options: { strict } }, token, _onError); + operations.push(operation); + const bytes = await bodyReadPromise.promise; + if (clonedResponse.body != null) { + clonedResponse.body.source = bytes; } - } - return null; -} -/** - * Create a new scalar token with `value` - * - * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`, - * as this function does not support any schema operations and won't check for such conflicts. - * - * @param value The string representation of the value, which will have its content properly indented. - * @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added. - * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value. - * @param context.indent The indent level of the token. - * @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value. - * @param context.offset The offset position of the token. - * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`. - */ -function createScalarToken(value, context) { - const { implicitKey = false, indent, inFlow = false, offset = -1, type = 'PLAIN' } = context; - const source = stringifyString.stringifyString({ type, value }, { - implicitKey, - indent: indent > 0 ? ' '.repeat(indent) : '', - inFlow, - options: { blockQuote: true, lineWidth: -1 } - }); - const end = context.end ?? [ - { type: 'newline', offset: -1, indent, source: '\n' } - ]; - switch (source[0]) { - case '|': - case '>': { - const he = source.indexOf('\n'); - const head = source.substring(0, he); - const body = source.substring(he + 1) + '\n'; - const props = [ - { type: 'block-scalar-header', offset, indent, source: head } - ]; - if (!addEndtoBlockProps(props, end)) - props.push({ type: 'newline', offset: -1, indent, source: '\n' }); - return { type: 'block-scalar', offset, indent, props, source: body }; + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; } - case '"': - return { type: 'double-quoted-scalar', offset, indent, source, end }; - case "'": - return { type: 'single-quoted-scalar', offset, indent, source, end }; - default: - return { type: 'scalar', offset, indent, source, end }; - } -} -/** - * Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have. - * - * Best efforts are made to retain any comments previously associated with the `token`, - * though all contents within a collection's `items` will be overwritten. - * - * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`, - * as this function does not support any schema operations and won't check for such conflicts. - * - * @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key. - * @param value The string representation of the value, which will have its content properly indented. - * @param context.afterKey In most cases, values after a key should have an additional level of indentation. - * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value. - * @param context.inFlow Being within a flow collection may affect the resolved type of the token's value. - * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`. - */ -function setScalarValue(token, value, context = {}) { - let { afterKey = false, implicitKey = false, inFlow = false, type } = context; - let indent = 'indent' in token ? token.indent : null; - if (afterKey && typeof indent === 'number') - indent += 2; - if (!type) - switch (token.type) { - case 'single-quoted-scalar': - type = 'QUOTE_SINGLE'; - break; - case 'double-quoted-scalar': - type = 'QUOTE_DOUBLE'; - break; - case 'block-scalar': { - const header = token.props[0]; - if (header.type !== 'block-scalar-header') - throw new Error('Invalid block scalar header'); - type = header.source[0] === '>' ? 'BLOCK_FOLDED' : 'BLOCK_LITERAL'; - break; + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async delete(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.delete" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return false; + } + } else { + assert(typeof request === "string"); + r = new Request(request)[kState]; + } + const operations = []; + const operation = { + type: "delete", + request: r, + options + }; + operations.push(operation); + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + let requestResponses; + try { + requestResponses = this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(!!requestResponses?.length); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys + * @param {any} request + * @param {import('../../types/cache').CacheQueryOptions} options + * @returns {readonly Request[]} + */ + async keys(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; } - default: - type = 'PLAIN'; + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } } - const source = stringifyString.stringifyString({ type, value }, { - implicitKey: implicitKey || indent === null, - indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '', - inFlow, - options: { blockQuote: true, lineWidth: -1 } - }); - switch (source[0]) { - case '|': - case '>': - setBlockScalarValue(token, source); - break; - case '"': - setFlowScalarValue(token, source, 'double-quoted-scalar'); - break; - case "'": - setFlowScalarValue(token, source, 'single-quoted-scalar'); - break; - default: - setFlowScalarValue(token, source, 'scalar'); - } -} -function setBlockScalarValue(token, source) { - const he = source.indexOf('\n'); - const head = source.substring(0, he); - const body = source.substring(he + 1) + '\n'; - if (token.type === 'block-scalar') { - const header = token.props[0]; - if (header.type !== 'block-scalar-header') - throw new Error('Invalid block scalar header'); - header.source = head; - token.source = body; - } - else { - const { offset } = token; - const indent = 'indent' in token ? token.indent : -1; - const props = [ - { type: 'block-scalar-header', offset, indent, source: head } - ]; - if (!addEndtoBlockProps(props, 'end' in token ? token.end : undefined)) - props.push({ type: 'newline', offset: -1, indent, source: '\n' }); - for (const key of Object.keys(token)) - if (key !== 'type' && key !== 'offset') - delete token[key]; - Object.assign(token, { type: 'block-scalar', indent, props, source: body }); - } -} -/** @returns `true` if last token is a newline */ -function addEndtoBlockProps(props, end) { - if (end) - for (const st of end) - switch (st.type) { - case 'space': - case 'comment': - props.push(st); - break; - case 'newline': - props.push(st); - return true; + const promise = createDeferredPromise(); + const requests = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + requests.push(requestResponse[0]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + requests.push(requestResponse[0]); + } + } + queueMicrotask(() => { + const requestList = []; + for (const request2 of requests) { + const requestObject = new Request("https://a"); + requestObject[kState] = request2; + requestObject[kHeaders][kHeadersList] = request2.headersList; + requestObject[kHeaders][kGuard] = "immutable"; + requestObject[kRealm] = request2.client; + requestList.push(requestObject); + } + promise.resolve(Object.freeze(requestList)); + }); + return promise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm + * @param {CacheBatchOperation[]} operations + * @returns {requestResponseList} + */ + #batchCacheOperations(operations) { + const cache = this.#relevantRequestResponseList; + const backupCache = [...cache]; + const addedItems = []; + const resultList = []; + try { + for (const operation of operations) { + if (operation.type !== "delete" && operation.type !== "put") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: 'operation type does not match "delete" or "put"' + }); } - return false; -} -function setFlowScalarValue(token, source, type) { - switch (token.type) { - case 'scalar': - case 'double-quoted-scalar': - case 'single-quoted-scalar': - token.type = type; - token.source = source; - break; - case 'block-scalar': { - const end = token.props.slice(1); - let oa = source.length; - if (token.props[0].type === 'block-scalar-header') - oa -= token.props[0].source.length; - for (const tok of end) - tok.offset += oa; - delete token.props; - Object.assign(token, { type, source, end }); - break; + if (operation.type === "delete" && operation.response != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "delete operation should not have an associated response" + }); + } + if (this.#queryCache(operation.request, operation.options, addedItems).length) { + throw new DOMException("???", "InvalidStateError"); + } + let requestResponses; + if (operation.type === "delete") { + requestResponses = this.#queryCache(operation.request, operation.options); + if (requestResponses.length === 0) { + return []; + } + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + } else if (operation.type === "put") { + if (operation.response == null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "put operation should have an associated response" + }); + } + const r = operation.request; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "expected http or https scheme" + }); + } + if (r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "not get method" + }); + } + if (operation.options != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "options must not be defined" + }); + } + requestResponses = this.#queryCache(operation.request); + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + cache.push([operation.request, operation.response]); + addedItems.push([operation.request, operation.response]); + } + resultList.push([operation.request, operation.response]); + } + return resultList; + } catch (e) { + this.#relevantRequestResponseList.length = 0; + this.#relevantRequestResponseList = backupCache; + throw e; } - case 'block-map': - case 'block-seq': { - const offset = token.offset + source.length; - const nl = { type: 'newline', offset, indent: token.indent, source: '\n' }; - delete token.items; - Object.assign(token, { type, source, end: [nl] }); - break; + } + /** + * @see https://w3c.github.io/ServiceWorker/#query-cache + * @param {any} requestQuery + * @param {import('../../types/cache').CacheQueryOptions} options + * @param {requestResponseList} targetStorage + * @returns {requestResponseList} + */ + #queryCache(requestQuery, options, targetStorage) { + const resultList = []; + const storage = targetStorage ?? this.#relevantRequestResponseList; + for (const requestResponse of storage) { + const [cachedRequest, cachedResponse] = requestResponse; + if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) { + resultList.push(requestResponse); + } } - default: { - const indent = 'indent' in token ? token.indent : -1; - const end = 'end' in token && Array.isArray(token.end) - ? token.end.filter(st => st.type === 'space' || - st.type === 'comment' || - st.type === 'newline') - : []; - for (const key of Object.keys(token)) - if (key !== 'type' && key !== 'offset') - delete token[key]; - Object.assign(token, { type, indent, source, end }); + return resultList; + } + /** + * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm + * @param {any} requestQuery + * @param {any} request + * @param {any | null} response + * @param {import('../../types/cache').CacheQueryOptions | undefined} options + * @returns {boolean} + */ + #requestMatchesCachedItem(requestQuery, request, response = null, options) { + const queryURL = new URL(requestQuery.url); + const cachedURL = new URL(request.url); + if (options?.ignoreSearch) { + cachedURL.search = ""; + queryURL.search = ""; + } + if (!urlEquals(queryURL, cachedURL, true)) { + return false; + } + if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) { + return true; + } + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + return false; + } + const requestValue = request.headersList.get(fieldValue); + const queryValue = requestQuery.headersList.get(fieldValue); + if (requestValue !== queryValue) { + return false; + } } - } -} - -exports.createScalarToken = createScalarToken; -exports.resolveAsScalar = resolveAsScalar; -exports.setScalarValue = setScalarValue; - - -/***/ }), - -/***/ 1733: -/***/ ((__unused_webpack_module, exports) => { + return true; + } + }; + Object.defineProperties(Cache.prototype, { + [Symbol.toStringTag]: { + value: "Cache", + configurable: true + }, + match: kEnumerableProperty, + matchAll: kEnumerableProperty, + add: kEnumerableProperty, + addAll: kEnumerableProperty, + put: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + var cacheQueryOptionConverters = [ + { + key: "ignoreSearch", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreMethod", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreVary", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters); + webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([ + ...cacheQueryOptionConverters, + { + key: "cacheName", + converter: webidl.converters.DOMString + } + ]); + webidl.converters.Response = webidl.interfaceConverter(Response2); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.RequestInfo + ); + module2.exports = { + Cache + }; + } +}); -"use strict"; +// node_modules/undici/lib/cache/cachestorage.js +var require_cachestorage = __commonJS({ + "node_modules/undici/lib/cache/cachestorage.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { Cache } = require_cache(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var CacheStorage = class _CacheStorage { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map + * @type {Map} + */ + async has(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.has" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.has(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open + * @param {string} cacheName + * @returns {Promise} + */ + async open(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.open" }); + cacheName = webidl.converters.DOMString(cacheName); + if (this.#caches.has(cacheName)) { + const cache2 = this.#caches.get(cacheName); + return new Cache(kConstruct, cache2); + } + const cache = []; + this.#caches.set(cacheName, cache); + return new Cache(kConstruct, cache); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete + * @param {string} cacheName + * @returns {Promise} + */ + async delete(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.delete" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.delete(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys + * @returns {string[]} + */ + async keys() { + webidl.brandCheck(this, _CacheStorage); + const keys = this.#caches.keys(); + return [...keys]; + } + }; + Object.defineProperties(CacheStorage.prototype, { + [Symbol.toStringTag]: { + value: "CacheStorage", + configurable: true + }, + match: kEnumerableProperty, + has: kEnumerableProperty, + open: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + module2.exports = { + CacheStorage + }; + } +}); +// node_modules/undici/lib/cookies/constants.js +var require_constants4 = __commonJS({ + "node_modules/undici/lib/cookies/constants.js"(exports2, module2) { + "use strict"; + var maxAttributeValueSize = 1024; + var maxNameValuePairSize = 4096; + module2.exports = { + maxAttributeValueSize, + maxNameValuePairSize + }; + } +}); -/** - * Stringify a CST document, token, or collection item - * - * Fair warning: This applies no validation whatsoever, and - * simply concatenates the sources in their logical order. - */ -const stringify = (cst) => 'type' in cst ? stringifyToken(cst) : stringifyItem(cst); -function stringifyToken(token) { - switch (token.type) { - case 'block-scalar': { - let res = ''; - for (const tok of token.props) - res += stringifyToken(tok); - return res + token.source; - } - case 'block-map': - case 'block-seq': { - let res = ''; - for (const item of token.items) - res += stringifyItem(item); - return res; - } - case 'flow-collection': { - let res = token.start.source; - for (const item of token.items) - res += stringifyItem(item); - for (const st of token.end) - res += st.source; - return res; - } - case 'document': { - let res = stringifyItem(token); - if (token.end) - for (const st of token.end) - res += st.source; - return res; - } - default: { - let res = token.source; - if ('end' in token && token.end) - for (const st of token.end) - res += st.source; - return res; +// node_modules/undici/lib/cookies/util.js +var require_util6 = __commonJS({ + "node_modules/undici/lib/cookies/util.js"(exports2, module2) { + "use strict"; + function isCTLExcludingHtab(value) { + if (value.length === 0) { + return false; + } + for (const char of value) { + const code = char.charCodeAt(0); + if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) { + return false; + } + } + } + function validateCookieName(name) { + for (const char of name) { + const code = char.charCodeAt(0); + if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") { + throw new Error("Invalid cookie name"); + } + } + } + function validateCookieValue(value) { + for (const char of value) { + const code = char.charCodeAt(0); + if (code < 33 || // exclude CTLs (0-31) + code === 34 || code === 44 || code === 59 || code === 92 || code > 126) { + throw new Error("Invalid header value"); + } + } + } + function validateCookiePath(path2) { + for (const char of path2) { + const code = char.charCodeAt(0); + if (code < 33 || char === ";") { + throw new Error("Invalid cookie path"); + } + } + } + function validateCookieDomain(domain) { + if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) { + throw new Error("Invalid cookie domain"); + } + } + function toIMFDate(date) { + if (typeof date === "number") { + date = new Date(date); + } + const days = [ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat" + ]; + const months = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + const dayName = days[date.getUTCDay()]; + const day = date.getUTCDate().toString().padStart(2, "0"); + const month = months[date.getUTCMonth()]; + const year = date.getUTCFullYear(); + const hour = date.getUTCHours().toString().padStart(2, "0"); + const minute = date.getUTCMinutes().toString().padStart(2, "0"); + const second = date.getUTCSeconds().toString().padStart(2, "0"); + return `${dayName}, ${day} ${month} ${year} ${hour}:${minute}:${second} GMT`; + } + function validateCookieMaxAge(maxAge) { + if (maxAge < 0) { + throw new Error("Invalid cookie max-age"); + } + } + function stringify2(cookie) { + if (cookie.name.length === 0) { + return null; + } + validateCookieName(cookie.name); + validateCookieValue(cookie.value); + const out = [`${cookie.name}=${cookie.value}`]; + if (cookie.name.startsWith("__Secure-")) { + cookie.secure = true; + } + if (cookie.name.startsWith("__Host-")) { + cookie.secure = true; + cookie.domain = null; + cookie.path = "/"; + } + if (cookie.secure) { + out.push("Secure"); + } + if (cookie.httpOnly) { + out.push("HttpOnly"); + } + if (typeof cookie.maxAge === "number") { + validateCookieMaxAge(cookie.maxAge); + out.push(`Max-Age=${cookie.maxAge}`); + } + if (cookie.domain) { + validateCookieDomain(cookie.domain); + out.push(`Domain=${cookie.domain}`); + } + if (cookie.path) { + validateCookiePath(cookie.path); + out.push(`Path=${cookie.path}`); + } + if (cookie.expires && cookie.expires.toString() !== "Invalid Date") { + out.push(`Expires=${toIMFDate(cookie.expires)}`); + } + if (cookie.sameSite) { + out.push(`SameSite=${cookie.sameSite}`); + } + for (const part of cookie.unparsed) { + if (!part.includes("=")) { + throw new Error("Invalid unparsed"); } + const [key, ...value] = part.split("="); + out.push(`${key.trim()}=${value.join("=")}`); + } + return out.join("; "); } -} -function stringifyItem({ start, key, sep, value }) { - let res = ''; - for (const st of start) - res += st.source; - if (key) - res += stringifyToken(key); - if (sep) - for (const st of sep) - res += st.source; - if (value) - res += stringifyToken(value); - return res; -} - -exports.stringify = stringify; - - -/***/ }), - -/***/ 7715: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; + module2.exports = { + isCTLExcludingHtab, + validateCookieName, + validateCookiePath, + validateCookieValue, + toIMFDate, + stringify: stringify2 + }; + } +}); +// node_modules/undici/lib/cookies/parse.js +var require_parse = __commonJS({ + "node_modules/undici/lib/cookies/parse.js"(exports2, module2) { + "use strict"; + var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4(); + var { isCTLExcludingHtab } = require_util6(); + var { collectASequenceOfCodePointsFast } = require_dataURL(); + var assert = require("assert"); + function parseSetCookie(header) { + if (isCTLExcludingHtab(header)) { + return null; + } + let nameValuePair = ""; + let unparsedAttributes = ""; + let name = ""; + let value = ""; + if (header.includes(";")) { + const position = { position: 0 }; + nameValuePair = collectASequenceOfCodePointsFast(";", header, position); + unparsedAttributes = header.slice(position.position); + } else { + nameValuePair = header; + } + if (!nameValuePair.includes("=")) { + value = nameValuePair; + } else { + const position = { position: 0 }; + name = collectASequenceOfCodePointsFast( + "=", + nameValuePair, + position + ); + value = nameValuePair.slice(position.position + 1); + } + name = name.trim(); + value = value.trim(); + if (name.length + value.length > maxNameValuePairSize) { + return null; + } + return { + name, + value, + ...parseUnparsedAttributes(unparsedAttributes) + }; + } + function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) { + if (unparsedAttributes.length === 0) { + return cookieAttributeList; + } + assert(unparsedAttributes[0] === ";"); + unparsedAttributes = unparsedAttributes.slice(1); + let cookieAv = ""; + if (unparsedAttributes.includes(";")) { + cookieAv = collectASequenceOfCodePointsFast( + ";", + unparsedAttributes, + { position: 0 } + ); + unparsedAttributes = unparsedAttributes.slice(cookieAv.length); + } else { + cookieAv = unparsedAttributes; + unparsedAttributes = ""; + } + let attributeName = ""; + let attributeValue = ""; + if (cookieAv.includes("=")) { + const position = { position: 0 }; + attributeName = collectASequenceOfCodePointsFast( + "=", + cookieAv, + position + ); + attributeValue = cookieAv.slice(position.position + 1); + } else { + attributeName = cookieAv; + } + attributeName = attributeName.trim(); + attributeValue = attributeValue.trim(); + if (attributeValue.length > maxAttributeValueSize) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const attributeNameLowercase = attributeName.toLowerCase(); + if (attributeNameLowercase === "expires") { + const expiryTime = new Date(attributeValue); + cookieAttributeList.expires = expiryTime; + } else if (attributeNameLowercase === "max-age") { + const charCode = attributeValue.charCodeAt(0); + if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + if (!/^\d+$/.test(attributeValue)) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const deltaSeconds = Number(attributeValue); + cookieAttributeList.maxAge = deltaSeconds; + } else if (attributeNameLowercase === "domain") { + let cookieDomain = attributeValue; + if (cookieDomain[0] === ".") { + cookieDomain = cookieDomain.slice(1); + } + cookieDomain = cookieDomain.toLowerCase(); + cookieAttributeList.domain = cookieDomain; + } else if (attributeNameLowercase === "path") { + let cookiePath = ""; + if (attributeValue.length === 0 || attributeValue[0] !== "/") { + cookiePath = "/"; + } else { + cookiePath = attributeValue; + } + cookieAttributeList.path = cookiePath; + } else if (attributeNameLowercase === "secure") { + cookieAttributeList.secure = true; + } else if (attributeNameLowercase === "httponly") { + cookieAttributeList.httpOnly = true; + } else if (attributeNameLowercase === "samesite") { + let enforcement = "Default"; + const attributeValueLowercase = attributeValue.toLowerCase(); + if (attributeValueLowercase.includes("none")) { + enforcement = "None"; + } + if (attributeValueLowercase.includes("strict")) { + enforcement = "Strict"; + } + if (attributeValueLowercase.includes("lax")) { + enforcement = "Lax"; + } + cookieAttributeList.sameSite = enforcement; + } else { + cookieAttributeList.unparsed ??= []; + cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`); + } + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + module2.exports = { + parseSetCookie, + parseUnparsedAttributes + }; + } +}); -const BREAK = Symbol('break visit'); -const SKIP = Symbol('skip children'); -const REMOVE = Symbol('remove item'); -/** - * Apply a visitor to a CST document or item. - * - * Walks through the tree (depth-first) starting from the root, calling a - * `visitor` function with two arguments when entering each item: - * - `item`: The current item, which included the following members: - * - `start: SourceToken[]` – Source tokens before the key or value, - * possibly including its anchor or tag. - * - `key?: Token | null` – Set for pair values. May then be `null`, if - * the key before the `:` separator is empty. - * - `sep?: SourceToken[]` – Source tokens between the key and the value, - * which should include the `:` map value indicator if `value` is set. - * - `value?: Token` – The value of a sequence item, or of a map pair. - * - `path`: The steps from the root to the current node, as an array of - * `['key' | 'value', number]` tuples. - * - * The return value of the visitor may be used to control the traversal: - * - `undefined` (default): Do nothing and continue - * - `visit.SKIP`: Do not visit the children of this token, continue with - * next sibling - * - `visit.BREAK`: Terminate traversal completely - * - `visit.REMOVE`: Remove the current item, then continue with the next one - * - `number`: Set the index of the next step. This is useful especially if - * the index of the current token has changed. - * - `function`: Define the next visitor for this item. After the original - * visitor is called on item entry, next visitors are called after handling - * a non-empty `key` and when exiting the item. - */ -function visit(cst, visitor) { - if ('type' in cst && cst.type === 'document') - cst = { start: cst.start, value: cst.value }; - _visit(Object.freeze([]), cst, visitor); -} -// Without the `as symbol` casts, TS declares these in the `visit` -// namespace using `var`, but then complains about that because -// `unique symbol` must be `const`. -/** Terminate visit traversal completely */ -visit.BREAK = BREAK; -/** Do not visit the children of the current item */ -visit.SKIP = SKIP; -/** Remove the current item */ -visit.REMOVE = REMOVE; -/** Find the item at `path` from `cst` as the root */ -visit.itemAtPath = (cst, path) => { - let item = cst; - for (const [field, index] of path) { - const tok = item?.[field]; - if (tok && 'items' in tok) { - item = tok.items[index]; - } - else - return undefined; +// node_modules/undici/lib/cookies/index.js +var require_cookies = __commonJS({ + "node_modules/undici/lib/cookies/index.js"(exports2, module2) { + "use strict"; + var { parseSetCookie } = require_parse(); + var { stringify: stringify2 } = require_util6(); + var { webidl } = require_webidl(); + var { Headers: Headers2 } = require_headers(); + function getCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookie = headers.get("cookie"); + const out = {}; + if (!cookie) { + return out; + } + for (const piece of cookie.split(";")) { + const [name, ...value] = piece.split("="); + out[name.trim()] = value.join("="); + } + return out; + } + function deleteCookie(headers, name, attributes) { + webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + name = webidl.converters.DOMString(name); + attributes = webidl.converters.DeleteCookieAttributes(attributes); + setCookie(headers, { + name, + value: "", + expires: /* @__PURE__ */ new Date(0), + ...attributes + }); + } + function getSetCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookies = headers.getSetCookie(); + if (!cookies) { + return []; + } + return cookies.map((pair) => parseSetCookie(pair)); } - return item; -}; -/** - * Get the immediate parent collection of the item at `path` from `cst` as the root. - * - * Throws an error if the collection is not found, which should never happen if the item itself exists. - */ -visit.parentCollection = (cst, path) => { - const parent = visit.itemAtPath(cst, path.slice(0, -1)); - const field = path[path.length - 1][0]; - const coll = parent?.[field]; - if (coll && 'items' in coll) - return coll; - throw new Error('Parent collection not found'); -}; -function _visit(path, item, visitor) { - let ctrl = visitor(item, path); - if (typeof ctrl === 'symbol') - return ctrl; - for (const field of ['key', 'value']) { - const token = item[field]; - if (token && 'items' in token) { - for (let i = 0; i < token.items.length; ++i) { - const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor); - if (typeof ci === 'number') - i = ci - 1; - else if (ci === BREAK) - return BREAK; - else if (ci === REMOVE) { - token.items.splice(i, 1); - i -= 1; - } - } - if (typeof ctrl === 'function' && field === 'key') - ctrl = ctrl(item, path); - } + function setCookie(headers, cookie) { + webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + cookie = webidl.converters.Cookie(cookie); + const str = stringify2(cookie); + if (str) { + headers.append("Set-Cookie", stringify2(cookie)); + } } - return typeof ctrl === 'function' ? ctrl(item, path) : ctrl; -} - -exports.visit = visit; - - -/***/ }), - -/***/ 3461: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([ + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + } + ]); + webidl.converters.Cookie = webidl.dictionaryConverter([ + { + converter: webidl.converters.DOMString, + key: "name" + }, + { + converter: webidl.converters.DOMString, + key: "value" + }, + { + converter: webidl.nullableConverter((value) => { + if (typeof value === "number") { + return webidl.converters["unsigned long long"](value); + } + return new Date(value); + }), + key: "expires", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters["long long"]), + key: "maxAge", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "secure", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "httpOnly", + defaultValue: null + }, + { + converter: webidl.converters.USVString, + key: "sameSite", + allowedValues: ["Strict", "Lax", "None"] + }, + { + converter: webidl.sequenceConverter(webidl.converters.DOMString), + key: "unparsed", + defaultValue: [] + } + ]); + module2.exports = { + getCookies, + deleteCookie, + getSetCookies, + setCookie + }; + } +}); -"use strict"; +// node_modules/undici/lib/websocket/constants.js +var require_constants5 = __commonJS({ + "node_modules/undici/lib/websocket/constants.js"(exports2, module2) { + "use strict"; + var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + var states = { + CONNECTING: 0, + OPEN: 1, + CLOSING: 2, + CLOSED: 3 + }; + var opcodes = { + CONTINUATION: 0, + TEXT: 1, + BINARY: 2, + CLOSE: 8, + PING: 9, + PONG: 10 + }; + var maxUnsigned16Bit = 2 ** 16 - 1; + var parserStates = { + INFO: 0, + PAYLOADLENGTH_16: 2, + PAYLOADLENGTH_64: 3, + READ_DATA: 4 + }; + var emptyBuffer = Buffer.allocUnsafe(0); + module2.exports = { + uid, + staticPropertyDescriptors, + states, + opcodes, + maxUnsigned16Bit, + parserStates, + emptyBuffer + }; + } +}); +// node_modules/undici/lib/websocket/symbols.js +var require_symbols5 = __commonJS({ + "node_modules/undici/lib/websocket/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kWebSocketURL: Symbol("url"), + kReadyState: Symbol("ready state"), + kController: Symbol("controller"), + kResponse: Symbol("response"), + kBinaryType: Symbol("binary type"), + kSentClose: Symbol("sent close"), + kReceivedClose: Symbol("received close"), + kByteParser: Symbol("byte parser") + }; + } +}); -var cstScalar = __nccwpck_require__(110); -var cstStringify = __nccwpck_require__(1733); -var cstVisit = __nccwpck_require__(7715); +// node_modules/undici/lib/websocket/events.js +var require_events = __commonJS({ + "node_modules/undici/lib/websocket/events.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var { MessagePort } = require("worker_threads"); + var MessageEvent = class _MessageEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.MessageEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get data() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.data; + } + get origin() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.origin; + } + get lastEventId() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.lastEventId; + } + get source() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.source; + } + get ports() { + webidl.brandCheck(this, _MessageEvent); + if (!Object.isFrozen(this.#eventInit.ports)) { + Object.freeze(this.#eventInit.ports); + } + return this.#eventInit.ports; + } + initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) { + webidl.brandCheck(this, _MessageEvent); + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" }); + return new _MessageEvent(type, { + bubbles, + cancelable, + data, + origin, + lastEventId, + source, + ports + }); + } + }; + var CloseEvent = class _CloseEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.CloseEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get wasClean() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.wasClean; + } + get code() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.code; + } + get reason() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.reason; + } + }; + var ErrorEvent = class _ErrorEvent extends Event { + #eventInit; + constructor(type, eventInitDict) { + webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" }); + super(type, eventInitDict); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {}); + this.#eventInit = eventInitDict; + } + get message() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.message; + } + get filename() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.filename; + } + get lineno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.lineno; + } + get colno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.colno; + } + get error() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.error; + } + }; + Object.defineProperties(MessageEvent.prototype, { + [Symbol.toStringTag]: { + value: "MessageEvent", + configurable: true + }, + data: kEnumerableProperty, + origin: kEnumerableProperty, + lastEventId: kEnumerableProperty, + source: kEnumerableProperty, + ports: kEnumerableProperty, + initMessageEvent: kEnumerableProperty + }); + Object.defineProperties(CloseEvent.prototype, { + [Symbol.toStringTag]: { + value: "CloseEvent", + configurable: true + }, + reason: kEnumerableProperty, + code: kEnumerableProperty, + wasClean: kEnumerableProperty + }); + Object.defineProperties(ErrorEvent.prototype, { + [Symbol.toStringTag]: { + value: "ErrorEvent", + configurable: true + }, + message: kEnumerableProperty, + filename: kEnumerableProperty, + lineno: kEnumerableProperty, + colno: kEnumerableProperty, + error: kEnumerableProperty + }); + webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.MessagePort + ); + var eventInit = [ + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.MessageEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "data", + converter: webidl.converters.any, + defaultValue: null + }, + { + key: "origin", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lastEventId", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "source", + // Node doesn't implement WindowProxy or ServiceWorker, so the only + // valid value for source is a MessagePort. + converter: webidl.nullableConverter(webidl.converters.MessagePort), + defaultValue: null + }, + { + key: "ports", + converter: webidl.converters["sequence"], + get defaultValue() { + return []; + } + } + ]); + webidl.converters.CloseEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "wasClean", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "code", + converter: webidl.converters["unsigned short"], + defaultValue: 0 + }, + { + key: "reason", + converter: webidl.converters.USVString, + defaultValue: "" + } + ]); + webidl.converters.ErrorEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "message", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "filename", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lineno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "colno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "error", + converter: webidl.converters.any + } + ]); + module2.exports = { + MessageEvent, + CloseEvent, + ErrorEvent + }; + } +}); -/** The byte order mark */ -const BOM = '\u{FEFF}'; -/** Start of doc-mode */ -const DOCUMENT = '\x02'; // C0: Start of Text -/** Unexpected end of flow-mode */ -const FLOW_END = '\x18'; // C0: Cancel -/** Next token is a scalar value */ -const SCALAR = '\x1f'; // C0: Unit Separator -/** @returns `true` if `token` is a flow or block collection */ -const isCollection = (token) => !!token && 'items' in token; -/** @returns `true` if `token` is a flow or block scalar; not an alias */ -const isScalar = (token) => !!token && - (token.type === 'scalar' || - token.type === 'single-quoted-scalar' || - token.type === 'double-quoted-scalar' || - token.type === 'block-scalar'); -/* istanbul ignore next */ -/** Get a printable representation of a lexer token */ -function prettyToken(token) { - switch (token) { - case BOM: - return ''; - case DOCUMENT: - return ''; - case FLOW_END: - return ''; - case SCALAR: - return ''; - default: - return JSON.stringify(token); +// node_modules/undici/lib/websocket/util.js +var require_util7 = __commonJS({ + "node_modules/undici/lib/websocket/util.js"(exports2, module2) { + "use strict"; + var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5(); + var { states, opcodes } = require_constants5(); + var { MessageEvent, ErrorEvent } = require_events(); + function isEstablished(ws) { + return ws[kReadyState] === states.OPEN; } -} -/** Identify the type of a lexer token. May return `null` for unknown tokens. */ -function tokenType(source) { - switch (source) { - case BOM: - return 'byte-order-mark'; - case DOCUMENT: - return 'doc-mode'; - case FLOW_END: - return 'flow-error-end'; - case SCALAR: - return 'scalar'; - case '---': - return 'doc-start'; - case '...': - return 'doc-end'; - case '': - case '\n': - case '\r\n': - return 'newline'; - case '-': - return 'seq-item-ind'; - case '?': - return 'explicit-key-ind'; - case ':': - return 'map-value-ind'; - case '{': - return 'flow-map-start'; - case '}': - return 'flow-map-end'; - case '[': - return 'flow-seq-start'; - case ']': - return 'flow-seq-end'; - case ',': - return 'comma'; - } - switch (source[0]) { - case ' ': - case '\t': - return 'space'; - case '#': - return 'comment'; - case '%': - return 'directive-line'; - case '*': - return 'alias'; - case '&': - return 'anchor'; - case '!': - return 'tag'; - case "'": - return 'single-quoted-scalar'; - case '"': - return 'double-quoted-scalar'; - case '|': - case '>': - return 'block-scalar-header'; + function isClosing(ws) { + return ws[kReadyState] === states.CLOSING; } - return null; -} - -exports.createScalarToken = cstScalar.createScalarToken; -exports.resolveAsScalar = cstScalar.resolveAsScalar; -exports.setScalarValue = cstScalar.setScalarValue; -exports.stringify = cstStringify.stringify; -exports.visit = cstVisit.visit; -exports.BOM = BOM; -exports.DOCUMENT = DOCUMENT; -exports.FLOW_END = FLOW_END; -exports.SCALAR = SCALAR; -exports.isCollection = isCollection; -exports.isScalar = isScalar; -exports.prettyToken = prettyToken; -exports.tokenType = tokenType; - - -/***/ }), - -/***/ 361: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var cst = __nccwpck_require__(3461); - -/* -START -> stream - -stream - directive -> line-end -> stream - indent + line-end -> stream - [else] -> line-start - -line-end - comment -> line-end - newline -> . - input-end -> END - -line-start - doc-start -> doc - doc-end -> stream - [else] -> indent -> block-start - -block-start - seq-item-start -> block-start - explicit-key-start -> block-start - map-value-start -> block-start - [else] -> doc - -doc - line-end -> line-start - spaces -> doc - anchor -> doc - tag -> doc - flow-start -> flow -> doc - flow-end -> error -> doc - seq-item-start -> error -> doc - explicit-key-start -> error -> doc - map-value-start -> doc - alias -> doc - quote-start -> quoted-scalar -> doc - block-scalar-header -> line-end -> block-scalar(min) -> line-start - [else] -> plain-scalar(false, min) -> doc - -flow - line-end -> flow - spaces -> flow - anchor -> flow - tag -> flow - flow-start -> flow -> flow - flow-end -> . - seq-item-start -> error -> flow - explicit-key-start -> flow - map-value-start -> flow - alias -> flow - quote-start -> quoted-scalar -> flow - comma -> flow - [else] -> plain-scalar(true, 0) -> flow - -quoted-scalar - quote-end -> . - [else] -> quoted-scalar - -block-scalar(min) - newline + peek(indent < min) -> . - [else] -> block-scalar(min) - -plain-scalar(is-flow, min) - scalar-end(is-flow) -> . - peek(newline + (indent < min)) -> . - [else] -> plain-scalar(min) -*/ -function isEmpty(ch) { - switch (ch) { - case undefined: - case ' ': - case '\n': - case '\r': - case '\t': - return true; - default: - return false; + function isClosed(ws) { + return ws[kReadyState] === states.CLOSED; } -} -const hexDigits = new Set('0123456789ABCDEFabcdef'); -const tagChars = new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()"); -const flowIndicatorChars = new Set(',[]{}'); -const invalidAnchorChars = new Set(' ,[]{}\n\r\t'); -const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch); -/** - * Splits an input string into lexical tokens, i.e. smaller strings that are - * easily identifiable by `tokens.tokenType()`. - * - * Lexing starts always in a "stream" context. Incomplete input may be buffered - * until a complete token can be emitted. - * - * In addition to slices of the original input, the following control characters - * may also be emitted: - * - * - `\x02` (Start of Text): A document starts with the next token - * - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error) - * - `\x1f` (Unit Separator): Next token is a scalar value - * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents - */ -class Lexer { - constructor() { - /** - * Flag indicating whether the end of the current buffer marks the end of - * all input - */ - this.atEnd = false; - /** - * Explicit indent set in block scalar header, as an offset from the current - * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not - * explicitly set. - */ - this.blockScalarIndent = -1; - /** - * Block scalars that include a + (keep) chomping indicator in their header - * include trailing empty lines, which are otherwise excluded from the - * scalar's contents. - */ - this.blockScalarKeep = false; - /** Current input */ - this.buffer = ''; - /** - * Flag noting whether the map value indicator : can immediately follow this - * node within a flow context. - */ - this.flowKey = false; - /** Count of surrounding flow collection levels. */ - this.flowLevel = 0; - /** - * Minimum level of indentation required for next lines to be parsed as a - * part of the current scalar value. - */ - this.indentNext = 0; - /** Indentation level of the current line. */ - this.indentValue = 0; - /** Position of the next \n character. */ - this.lineEndPos = null; - /** Stores the state of the lexer if reaching the end of incpomplete input */ - this.next = null; - /** A pointer to `buffer`; the current position of the lexer. */ - this.pos = 0; + function fireEvent(e, target, eventConstructor = Event, eventInitDict) { + const event = new eventConstructor(e, eventInitDict); + target.dispatchEvent(event); } - /** - * Generate YAML tokens from the `source` string. If `incomplete`, - * a part of the last line may be left as a buffer for the next call. - * - * @returns A generator of lexical tokens - */ - *lex(source, incomplete = false) { - if (source) { - if (typeof source !== 'string') - throw TypeError('source is not a string'); - this.buffer = this.buffer ? this.buffer + source : source; - this.lineEndPos = null; + function websocketMessageReceived(ws, type, data) { + if (ws[kReadyState] !== states.OPEN) { + return; + } + let dataForEvent; + if (type === opcodes.TEXT) { + try { + dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data); + } catch { + failWebsocketConnection(ws, "Received invalid UTF-8 in text frame."); + return; + } + } else if (type === opcodes.BINARY) { + if (ws[kBinaryType] === "blob") { + dataForEvent = new Blob([data]); + } else { + dataForEvent = new Uint8Array(data).buffer; } - this.atEnd = !incomplete; - let next = this.next ?? 'stream'; - while (next && (incomplete || this.hasChars(1))) - next = yield* this.parseNext(next); + } + fireEvent("message", ws, MessageEvent, { + origin: ws[kWebSocketURL].origin, + data: dataForEvent + }); } - atLineEnd() { - let i = this.pos; - let ch = this.buffer[i]; - while (ch === ' ' || ch === '\t') - ch = this.buffer[++i]; - if (!ch || ch === '#' || ch === '\n') - return true; - if (ch === '\r') - return this.buffer[i + 1] === '\n'; + function isValidSubprotocol(protocol) { + if (protocol.length === 0) { return false; + } + for (const char of protocol) { + const code = char.charCodeAt(0); + if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP + code === 9) { + return false; + } + } + return true; } - charAt(n) { - return this.buffer[this.pos + n]; + function isValidStatusCode(code) { + if (code >= 1e3 && code < 1015) { + return code !== 1004 && // reserved + code !== 1005 && // "MUST NOT be set as a status code" + code !== 1006; + } + return code >= 3e3 && code <= 4999; } - continueScalar(offset) { - let ch = this.buffer[offset]; - if (this.indentNext > 0) { - let indent = 0; - while (ch === ' ') - ch = this.buffer[++indent + offset]; - if (ch === '\r') { - const next = this.buffer[indent + offset + 1]; - if (next === '\n' || (!next && !this.atEnd)) - return offset + indent + 1; - } - return ch === '\n' || indent >= this.indentNext || (!ch && !this.atEnd) - ? offset + indent - : -1; - } - if (ch === '-' || ch === '.') { - const dt = this.buffer.substr(offset, 3); - if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3])) - return -1; - } - return offset; + function failWebsocketConnection(ws, reason) { + const { [kController]: controller, [kResponse]: response } = ws; + controller.abort(); + if (response?.socket && !response.socket.destroyed) { + response.socket.destroy(); + } + if (reason) { + fireEvent("error", ws, ErrorEvent, { + error: new Error(reason) + }); + } } - getLine() { - let end = this.lineEndPos; - if (typeof end !== 'number' || (end !== -1 && end < this.pos)) { - end = this.buffer.indexOf('\n', this.pos); - this.lineEndPos = end; - } - if (end === -1) - return this.atEnd ? this.buffer.substring(this.pos) : null; - if (this.buffer[end - 1] === '\r') - end -= 1; - return this.buffer.substring(this.pos, end); + module2.exports = { + isEstablished, + isClosing, + isClosed, + fireEvent, + isValidSubprotocol, + isValidStatusCode, + failWebsocketConnection, + websocketMessageReceived + }; + } +}); + +// node_modules/undici/lib/websocket/connection.js +var require_connection = __commonJS({ + "node_modules/undici/lib/websocket/connection.js"(exports2, module2) { + "use strict"; + var diagnosticsChannel = require("diagnostics_channel"); + var { uid, states } = require_constants5(); + var { + kReadyState, + kSentClose, + kByteParser, + kReceivedClose + } = require_symbols5(); + var { fireEvent, failWebsocketConnection } = require_util7(); + var { CloseEvent } = require_events(); + var { makeRequest } = require_request2(); + var { fetching } = require_fetch(); + var { Headers: Headers2 } = require_headers(); + var { getGlobalDispatcher } = require_global2(); + var { kHeadersList } = require_symbols(); + var channels = {}; + channels.open = diagnosticsChannel.channel("undici:websocket:open"); + channels.close = diagnosticsChannel.channel("undici:websocket:close"); + channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error"); + var crypto; + try { + crypto = require("crypto"); + } catch { } - hasChars(n) { - return this.pos + n <= this.buffer.length; + function establishWebSocketConnection(url, protocols, ws, onEstablish, options) { + const requestURL = url; + requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:"; + const request = makeRequest({ + urlList: [requestURL], + serviceWorkers: "none", + referrer: "no-referrer", + mode: "websocket", + credentials: "include", + cache: "no-store", + redirect: "error" + }); + if (options.headers) { + const headersList = new Headers2(options.headers)[kHeadersList]; + request.headersList = headersList; + } + const keyValue = crypto.randomBytes(16).toString("base64"); + request.headersList.append("sec-websocket-key", keyValue); + request.headersList.append("sec-websocket-version", "13"); + for (const protocol of protocols) { + request.headersList.append("sec-websocket-protocol", protocol); + } + const permessageDeflate = ""; + const controller = fetching({ + request, + useParallelQueue: true, + dispatcher: options.dispatcher ?? getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status !== 101) { + failWebsocketConnection(ws, "Received network error or non-101 status code."); + return; + } + if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Server did not respond with sent protocols."); + return; + } + if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") { + failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".'); + return; + } + if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") { + failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".'); + return; + } + const secWSAccept = response.headersList.get("Sec-WebSocket-Accept"); + const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64"); + if (secWSAccept !== digest) { + failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header."); + return; + } + const secExtension = response.headersList.get("Sec-WebSocket-Extensions"); + if (secExtension !== null && secExtension !== permessageDeflate) { + failWebsocketConnection(ws, "Received different permessage-deflate than the one set."); + return; + } + const secProtocol = response.headersList.get("Sec-WebSocket-Protocol"); + if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Protocol was not set in the opening handshake."); + return; + } + response.socket.on("data", onSocketData); + response.socket.on("close", onSocketClose); + response.socket.on("error", onSocketError); + if (channels.open.hasSubscribers) { + channels.open.publish({ + address: response.socket.address(), + protocol: secProtocol, + extensions: secExtension + }); + } + onEstablish(response); + } + }); + return controller; + } + function onSocketData(chunk) { + if (!this.ws[kByteParser].write(chunk)) { + this.pause(); + } + } + function onSocketClose() { + const { ws } = this; + const wasClean = ws[kSentClose] && ws[kReceivedClose]; + let code = 1005; + let reason = ""; + const result = ws[kByteParser].closingInfo; + if (result) { + code = result.code ?? 1005; + reason = result.reason; + } else if (!ws[kSentClose]) { + code = 1006; + } + ws[kReadyState] = states.CLOSED; + fireEvent("close", ws, CloseEvent, { + wasClean, + code, + reason + }); + if (channels.close.hasSubscribers) { + channels.close.publish({ + websocket: ws, + code, + reason + }); + } } - setNext(state) { - this.buffer = this.buffer.substring(this.pos); - this.pos = 0; - this.lineEndPos = null; - this.next = state; - return null; + function onSocketError(error2) { + const { ws } = this; + ws[kReadyState] = states.CLOSING; + if (channels.socketError.hasSubscribers) { + channels.socketError.publish(error2); + } + this.destroy(); } - peek(n) { - return this.buffer.substr(this.pos, n); + module2.exports = { + establishWebSocketConnection + }; + } +}); + +// node_modules/undici/lib/websocket/frame.js +var require_frame = __commonJS({ + "node_modules/undici/lib/websocket/frame.js"(exports2, module2) { + "use strict"; + var { maxUnsigned16Bit } = require_constants5(); + var crypto; + try { + crypto = require("crypto"); + } catch { } - *parseNext(next) { - switch (next) { - case 'stream': - return yield* this.parseStream(); - case 'line-start': - return yield* this.parseLineStart(); - case 'block-start': - return yield* this.parseBlockStart(); - case 'doc': - return yield* this.parseDocument(); - case 'flow': - return yield* this.parseFlowCollection(); - case 'quoted-scalar': - return yield* this.parseQuotedScalar(); - case 'block-scalar': - return yield* this.parseBlockScalar(); - case 'plain-scalar': - return yield* this.parsePlainScalar(); - } - } - *parseStream() { - let line = this.getLine(); - if (line === null) - return this.setNext('stream'); - if (line[0] === cst.BOM) { - yield* this.pushCount(1); - line = line.substring(1); - } - if (line[0] === '%') { - let dirEnd = line.length; - let cs = line.indexOf('#'); - while (cs !== -1) { - const ch = line[cs - 1]; - if (ch === ' ' || ch === '\t') { - dirEnd = cs - 1; - break; - } - else { - cs = line.indexOf('#', cs + 1); + var WebsocketFrameSend = class { + /** + * @param {Buffer|undefined} data + */ + constructor(data) { + this.frameData = data; + this.maskKey = crypto.randomBytes(4); + } + createFrame(opcode) { + const bodyLength = this.frameData?.byteLength ?? 0; + let payloadLength = bodyLength; + let offset = 6; + if (bodyLength > maxUnsigned16Bit) { + offset += 8; + payloadLength = 127; + } else if (bodyLength > 125) { + offset += 2; + payloadLength = 126; + } + const buffer = Buffer.allocUnsafe(bodyLength + offset); + buffer[0] = buffer[1] = 0; + buffer[0] |= 128; + buffer[0] = (buffer[0] & 240) + opcode; + buffer[offset - 4] = this.maskKey[0]; + buffer[offset - 3] = this.maskKey[1]; + buffer[offset - 2] = this.maskKey[2]; + buffer[offset - 1] = this.maskKey[3]; + buffer[1] = payloadLength; + if (payloadLength === 126) { + buffer.writeUInt16BE(bodyLength, 2); + } else if (payloadLength === 127) { + buffer[2] = buffer[3] = 0; + buffer.writeUIntBE(bodyLength, 4, 6); + } + buffer[1] |= 128; + for (let i = 0; i < bodyLength; i++) { + buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4]; + } + return buffer; + } + }; + module2.exports = { + WebsocketFrameSend + }; + } +}); + +// node_modules/undici/lib/websocket/receiver.js +var require_receiver = __commonJS({ + "node_modules/undici/lib/websocket/receiver.js"(exports2, module2) { + "use strict"; + var { Writable } = require("stream"); + var diagnosticsChannel = require("diagnostics_channel"); + var { parserStates, opcodes, states, emptyBuffer } = require_constants5(); + var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5(); + var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util7(); + var { WebsocketFrameSend } = require_frame(); + var channels = {}; + channels.ping = diagnosticsChannel.channel("undici:websocket:ping"); + channels.pong = diagnosticsChannel.channel("undici:websocket:pong"); + var ByteParser = class extends Writable { + #buffers = []; + #byteOffset = 0; + #state = parserStates.INFO; + #info = {}; + #fragments = []; + constructor(ws) { + super(); + this.ws = ws; + } + /** + * @param {Buffer} chunk + * @param {() => void} callback + */ + _write(chunk, _, callback) { + this.#buffers.push(chunk); + this.#byteOffset += chunk.length; + this.run(callback); + } + /** + * Runs whenever a new chunk is received. + * Callback is called whenever there are no more chunks buffering, + * or not enough bytes are buffered to parse. + */ + run(callback) { + while (true) { + if (this.#state === parserStates.INFO) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.fin = (buffer[0] & 128) !== 0; + this.#info.opcode = buffer[0] & 15; + this.#info.originalOpcode ??= this.#info.opcode; + this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION; + if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) { + failWebsocketConnection(this.ws, "Invalid frame type was fragmented."); + return; + } + const payloadLength = buffer[1] & 127; + if (payloadLength <= 125) { + this.#info.payloadLength = payloadLength; + this.#state = parserStates.READ_DATA; + } else if (payloadLength === 126) { + this.#state = parserStates.PAYLOADLENGTH_16; + } else if (payloadLength === 127) { + this.#state = parserStates.PAYLOADLENGTH_64; + } + if (this.#info.fragmented && payloadLength > 125) { + failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes."); + return; + } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) { + failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes."); + return; + } else if (this.#info.opcode === opcodes.CLOSE) { + if (payloadLength === 1) { + failWebsocketConnection(this.ws, "Received close frame with a 1-byte body."); + return; + } + const body = this.consume(payloadLength); + this.#info.closeInfo = this.parseCloseBody(false, body); + if (!this.ws[kSentClose]) { + const body2 = Buffer.allocUnsafe(2); + body2.writeUInt16BE(this.#info.closeInfo.code, 0); + const closeFrame = new WebsocketFrameSend(body2); + this.ws[kResponse].socket.write( + closeFrame.createFrame(opcodes.CLOSE), + (err) => { + if (!err) { + this.ws[kSentClose] = true; + } + } + ); + } + this.ws[kReadyState] = states.CLOSING; + this.ws[kReceivedClose] = true; + this.end(); + return; + } else if (this.#info.opcode === opcodes.PING) { + const body = this.consume(payloadLength); + if (!this.ws[kReceivedClose]) { + const frame = new WebsocketFrameSend(body); + this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG)); + if (channels.ping.hasSubscribers) { + channels.ping.publish({ + payload: body + }); } + } + this.#state = parserStates.INFO; + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } + } else if (this.#info.opcode === opcodes.PONG) { + const body = this.consume(payloadLength); + if (channels.pong.hasSubscribers) { + channels.pong.publish({ + payload: body + }); + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } } - while (true) { - const ch = line[dirEnd - 1]; - if (ch === ' ' || ch === '\t') - dirEnd -= 1; - else - break; + } else if (this.#state === parserStates.PAYLOADLENGTH_16) { + if (this.#byteOffset < 2) { + return callback(); } - const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true)); - yield* this.pushCount(line.length - n); // possible comment - this.pushNewline(); - return 'stream'; + const buffer = this.consume(2); + this.#info.payloadLength = buffer.readUInt16BE(0); + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.PAYLOADLENGTH_64) { + if (this.#byteOffset < 8) { + return callback(); + } + const buffer = this.consume(8); + const upper = buffer.readUInt32BE(0); + if (upper > 2 ** 31 - 1) { + failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes."); + return; + } + const lower = buffer.readUInt32BE(4); + this.#info.payloadLength = (upper << 8) + lower; + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.READ_DATA) { + if (this.#byteOffset < this.#info.payloadLength) { + return callback(); + } else if (this.#byteOffset >= this.#info.payloadLength) { + const body = this.consume(this.#info.payloadLength); + this.#fragments.push(body); + if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) { + const fullMessage = Buffer.concat(this.#fragments); + websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage); + this.#info = {}; + this.#fragments.length = 0; + } + this.#state = parserStates.INFO; + } + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + break; + } } - if (this.atLineEnd()) { - const sp = yield* this.pushSpaces(true); - yield* this.pushCount(line.length - sp); - yield* this.pushNewline(); - return 'stream'; + } + /** + * Take n bytes from the buffered Buffers + * @param {number} n + * @returns {Buffer|null} + */ + consume(n) { + if (n > this.#byteOffset) { + return null; + } else if (n === 0) { + return emptyBuffer; + } + if (this.#buffers[0].length === n) { + this.#byteOffset -= this.#buffers[0].length; + return this.#buffers.shift(); + } + const buffer = Buffer.allocUnsafe(n); + let offset = 0; + while (offset !== n) { + const next = this.#buffers[0]; + const { length } = next; + if (length + offset === n) { + buffer.set(this.#buffers.shift(), offset); + break; + } else if (length + offset > n) { + buffer.set(next.subarray(0, n - offset), offset); + this.#buffers[0] = next.subarray(n - offset); + break; + } else { + buffer.set(this.#buffers.shift(), offset); + offset += next.length; + } } - yield cst.DOCUMENT; - return yield* this.parseLineStart(); - } - *parseLineStart() { - const ch = this.charAt(0); - if (!ch && !this.atEnd) - return this.setNext('line-start'); - if (ch === '-' || ch === '.') { - if (!this.atEnd && !this.hasChars(4)) - return this.setNext('line-start'); - const s = this.peek(3); - if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) { - yield* this.pushCount(3); - this.indentValue = 0; - this.indentNext = 0; - return s === '---' ? 'doc' : 'stream'; - } + this.#byteOffset -= n; + return buffer; + } + parseCloseBody(onlyCode, data) { + let code; + if (data.length >= 2) { + code = data.readUInt16BE(0); } - this.indentValue = yield* this.pushSpaces(false); - if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1))) - this.indentNext = this.indentValue; - return yield* this.parseBlockStart(); - } - *parseBlockStart() { - const [ch0, ch1] = this.peek(2); - if (!ch1 && !this.atEnd) - return this.setNext('block-start'); - if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) { - const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)); - this.indentNext = this.indentValue + 1; - this.indentValue += n; - return yield* this.parseBlockStart(); + if (onlyCode) { + if (!isValidStatusCode(code)) { + return null; + } + return { code }; } - return 'doc'; - } - *parseDocument() { - yield* this.pushSpaces(true); - const line = this.getLine(); - if (line === null) - return this.setNext('doc'); - let n = yield* this.pushIndicators(); - switch (line[n]) { - case '#': - yield* this.pushCount(line.length - n); - // fallthrough - case undefined: - yield* this.pushNewline(); - return yield* this.parseLineStart(); - case '{': - case '[': - yield* this.pushCount(1); - this.flowKey = false; - this.flowLevel = 1; - return 'flow'; - case '}': - case ']': - // this is an error - yield* this.pushCount(1); - return 'doc'; - case '*': - yield* this.pushUntil(isNotAnchorChar); - return 'doc'; - case '"': - case "'": - return yield* this.parseQuotedScalar(); - case '|': - case '>': - n += yield* this.parseBlockScalarHeader(); - n += yield* this.pushSpaces(true); - yield* this.pushCount(line.length - n); - yield* this.pushNewline(); - return yield* this.parseBlockScalar(); - default: - return yield* this.parsePlainScalar(); + let reason = data.subarray(2); + if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) { + reason = reason.subarray(3); } - } - *parseFlowCollection() { - let nl, sp; - let indent = -1; - do { - nl = yield* this.pushNewline(); - if (nl > 0) { - sp = yield* this.pushSpaces(false); - this.indentValue = indent = sp; - } - else { - sp = 0; - } - sp += yield* this.pushSpaces(true); - } while (nl + sp > 0); - const line = this.getLine(); - if (line === null) - return this.setNext('flow'); - if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') || - (indent === 0 && - (line.startsWith('---') || line.startsWith('...')) && - isEmpty(line[3]))) { - // Allowing for the terminal ] or } at the same (rather than greater) - // indent level as the initial [ or { is technically invalid, but - // failing here would be surprising to users. - const atFlowEndMarker = indent === this.indentNext - 1 && - this.flowLevel === 1 && - (line[0] === ']' || line[0] === '}'); - if (!atFlowEndMarker) { - // this is an error - this.flowLevel = 0; - yield cst.FLOW_END; - return yield* this.parseLineStart(); - } + if (code !== void 0 && !isValidStatusCode(code)) { + return null; } - let n = 0; - while (line[n] === ',') { - n += yield* this.pushCount(1); - n += yield* this.pushSpaces(true); - this.flowKey = false; + try { + reason = new TextDecoder("utf-8", { fatal: true }).decode(reason); + } catch { + return null; } - n += yield* this.pushIndicators(); - switch (line[n]) { - case undefined: - return 'flow'; - case '#': - yield* this.pushCount(line.length - n); - return 'flow'; - case '{': - case '[': - yield* this.pushCount(1); - this.flowKey = false; - this.flowLevel += 1; - return 'flow'; - case '}': - case ']': - yield* this.pushCount(1); - this.flowKey = true; - this.flowLevel -= 1; - return this.flowLevel ? 'flow' : 'doc'; - case '*': - yield* this.pushUntil(isNotAnchorChar); - return 'flow'; - case '"': - case "'": - this.flowKey = true; - return yield* this.parseQuotedScalar(); - case ':': { - const next = this.charAt(1); - if (this.flowKey || isEmpty(next) || next === ',') { - this.flowKey = false; - yield* this.pushCount(1); - yield* this.pushSpaces(true); - return 'flow'; - } - } - // fallthrough - default: - this.flowKey = false; - return yield* this.parsePlainScalar(); + return { code, reason }; + } + get closingInfo() { + return this.#info.closeInfo; + } + }; + module2.exports = { + ByteParser + }; + } +}); + +// node_modules/undici/lib/websocket/websocket.js +var require_websocket = __commonJS({ + "node_modules/undici/lib/websocket/websocket.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { DOMException: DOMException2 } = require_constants2(); + var { URLSerializer } = require_dataURL(); + var { getGlobalOrigin } = require_global(); + var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants5(); + var { + kWebSocketURL, + kReadyState, + kController, + kBinaryType, + kResponse, + kSentClose, + kByteParser + } = require_symbols5(); + var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util7(); + var { establishWebSocketConnection } = require_connection(); + var { WebsocketFrameSend } = require_frame(); + var { ByteParser } = require_receiver(); + var { kEnumerableProperty, isBlobLike: isBlobLike2 } = require_util(); + var { getGlobalDispatcher } = require_global2(); + var { types } = require("util"); + var experimentalWarned = false; + var WebSocket = class _WebSocket extends EventTarget { + #events = { + open: null, + error: null, + close: null, + message: null + }; + #bufferedAmount = 0; + #protocol = ""; + #extensions = ""; + /** + * @param {string} url + * @param {string|string[]} protocols + */ + constructor(url, protocols = []) { + super(); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" }); + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("WebSockets are experimental, expect them to change at any time.", { + code: "UNDICI-WS" + }); + } + const options = webidl.converters["DOMString or sequence or WebSocketInit"](protocols); + url = webidl.converters.USVString(url); + protocols = options.protocols; + const baseURL = getGlobalOrigin(); + let urlRecord; + try { + urlRecord = new URL(url, baseURL); + } catch (e) { + throw new DOMException2(e, "SyntaxError"); + } + if (urlRecord.protocol === "http:") { + urlRecord.protocol = "ws:"; + } else if (urlRecord.protocol === "https:") { + urlRecord.protocol = "wss:"; + } + if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") { + throw new DOMException2( + `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, + "SyntaxError" + ); + } + if (urlRecord.hash || urlRecord.href.endsWith("#")) { + throw new DOMException2("Got fragment", "SyntaxError"); + } + if (typeof protocols === "string") { + protocols = [protocols]; + } + if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + this[kWebSocketURL] = new URL(urlRecord.href); + this[kController] = establishWebSocketConnection( + urlRecord, + protocols, + this, + (response) => this.#onConnectionEstablished(response), + options + ); + this[kReadyState] = _WebSocket.CONNECTING; + this[kBinaryType] = "blob"; + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-close + * @param {number|undefined} code + * @param {string|undefined} reason + */ + close(code = void 0, reason = void 0) { + webidl.brandCheck(this, _WebSocket); + if (code !== void 0) { + code = webidl.converters["unsigned short"](code, { clamp: true }); + } + if (reason !== void 0) { + reason = webidl.converters.USVString(reason); + } + if (code !== void 0) { + if (code !== 1e3 && (code < 3e3 || code > 4999)) { + throw new DOMException2("invalid code", "InvalidAccessError"); + } } - } - *parseQuotedScalar() { - const quote = this.charAt(0); - let end = this.buffer.indexOf(quote, this.pos + 1); - if (quote === "'") { - while (end !== -1 && this.buffer[end + 1] === "'") - end = this.buffer.indexOf("'", end + 2); + let reasonByteLength = 0; + if (reason !== void 0) { + reasonByteLength = Buffer.byteLength(reason); + if (reasonByteLength > 123) { + throw new DOMException2( + `Reason must be less than 123 bytes; received ${reasonByteLength}`, + "SyntaxError" + ); + } } - else { - // double-quote - while (end !== -1) { - let n = 0; - while (this.buffer[end - 1 - n] === '\\') - n += 1; - if (n % 2 === 0) - break; - end = this.buffer.indexOf('"', end + 1); + if (this[kReadyState] === _WebSocket.CLOSING || this[kReadyState] === _WebSocket.CLOSED) { + } else if (!isEstablished(this)) { + failWebsocketConnection(this, "Connection was closed before it was established."); + this[kReadyState] = _WebSocket.CLOSING; + } else if (!isClosing(this)) { + const frame = new WebsocketFrameSend(); + if (code !== void 0 && reason === void 0) { + frame.frameData = Buffer.allocUnsafe(2); + frame.frameData.writeUInt16BE(code, 0); + } else if (code !== void 0 && reason !== void 0) { + frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength); + frame.frameData.writeUInt16BE(code, 0); + frame.frameData.write(reason, 2, "utf-8"); + } else { + frame.frameData = emptyBuffer; + } + const socket = this[kResponse].socket; + socket.write(frame.createFrame(opcodes.CLOSE), (err) => { + if (!err) { + this[kSentClose] = true; } + }); + this[kReadyState] = states.CLOSING; + } else { + this[kReadyState] = _WebSocket.CLOSING; } - // Only looking for newlines within the quotes - const qb = this.buffer.substring(0, end); - let nl = qb.indexOf('\n', this.pos); - if (nl !== -1) { - while (nl !== -1) { - const cs = this.continueScalar(nl + 1); - if (cs === -1) - break; - nl = qb.indexOf('\n', cs); - } - if (nl !== -1) { - // this is an error caused by an unexpected unindent - end = nl - (qb[nl - 1] === '\r' ? 2 : 1); - } + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-send + * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data + */ + send(data) { + webidl.brandCheck(this, _WebSocket); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" }); + data = webidl.converters.WebSocketSendData(data); + if (this[kReadyState] === _WebSocket.CONNECTING) { + throw new DOMException2("Sent before connected.", "InvalidStateError"); + } + if (!isEstablished(this) || isClosing(this)) { + return; + } + const socket = this[kResponse].socket; + if (typeof data === "string") { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.TEXT); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (types.isArrayBuffer(data)) { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (ArrayBuffer.isView(data)) { + const ab = Buffer.from(data, data.byteOffset, data.byteLength); + const frame = new WebsocketFrameSend(ab); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += ab.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= ab.byteLength; + }); + } else if (isBlobLike2(data)) { + const frame = new WebsocketFrameSend(); + data.arrayBuffer().then((ab) => { + const value = Buffer.from(ab); + frame.frameData = value; + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + }); } - if (end === -1) { - if (!this.atEnd) - return this.setNext('quoted-scalar'); - end = this.buffer.length; + } + get readyState() { + webidl.brandCheck(this, _WebSocket); + return this[kReadyState]; + } + get bufferedAmount() { + webidl.brandCheck(this, _WebSocket); + return this.#bufferedAmount; + } + get url() { + webidl.brandCheck(this, _WebSocket); + return URLSerializer(this[kWebSocketURL]); + } + get extensions() { + webidl.brandCheck(this, _WebSocket); + return this.#extensions; + } + get protocol() { + webidl.brandCheck(this, _WebSocket); + return this.#protocol; + } + get onopen() { + webidl.brandCheck(this, _WebSocket); + return this.#events.open; + } + set onopen(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.open) { + this.removeEventListener("open", this.#events.open); } - yield* this.pushToIndex(end + 1, false); - return this.flowLevel ? 'flow' : 'doc'; - } - *parseBlockScalarHeader() { - this.blockScalarIndent = -1; - this.blockScalarKeep = false; - let i = this.pos; - while (true) { - const ch = this.buffer[++i]; - if (ch === '+') - this.blockScalarKeep = true; - else if (ch > '0' && ch <= '9') - this.blockScalarIndent = Number(ch) - 1; - else if (ch !== '-') - break; + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else { + this.#events.open = null; } - return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#'); - } - *parseBlockScalar() { - let nl = this.pos - 1; // may be -1 if this.pos === 0 - let indent = 0; - let ch; - loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) { - switch (ch) { - case ' ': - indent += 1; - break; - case '\n': - nl = i; - indent = 0; - break; - case '\r': { - const next = this.buffer[i + 1]; - if (!next && !this.atEnd) - return this.setNext('block-scalar'); - if (next === '\n') - break; - } // fallthrough - default: - break loop; - } + } + get onerror() { + webidl.brandCheck(this, _WebSocket); + return this.#events.error; + } + set onerror(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.error) { + this.removeEventListener("error", this.#events.error); + } + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else { + this.#events.error = null; + } + } + get onclose() { + webidl.brandCheck(this, _WebSocket); + return this.#events.close; + } + set onclose(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.close) { + this.removeEventListener("close", this.#events.close); + } + if (typeof fn === "function") { + this.#events.close = fn; + this.addEventListener("close", fn); + } else { + this.#events.close = null; + } + } + get onmessage() { + webidl.brandCheck(this, _WebSocket); + return this.#events.message; + } + set onmessage(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.message) { + this.removeEventListener("message", this.#events.message); + } + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else { + this.#events.message = null; + } + } + get binaryType() { + webidl.brandCheck(this, _WebSocket); + return this[kBinaryType]; + } + set binaryType(type) { + webidl.brandCheck(this, _WebSocket); + if (type !== "blob" && type !== "arraybuffer") { + this[kBinaryType] = "blob"; + } else { + this[kBinaryType] = type; + } + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + */ + #onConnectionEstablished(response) { + this[kResponse] = response; + const parser = new ByteParser(this); + parser.on("drain", function onParserDrain() { + this.ws[kResponse].socket.resume(); + }); + response.socket.ws = this; + this[kByteParser] = parser; + this[kReadyState] = states.OPEN; + const extensions = response.headersList.get("sec-websocket-extensions"); + if (extensions !== null) { + this.#extensions = extensions; + } + const protocol = response.headersList.get("sec-websocket-protocol"); + if (protocol !== null) { + this.#protocol = protocol; + } + fireEvent("open", this); + } + }; + WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING; + WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN; + WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING; + WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED; + Object.defineProperties(WebSocket.prototype, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors, + url: kEnumerableProperty, + readyState: kEnumerableProperty, + bufferedAmount: kEnumerableProperty, + onopen: kEnumerableProperty, + onerror: kEnumerableProperty, + onclose: kEnumerableProperty, + close: kEnumerableProperty, + onmessage: kEnumerableProperty, + binaryType: kEnumerableProperty, + send: kEnumerableProperty, + extensions: kEnumerableProperty, + protocol: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "WebSocket", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(WebSocket, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors + }); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.DOMString + ); + webidl.converters["DOMString or sequence"] = function(V) { + if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) { + return webidl.converters["sequence"](V); + } + return webidl.converters.DOMString(V); + }; + webidl.converters.WebSocketInit = webidl.dictionaryConverter([ + { + key: "protocols", + converter: webidl.converters["DOMString or sequence"], + get defaultValue() { + return []; } - if (!ch && !this.atEnd) - return this.setNext('block-scalar'); - if (indent >= this.indentNext) { - if (this.blockScalarIndent === -1) - this.indentNext = indent; - else { - this.indentNext = - this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext); - } - do { - const cs = this.continueScalar(nl + 1); - if (cs === -1) - break; - nl = this.buffer.indexOf('\n', cs); - } while (nl !== -1); - if (nl === -1) { - if (!this.atEnd) - return this.setNext('block-scalar'); - nl = this.buffer.length; - } + }, + { + key: "dispatcher", + converter: (V) => V, + get defaultValue() { + return getGlobalDispatcher(); } - // Trailing insufficiently indented tabs are invalid. - // To catch that during parsing, we include them in the block scalar value. - let i = nl + 1; - ch = this.buffer[i]; - while (ch === ' ') - ch = this.buffer[++i]; - if (ch === '\t') { - while (ch === '\t' || ch === ' ' || ch === '\r' || ch === '\n') - ch = this.buffer[++i]; - nl = i - 1; - } - else if (!this.blockScalarKeep) { - do { - let i = nl - 1; - let ch = this.buffer[i]; - if (ch === '\r') - ch = this.buffer[--i]; - const lastChar = i; // Drop the line if last char not more indented - while (ch === ' ') - ch = this.buffer[--i]; - if (ch === '\n' && i >= this.pos && i + 1 + indent > lastChar) - nl = i; - else - break; - } while (true); + }, + { + key: "headers", + converter: webidl.nullableConverter(webidl.converters.HeadersInit) + } + ]); + webidl.converters["DOMString or sequence or WebSocketInit"] = function(V) { + if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) { + return webidl.converters.WebSocketInit(V); + } + return { protocols: webidl.converters["DOMString or sequence"](V) }; + }; + webidl.converters.WebSocketSendData = function(V) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); } - yield cst.SCALAR; - yield* this.pushToIndex(nl + 1, true); - return yield* this.parseLineStart(); - } - *parsePlainScalar() { - const inFlow = this.flowLevel > 0; - let end = this.pos - 1; - let i = this.pos - 1; - let ch; - while ((ch = this.buffer[++i])) { - if (ch === ':') { - const next = this.buffer[i + 1]; - if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next))) - break; - end = i; - } - else if (isEmpty(ch)) { - let next = this.buffer[i + 1]; - if (ch === '\r') { - if (next === '\n') { - i += 1; - ch = '\n'; - next = this.buffer[i + 1]; - } - else - end = i; - } - if (next === '#' || (inFlow && flowIndicatorChars.has(next))) - break; - if (ch === '\n') { - const cs = this.continueScalar(i + 1); - if (cs === -1) - break; - i = Math.max(i, cs - 2); // to advance, but still account for ' #' - } - } - else { - if (inFlow && flowIndicatorChars.has(ch)) - break; - end = i; - } + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V); } - if (!ch && !this.atEnd) - return this.setNext('plain-scalar'); - yield cst.SCALAR; - yield* this.pushToIndex(end + 1, true); - return inFlow ? 'flow' : 'doc'; - } - *pushCount(n) { - if (n > 0) { - yield this.buffer.substr(this.pos, n); - this.pos += n; - return n; + } + return webidl.converters.USVString(V); + }; + module2.exports = { + WebSocket + }; + } +}); + +// node_modules/undici/index.js +var require_undici = __commonJS({ + "node_modules/undici/index.js"(exports2, module2) { + "use strict"; + var Client = require_client(); + var Dispatcher = require_dispatcher(); + var errors = require_errors2(); + var Pool = require_pool(); + var BalancedPool = require_balanced_pool(); + var Agent = require_agent(); + var util = require_util(); + var { InvalidArgumentError } = errors; + var api = require_api(); + var buildConnector = require_connect(); + var MockClient = require_mock_client(); + var MockAgent = require_mock_agent(); + var MockPool = require_mock_pool(); + var mockErrors = require_mock_errors(); + var ProxyAgent = require_proxy_agent(); + var RetryHandler = require_RetryHandler(); + var { getGlobalDispatcher, setGlobalDispatcher } = require_global2(); + var DecoratorHandler = require_DecoratorHandler(); + var RedirectHandler = require_RedirectHandler(); + var createRedirectInterceptor = require_redirectInterceptor(); + var hasCrypto; + try { + require("crypto"); + hasCrypto = true; + } catch { + hasCrypto = false; + } + Object.assign(Dispatcher.prototype, api); + module2.exports.Dispatcher = Dispatcher; + module2.exports.Client = Client; + module2.exports.Pool = Pool; + module2.exports.BalancedPool = BalancedPool; + module2.exports.Agent = Agent; + module2.exports.ProxyAgent = ProxyAgent; + module2.exports.RetryHandler = RetryHandler; + module2.exports.DecoratorHandler = DecoratorHandler; + module2.exports.RedirectHandler = RedirectHandler; + module2.exports.createRedirectInterceptor = createRedirectInterceptor; + module2.exports.buildConnector = buildConnector; + module2.exports.errors = errors; + function makeDispatcher(fn) { + return (url, opts, handler) => { + if (typeof opts === "function") { + handler = opts; + opts = null; + } + if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) { + throw new InvalidArgumentError("invalid url"); + } + if (opts != null && typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (opts && opts.path != null) { + if (typeof opts.path !== "string") { + throw new InvalidArgumentError("invalid opts.path"); + } + let path2 = opts.path; + if (!opts.path.startsWith("/")) { + path2 = `/${path2}`; + } + url = new URL(util.parseOrigin(url).origin + path2); + } else { + if (!opts) { + opts = typeof url === "object" ? url : {}; + } + url = util.parseURL(url); } - return 0; - } - *pushToIndex(i, allowEmpty) { - const s = this.buffer.slice(this.pos, i); - if (s) { - yield s; - this.pos += s.length; - return s.length; + const { agent, dispatcher = getGlobalDispatcher() } = opts; + if (agent) { + throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?"); + } + return fn.call(dispatcher, { + ...opts, + origin: url.origin, + path: url.search ? `${url.pathname}${url.search}` : url.pathname, + method: opts.method || (opts.body ? "PUT" : "GET") + }, handler); + }; + } + module2.exports.setGlobalDispatcher = setGlobalDispatcher; + module2.exports.getGlobalDispatcher = getGlobalDispatcher; + if (util.nodeMajor > 16 || util.nodeMajor === 16 && util.nodeMinor >= 8) { + let fetchImpl = null; + module2.exports.fetch = async function fetch2(resource) { + if (!fetchImpl) { + fetchImpl = require_fetch().fetch; } - else if (allowEmpty) - yield ''; - return 0; - } - *pushIndicators() { - switch (this.charAt(0)) { - case '!': - return ((yield* this.pushTag()) + - (yield* this.pushSpaces(true)) + - (yield* this.pushIndicators())); - case '&': - return ((yield* this.pushUntil(isNotAnchorChar)) + - (yield* this.pushSpaces(true)) + - (yield* this.pushIndicators())); - case '-': // this is an error - case '?': // this is an error outside flow collections - case ':': { - const inFlow = this.flowLevel > 0; - const ch1 = this.charAt(1); - if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) { - if (!inFlow) - this.indentNext = this.indentValue + 1; - else if (this.flowKey) - this.flowKey = false; - return ((yield* this.pushCount(1)) + - (yield* this.pushSpaces(true)) + - (yield* this.pushIndicators())); - } - } + try { + return await fetchImpl(...arguments); + } catch (err) { + if (typeof err === "object") { + Error.captureStackTrace(err, this); + } + throw err; + } + }; + module2.exports.Headers = require_headers().Headers; + module2.exports.Response = require_response().Response; + module2.exports.Request = require_request2().Request; + module2.exports.FormData = require_formdata().FormData; + module2.exports.File = require_file().File; + module2.exports.FileReader = require_filereader().FileReader; + const { setGlobalOrigin, getGlobalOrigin } = require_global(); + module2.exports.setGlobalOrigin = setGlobalOrigin; + module2.exports.getGlobalOrigin = getGlobalOrigin; + const { CacheStorage } = require_cachestorage(); + const { kConstruct } = require_symbols4(); + module2.exports.caches = new CacheStorage(kConstruct); + } + if (util.nodeMajor >= 16) { + const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies(); + module2.exports.deleteCookie = deleteCookie; + module2.exports.getCookies = getCookies; + module2.exports.getSetCookies = getSetCookies; + module2.exports.setCookie = setCookie; + const { parseMIMEType, serializeAMimeType } = require_dataURL(); + module2.exports.parseMIMEType = parseMIMEType; + module2.exports.serializeAMimeType = serializeAMimeType; + } + if (util.nodeMajor >= 18 && hasCrypto) { + const { WebSocket } = require_websocket(); + module2.exports.WebSocket = WebSocket; + } + module2.exports.request = makeDispatcher(api.request); + module2.exports.stream = makeDispatcher(api.stream); + module2.exports.pipeline = makeDispatcher(api.pipeline); + module2.exports.connect = makeDispatcher(api.connect); + module2.exports.upgrade = makeDispatcher(api.upgrade); + module2.exports.MockClient = MockClient; + module2.exports.MockPool = MockPool; + module2.exports.MockAgent = MockAgent; + module2.exports.mockErrors = mockErrors; + } +}); + +// node_modules/@actions/http-client/lib/index.js +var require_lib = __commonJS({ + "node_modules/@actions/http-client/lib/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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); + } } - return 0; - } - *pushTag() { - if (this.charAt(1) === '<') { - let i = this.pos + 2; - let ch = this.buffer[i]; - while (!isEmpty(ch) && ch !== '>') - ch = this.buffer[++i]; - return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false); + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } } - else { - let i = this.pos + 1; - let ch = this.buffer[i]; - while (ch) { - if (tagChars.has(ch)) - ch = this.buffer[++i]; - else if (ch === '%' && - hexDigits.has(this.buffer[i + 1]) && - hexDigits.has(this.buffer[i + 2])) { - ch = this.buffer[(i += 3)]; - } - else - break; - } - return yield* this.pushToIndex(i, false); + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - } - *pushNewline() { - const ch = this.buffer[this.pos]; - if (ch === '\n') - return yield* this.pushCount(1); - else if (ch === '\r' && this.charAt(1) === '\n') - return yield* this.pushCount(2); - else - return 0; - } - *pushSpaces(allowTabs) { - let i = this.pos - 1; - let ch; - do { - ch = this.buffer[++i]; - } while (ch === ' ' || (allowTabs && ch === '\t')); - const n = i - this.pos; - if (n > 0) { - yield this.buffer.substr(this.pos, n); - this.pos = i; + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.HttpClient = exports2.isHttps = exports2.HttpClientResponse = exports2.HttpClientError = exports2.getProxyUrl = exports2.MediaTypes = exports2.Headers = exports2.HttpCodes = void 0; + var http = __importStar(require("http")); + var https = __importStar(require("https")); + var pm = __importStar(require_proxy()); + var tunnel = __importStar(require_tunnel2()); + var undici_1 = require_undici(); + var HttpCodes; + (function(HttpCodes2) { + HttpCodes2[HttpCodes2["OK"] = 200] = "OK"; + HttpCodes2[HttpCodes2["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes2[HttpCodes2["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes2[HttpCodes2["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes2[HttpCodes2["SeeOther"] = 303] = "SeeOther"; + HttpCodes2[HttpCodes2["NotModified"] = 304] = "NotModified"; + HttpCodes2[HttpCodes2["UseProxy"] = 305] = "UseProxy"; + HttpCodes2[HttpCodes2["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes2[HttpCodes2["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes2[HttpCodes2["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes2[HttpCodes2["BadRequest"] = 400] = "BadRequest"; + HttpCodes2[HttpCodes2["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes2[HttpCodes2["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes2[HttpCodes2["Forbidden"] = 403] = "Forbidden"; + HttpCodes2[HttpCodes2["NotFound"] = 404] = "NotFound"; + HttpCodes2[HttpCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes2[HttpCodes2["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes2[HttpCodes2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes2[HttpCodes2["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes2[HttpCodes2["Conflict"] = 409] = "Conflict"; + HttpCodes2[HttpCodes2["Gone"] = 410] = "Gone"; + HttpCodes2[HttpCodes2["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes2[HttpCodes2["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes2[HttpCodes2["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes2[HttpCodes2["BadGateway"] = 502] = "BadGateway"; + HttpCodes2[HttpCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes2[HttpCodes2["GatewayTimeout"] = 504] = "GatewayTimeout"; + })(HttpCodes || (exports2.HttpCodes = HttpCodes = {})); + var Headers2; + (function(Headers3) { + Headers3["Accept"] = "accept"; + Headers3["ContentType"] = "content-type"; + })(Headers2 || (exports2.Headers = Headers2 = {})); + var MediaTypes; + (function(MediaTypes2) { + MediaTypes2["ApplicationJson"] = "application/json"; + })(MediaTypes || (exports2.MediaTypes = MediaTypes = {})); + function getProxyUrl(serverUrl) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ""; + } + exports2.getProxyUrl = getProxyUrl; + var HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect + ]; + var HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout + ]; + var RetryableHttpVerbs = ["OPTIONS", "GET", "DELETE", "HEAD"]; + var ExponentialBackoffCeiling = 10; + var ExponentialBackoffTimeSlice = 5; + var HttpClientError = class _HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = "HttpClientError"; + this.statusCode = statusCode; + Object.setPrototypeOf(this, _HttpClientError.prototype); + } + }; + exports2.HttpClientError = HttpClientError; + var HttpClientResponse = class { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + let output = Buffer.alloc(0); + this.message.on("data", (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on("end", () => { + resolve(output.toString()); + }); + })); + }); + } + readBodyBuffer() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + const chunks = []; + this.message.on("data", (chunk) => { + chunks.push(chunk); + }); + this.message.on("end", () => { + resolve(Buffer.concat(chunks)); + }); + })); + }); + } + }; + exports2.HttpClientResponse = HttpClientResponse; + function isHttps(requestUrl) { + const parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === "https:"; + } + exports2.isHttps = isHttps; + var HttpClient = class { + 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; + } } - return n; - } - *pushUntil(test) { - let i = this.pos; - let ch = this.buffer[i]; - while (!test(ch)) - ch = this.buffer[++i]; - return yield* this.pushToIndex(i, false); - } -} - -exports.Lexer = Lexer; - - -/***/ }), - -/***/ 6628: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -/** - * Tracks newlines during parsing in order to provide an efficient API for - * determining the one-indexed `{ line, col }` position for any offset - * within the input. - */ -class LineCounter { - constructor() { - this.lineStarts = []; - /** - * Should be called in ascending order. Otherwise, call - * `lineCounter.lineStarts.sort()` before calling `linePos()`. - */ - this.addNewLine = (offset) => this.lineStarts.push(offset); - /** - * Performs a binary search and returns the 1-indexed { line, col } - * position of `offset`. If `line === 0`, `addNewLine` has never been - * called or `offset` is before the first known newline. - */ - this.linePos = (offset) => { - let low = 0; - let high = this.lineStarts.length; - while (low < high) { - const mid = (low + high) >> 1; // Math.floor((low + high) / 2) - if (this.lineStarts[mid] < offset) - low = mid + 1; - else - high = mid; + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("OPTIONS", requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("GET", requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("DELETE", requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("POST", requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PATCH", requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PUT", requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("HEAD", requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request(verb, requestUrl, stream, additionalHeaders); + }); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + getJson(requestUrl, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error("Client has already been disposed."); + } + const parsedUrl = new URL(requestUrl); + let info2 = this._prepareRequest(verb, parsedUrl, headers); + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info2, data); + if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) { + if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info2, data); + } else { + return response; + } } - if (this.lineStarts[low] === offset) - return { line: low + 1, col: 1 }; - if (low === 0) - return { line: 0, col: offset }; - const start = this.lineStarts[low - 1]; - return { line: low, col: offset - start + 1 }; - }; - } -} - -exports.LineCounter = LineCounter; - - -/***/ }), - -/***/ 3456: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var node_process = __nccwpck_require__(932); -var cst = __nccwpck_require__(3461); -var lexer = __nccwpck_require__(361); - -function includesToken(list, type) { - for (let i = 0; i < list.length; ++i) - if (list[i].type === type) - return true; - return false; -} -function findNonEmptyIndex(list) { - for (let i = 0; i < list.length; ++i) { - switch (list[i].type) { - case 'space': - case 'comment': - case 'newline': + let redirectsRemaining = this._maxRedirects; + while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) { + const redirectUrl = response.message.headers["location"]; + if (!redirectUrl) { break; - default: - return i; - } - } - return -1; -} -function isFlowToken(token) { - switch (token?.type) { - case 'alias': - case 'scalar': - case 'single-quoted-scalar': - case 'double-quoted-scalar': - case 'flow-collection': - return true; - default: - return false; - } -} -function getPrevProps(parent) { - switch (parent.type) { - case 'document': - return parent.start; - case 'block-map': { - const it = parent.items[parent.items.length - 1]; - return it.sep ?? it.start; - } - case 'block-seq': - return parent.items[parent.items.length - 1].start; - /* istanbul ignore next should not happen */ - default: - return []; - } -} -/** Note: May modify input array */ -function getFirstKeyStartProps(prev) { - if (prev.length === 0) - return []; - let i = prev.length; - loop: while (--i >= 0) { - switch (prev[i].type) { - case 'doc-start': - case 'explicit-key-ind': - case 'map-value-ind': - case 'seq-item-ind': - case 'newline': - break loop; - } - } - while (prev[++i]?.type === 'space') { - /* loop */ - } - return prev.splice(i, prev.length); -} -function fixFlowSeqItems(fc) { - if (fc.start.type === 'flow-seq-start') { - for (const it of fc.items) { - if (it.sep && - !it.value && - !includesToken(it.start, 'explicit-key-ind') && - !includesToken(it.sep, 'map-value-ind')) { - if (it.key) - it.value = it.key; - delete it.key; - if (isFlowToken(it.value)) { - if (it.value.end) - Array.prototype.push.apply(it.value.end, it.sep); - else - it.value.end = it.sep; + } + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) { + throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true."); + } + yield response.readBody(); + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) { + if (header.toLowerCase() === "authorization") { + delete headers[header]; + } } - else - Array.prototype.push.apply(it.start, it.sep); - delete it.sep; + } + info2 = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info2, data); + redirectsRemaining--; + } + if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) { + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info2, data) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) { + reject(err); + } else if (!res) { + reject(new Error("Unknown error")); + } else { + resolve(res); + } } + this.requestRawWithCallback(info2, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info2, data, onResult) { + if (typeof data === "string") { + if (!info2.options.headers) { + info2.options.headers = {}; + } + info2.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8"); } - } -} -/** - * A YAML concrete syntax tree (CST) parser - * - * ```ts - * const src: string = ... - * for (const token of new Parser().parse(src)) { - * // token: Token - * } - * ``` - * - * To use the parser with a user-provided lexer: - * - * ```ts - * function* parse(source: string, lexer: Lexer) { - * const parser = new Parser() - * for (const lexeme of lexer.lex(source)) - * yield* parser.next(lexeme) - * yield* parser.end() - * } - * - * const src: string = ... - * const lexer = new Lexer() - * for (const token of parse(src, lexer)) { - * // token: Token - * } - * ``` - */ -class Parser { - /** - * @param onNewLine - If defined, called separately with the start position of - * each new line (in `parse()`, including the start of input). - */ - constructor(onNewLine) { - /** If true, space and sequence indicators count as indentation */ - this.atNewLine = true; - /** If true, next token is a scalar value */ - this.atScalar = false; - /** Current indentation level */ - this.indent = 0; - /** Current offset since the start of parsing */ - this.offset = 0; - /** On the same line with a block map key */ - this.onKeyLine = false; - /** Top indicates the node that's currently being built */ - this.stack = []; - /** The source of the current token, set in parse() */ - this.source = ''; - /** The type of the current token, set in parse() */ - this.type = ''; - // Must be defined after `next()` - this.lexer = new lexer.Lexer(); - this.onNewLine = onNewLine; - } - /** - * Parse `source` as a YAML stream. - * If `incomplete`, a part of the last line may be left as a buffer for the next call. - * - * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens. - * - * @returns A generator of tokens representing each directive, document, and other structure. - */ - *parse(source, incomplete = false) { - if (this.onNewLine && this.offset === 0) - this.onNewLine(0); - for (const lexeme of this.lexer.lex(source, incomplete)) - yield* this.next(lexeme); - if (!incomplete) - yield* this.end(); - } - /** - * Advance the parser by the `source` of one lexical token. - */ - *next(source) { - this.source = source; - if (node_process.env.LOG_TOKENS) - console.log('|', cst.prettyToken(source)); - if (this.atScalar) { - this.atScalar = false; - yield* this.step(); - this.offset += source.length; - return; + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } } - const type = cst.tokenType(source); - if (!type) { - const message = `Not a YAML token: ${source}`; - yield* this.pop({ type: 'error', offset: this.offset, message, source }); - this.offset += source.length; + const req = info2.httpModule.request(info2.options, (msg) => { + const res = new HttpClientResponse(msg); + handleResult(void 0, res); + }); + let socket; + req.on("socket", (sock) => { + socket = sock; + }); + req.setTimeout(this._socketTimeout || 3 * 6e4, () => { + if (socket) { + socket.end(); + } + handleResult(new Error(`Request timeout: ${info2.options.path}`)); + }); + req.on("error", function(err) { + handleResult(err); + }); + if (data && typeof data === "string") { + req.write(data, "utf8"); } - else if (type === 'scalar') { - this.atNewLine = false; - this.atScalar = true; - this.type = 'scalar'; + if (data && typeof data !== "string") { + data.on("close", function() { + req.end(); + }); + data.pipe(req); + } else { + req.end(); } - else { - this.type = type; - yield* this.step(); - switch (type) { - case 'newline': - this.atNewLine = true; - this.indent = 0; - if (this.onNewLine) - this.onNewLine(this.offset + source.length); - break; - case 'space': - if (this.atNewLine && source[0] === ' ') - this.indent += source.length; - break; - case 'explicit-key-ind': - case 'map-value-ind': - case 'seq-item-ind': - if (this.atNewLine) - this.indent += source.length; - break; - case 'doc-mode': - case 'flow-error-end': - return; - default: - this.atNewLine = false; - } - this.offset += source.length; + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + getAgentDispatcher(serverUrl) { + const parsedUrl = new URL(serverUrl); + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (!useProxy) { + return; } - } - /** Call at end of input to push out any remaining constructions */ - *end() { - while (this.stack.length > 0) - yield* this.pop(); - } - get sourceToken() { - const st = { - type: this.type, - offset: this.offset, - indent: this.indent, - source: this.source - }; - return st; - } - *step() { - const top = this.peek(1); - if (this.type === 'doc-end' && (!top || top.type !== 'doc-end')) { - while (this.stack.length > 0) - yield* this.pop(); - this.stack.push({ - type: 'doc-end', - offset: this.offset, - source: this.source - }); - return; + return this._getProxyAgentDispatcher(parsedUrl, proxyUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info2 = {}; + info2.parsedUrl = requestUrl; + const usingSsl = info2.parsedUrl.protocol === "https:"; + info2.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info2.options = {}; + info2.options.host = info2.parsedUrl.hostname; + info2.options.port = info2.parsedUrl.port ? parseInt(info2.parsedUrl.port) : defaultPort; + info2.options.path = (info2.parsedUrl.pathname || "") + (info2.parsedUrl.search || ""); + info2.options.method = method; + info2.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info2.options.headers["user-agent"] = this.userAgent; } - if (!top) - return yield* this.stream(); - switch (top.type) { - case 'document': - return yield* this.document(top); - case 'alias': - case 'scalar': - case 'single-quoted-scalar': - case 'double-quoted-scalar': - return yield* this.scalar(top); - case 'block-scalar': - return yield* this.blockScalar(top); - case 'block-map': - return yield* this.blockMap(top); - case 'block-seq': - return yield* this.blockSequence(top); - case 'flow-collection': - return yield* this.flowCollection(top); - case 'doc-end': - return yield* this.documentEnd(top); + info2.options.agent = this._getAgent(info2.parsedUrl); + if (this.handlers) { + for (const handler of this.handlers) { + handler.prepareRequest(info2.options); + } } - /* istanbul ignore next should not happen */ - yield* this.pop(); - } - peek(n) { - return this.stack[this.stack.length - n]; - } - *pop(error) { - const token = error ?? this.stack.pop(); - /* istanbul ignore if should not happen */ - if (!token) { - const message = 'Tried to pop an empty stack'; - yield { type: 'error', offset: this.offset, source: '', message }; + return info2; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); } - else if (this.stack.length === 0) { - yield token; + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; } - else { - const top = this.peek(1); - if (token.type === 'block-scalar') { - // Block scalars use their parent rather than header indent - token.indent = 'indent' in top ? top.indent : 0; - } - else if (token.type === 'flow-collection' && top.type === 'document') { - // Ignore all indent for top-level flow collections - token.indent = 0; - } - if (token.type === 'flow-collection') - fixFlowSeqItems(token); - switch (top.type) { - case 'document': - top.value = token; - break; - case 'block-scalar': - top.props.push(token); // error - break; - case 'block-map': { - const it = top.items[top.items.length - 1]; - if (it.value) { - top.items.push({ start: [], key: token, sep: [] }); - this.onKeyLine = true; - return; - } - else if (it.sep) { - it.value = token; - } - else { - Object.assign(it, { key: token, sep: [] }); - this.onKeyLine = !it.explicitKey; - return; - } - break; - } - case 'block-seq': { - const it = top.items[top.items.length - 1]; - if (it.value) - top.items.push({ start: [], value: token }); - else - it.value = token; - break; - } - case 'flow-collection': { - const it = top.items[top.items.length - 1]; - if (!it || it.value) - top.items.push({ start: [], key: token, sep: [] }); - else if (it.sep) - it.value = token; - else - Object.assign(it, { key: token, sep: [] }); - return; - } - /* istanbul ignore next should not happen */ - default: - yield* this.pop(); - yield* this.pop(token); - } - if ((top.type === 'document' || - top.type === 'block-map' || - top.type === 'block-seq') && - (token.type === 'block-map' || token.type === 'block-seq')) { - const last = token.items[token.items.length - 1]; - if (last && - !last.sep && - !last.value && - last.start.length > 0 && - findNonEmptyIndex(last.start) === -1 && - (token.indent === 0 || - last.start.every(st => st.type !== 'comment' || st.indent < token.indent))) { - if (top.type === 'document') - top.end = last.start; - else - top.items.push({ start: last.start }); - token.items.splice(-1, 1); - } - } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; } - } - *stream() { - switch (this.type) { - case 'directive-line': - yield { type: 'directive', offset: this.offset, source: this.source }; - return; - case 'byte-order-mark': - case 'space': - case 'comment': - case 'newline': - yield this.sourceToken; - return; - case 'doc-mode': - case 'doc-start': { - const doc = { - type: 'document', - offset: this.offset, - start: [] - }; - if (this.type === 'doc-start') - doc.start.push(this.sourceToken); - this.stack.push(doc); - return; - } + if (!useProxy) { + agent = this._agent; } - yield { - type: 'error', - offset: this.offset, - message: `Unexpected ${this.type} token in YAML stream`, - source: this.source - }; - } - *document(doc) { - if (doc.value) - return yield* this.lineEnd(doc); - switch (this.type) { - case 'doc-start': { - if (findNonEmptyIndex(doc.start) !== -1) { - yield* this.pop(); - yield* this.step(); - } - else - doc.start.push(this.sourceToken); - return; - } - case 'anchor': - case 'tag': - case 'space': - case 'comment': - case 'newline': - doc.start.push(this.sourceToken); - return; + if (agent) { + return agent; } - const bv = this.startBlockValue(doc); - if (bv) - this.stack.push(bv); - else { - yield { - type: 'error', - offset: this.offset, - message: `Unexpected ${this.type} token in YAML document`, - source: this.source - }; + const usingSsl = parsedUrl.protocol === "https:"; + let maxSockets = 100; + if (this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; } - } - *scalar(scalar) { - if (this.type === 'map-value-ind') { - const prev = getPrevProps(this.peek(2)); - const start = getFirstKeyStartProps(prev); - let sep; - if (scalar.end) { - sep = scalar.end; - sep.push(this.sourceToken); - delete scalar.end; - } - else - sep = [this.sourceToken]; - const map = { - type: 'block-map', - offset: scalar.offset, - indent: scalar.indent, - items: [{ start, key: scalar, sep }] - }; - this.onKeyLine = true; - this.stack[this.stack.length - 1] = map; + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + }), { host: proxyUrl.hostname, port: proxyUrl.port }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === "https:"; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; } - else - yield* this.lineEnd(scalar); - } - *blockScalar(scalar) { - switch (this.type) { - case 'space': - case 'comment': - case 'newline': - scalar.props.push(this.sourceToken); - return; - case 'scalar': - scalar.source = this.source; - // block-scalar source includes trailing newline - this.atNewLine = true; - this.indent = 0; - if (this.onNewLine) { - let nl = this.source.indexOf('\n') + 1; - while (nl !== 0) { - this.onNewLine(this.offset + nl); - nl = this.source.indexOf('\n', nl) + 1; - } - } - yield* this.pop(); - break; - /* istanbul ignore next should not happen */ - default: - yield* this.pop(); - yield* this.step(); + if (!agent) { + const options = { keepAlive: this._keepAlive, maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; } - } - *blockMap(map) { - const it = map.items[map.items.length - 1]; - // it.sep is true-ish if pair already has key or : separator - switch (this.type) { - case 'newline': - this.onKeyLine = false; - if (it.value) { - const end = 'end' in it.value ? it.value.end : undefined; - const last = Array.isArray(end) ? end[end.length - 1] : undefined; - if (last?.type === 'comment') - end?.push(this.sourceToken); - else - map.items.push({ start: [this.sourceToken] }); - } - else if (it.sep) { - it.sep.push(this.sourceToken); - } - else { - it.start.push(this.sourceToken); - } - return; - case 'space': - case 'comment': - if (it.value) { - map.items.push({ start: [this.sourceToken] }); - } - else if (it.sep) { - it.sep.push(this.sourceToken); - } - else { - if (this.atIndentedComment(it.start, map.indent)) { - const prev = map.items[map.items.length - 2]; - const end = prev?.value?.end; - if (Array.isArray(end)) { - Array.prototype.push.apply(end, it.start); - end.push(this.sourceToken); - map.items.pop(); - return; - } - } - it.start.push(this.sourceToken); - } - return; + if (usingSsl && this._ignoreSslError) { + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); } - if (this.indent >= map.indent) { - const atMapIndent = !this.onKeyLine && this.indent === map.indent; - const atNextItem = atMapIndent && - (it.sep || it.explicitKey) && - this.type !== 'seq-item-ind'; - // For empty nodes, assign newline-separated not indented empty tokens to following node - let start = []; - if (atNextItem && it.sep && !it.value) { - const nl = []; - for (let i = 0; i < it.sep.length; ++i) { - const st = it.sep[i]; - switch (st.type) { - case 'newline': - nl.push(i); - break; - case 'space': - break; - case 'comment': - if (st.indent > map.indent) - nl.length = 0; - break; - default: - nl.length = 0; - } - } - if (nl.length >= 2) - start = it.sep.splice(nl[1]); - } - switch (this.type) { - case 'anchor': - case 'tag': - if (atNextItem || it.value) { - start.push(this.sourceToken); - map.items.push({ start }); - this.onKeyLine = true; - } - else if (it.sep) { - it.sep.push(this.sourceToken); - } - else { - it.start.push(this.sourceToken); - } - return; - case 'explicit-key-ind': - if (!it.sep && !it.explicitKey) { - it.start.push(this.sourceToken); - it.explicitKey = true; - } - else if (atNextItem || it.value) { - start.push(this.sourceToken); - map.items.push({ start, explicitKey: true }); - } - else { - this.stack.push({ - type: 'block-map', - offset: this.offset, - indent: this.indent, - items: [{ start: [this.sourceToken], explicitKey: true }] - }); - } - this.onKeyLine = true; - return; - case 'map-value-ind': - if (it.explicitKey) { - if (!it.sep) { - if (includesToken(it.start, 'newline')) { - Object.assign(it, { key: null, sep: [this.sourceToken] }); - } - else { - const start = getFirstKeyStartProps(it.start); - this.stack.push({ - type: 'block-map', - offset: this.offset, - indent: this.indent, - items: [{ start, key: null, sep: [this.sourceToken] }] - }); - } - } - else if (it.value) { - map.items.push({ start: [], key: null, sep: [this.sourceToken] }); - } - else if (includesToken(it.sep, 'map-value-ind')) { - this.stack.push({ - type: 'block-map', - offset: this.offset, - indent: this.indent, - items: [{ start, key: null, sep: [this.sourceToken] }] - }); - } - else if (isFlowToken(it.key) && - !includesToken(it.sep, 'newline')) { - const start = getFirstKeyStartProps(it.start); - const key = it.key; - const sep = it.sep; - sep.push(this.sourceToken); - // @ts-expect-error type guard is wrong here - delete it.key; - // @ts-expect-error type guard is wrong here - delete it.sep; - this.stack.push({ - type: 'block-map', - offset: this.offset, - indent: this.indent, - items: [{ start, key, sep }] - }); - } - else if (start.length > 0) { - // Not actually at next item - it.sep = it.sep.concat(start, this.sourceToken); - } - else { - it.sep.push(this.sourceToken); - } - } - else { - if (!it.sep) { - Object.assign(it, { key: null, sep: [this.sourceToken] }); - } - else if (it.value || atNextItem) { - map.items.push({ start, key: null, sep: [this.sourceToken] }); - } - else if (includesToken(it.sep, 'map-value-ind')) { - this.stack.push({ - type: 'block-map', - offset: this.offset, - indent: this.indent, - items: [{ start: [], key: null, sep: [this.sourceToken] }] - }); - } - else { - it.sep.push(this.sourceToken); - } - } - this.onKeyLine = true; - return; - case 'alias': - case 'scalar': - case 'single-quoted-scalar': - case 'double-quoted-scalar': { - const fs = this.flowScalar(this.type); - if (atNextItem || it.value) { - map.items.push({ start, key: fs, sep: [] }); - this.onKeyLine = true; - } - else if (it.sep) { - this.stack.push(fs); - } - else { - Object.assign(it, { key: fs, sep: [] }); - this.onKeyLine = true; - } - return; - } - default: { - const bv = this.startBlockValue(map); - if (bv) { - if (bv.type === 'block-seq') { - if (!it.explicitKey && - it.sep && - !includesToken(it.sep, 'newline')) { - yield* this.pop({ - type: 'error', - offset: this.offset, - message: 'Unexpected block-seq-ind on same line with key', - source: this.source - }); - return; - } - } - else if (atMapIndent) { - map.items.push({ start }); - } - this.stack.push(bv); - return; - } - } - } + return agent; + } + _getProxyAgentDispatcher(parsedUrl, proxyUrl) { + let proxyAgent; + if (this._keepAlive) { + proxyAgent = this._proxyAgentDispatcher; } - yield* this.pop(); - yield* this.step(); - } - *blockSequence(seq) { - const it = seq.items[seq.items.length - 1]; - switch (this.type) { - case 'newline': - if (it.value) { - const end = 'end' in it.value ? it.value.end : undefined; - const last = Array.isArray(end) ? end[end.length - 1] : undefined; - if (last?.type === 'comment') - end?.push(this.sourceToken); - else - seq.items.push({ start: [this.sourceToken] }); - } - else - it.start.push(this.sourceToken); - return; - case 'space': - case 'comment': - if (it.value) - seq.items.push({ start: [this.sourceToken] }); - else { - if (this.atIndentedComment(it.start, seq.indent)) { - const prev = seq.items[seq.items.length - 2]; - const end = prev?.value?.end; - if (Array.isArray(end)) { - Array.prototype.push.apply(end, it.start); - end.push(this.sourceToken); - seq.items.pop(); - return; - } - } - it.start.push(this.sourceToken); - } - return; - case 'anchor': - case 'tag': - if (it.value || this.indent <= seq.indent) - break; - it.start.push(this.sourceToken); - return; - case 'seq-item-ind': - if (this.indent !== seq.indent) - break; - if (it.value || includesToken(it.start, 'seq-item-ind')) - seq.items.push({ start: [this.sourceToken] }); - else - it.start.push(this.sourceToken); - return; + if (proxyAgent) { + return proxyAgent; } - if (this.indent > seq.indent) { - const bv = this.startBlockValue(seq); - if (bv) { - this.stack.push(bv); - return; - } + const usingSsl = parsedUrl.protocol === "https:"; + proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, (proxyUrl.username || proxyUrl.password) && { + token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}` + })); + this._proxyAgentDispatcher = proxyAgent; + if (usingSsl && this._ignoreSslError) { + proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { + rejectUnauthorized: false + }); } - yield* this.pop(); - yield* this.step(); - } - *flowCollection(fc) { - const it = fc.items[fc.items.length - 1]; - if (this.type === 'flow-error-end') { - let top; - do { - yield* this.pop(); - top = this.peek(1); - } while (top && top.type === 'flow-collection'); - } - else if (fc.end.length === 0) { - switch (this.type) { - case 'comma': - case 'explicit-key-ind': - if (!it || it.sep) - fc.items.push({ start: [this.sourceToken] }); - else - it.start.push(this.sourceToken); - return; - case 'map-value-ind': - if (!it || it.value) - fc.items.push({ start: [], key: null, sep: [this.sourceToken] }); - else if (it.sep) - it.sep.push(this.sourceToken); - else - Object.assign(it, { key: null, sep: [this.sourceToken] }); - return; - case 'space': - case 'comment': - case 'newline': - case 'anchor': - case 'tag': - if (!it || it.value) - fc.items.push({ start: [this.sourceToken] }); - else if (it.sep) - it.sep.push(this.sourceToken); - else - it.start.push(this.sourceToken); - return; - case 'alias': - case 'scalar': - case 'single-quoted-scalar': - case 'double-quoted-scalar': { - const fs = this.flowScalar(this.type); - if (!it || it.value) - fc.items.push({ start: [], key: fs, sep: [] }); - else if (it.sep) - this.stack.push(fs); - else - Object.assign(it, { key: fs, sep: [] }); - return; - } - case 'flow-map-end': - case 'flow-seq-end': - fc.end.push(this.sourceToken); - return; - } - const bv = this.startBlockValue(fc); - /* istanbul ignore else should not happen */ - if (bv) - this.stack.push(bv); - else { - yield* this.pop(); - yield* this.step(); + return proxyAgent; + } + _performExponentialBackoff(retryNumber) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise((resolve) => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + if (statusCode === HttpCodes.NotFound) { + resolve(response); } - } - else { - const parent = this.peek(2); - if (parent.type === 'block-map' && - ((this.type === 'map-value-ind' && parent.indent === fc.indent) || - (this.type === 'newline' && - !parent.items[parent.items.length - 1].sep))) { - yield* this.pop(); - yield* this.step(); + function dateTimeDeserializer(key, value) { + if (typeof value === "string") { + const a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; } - else if (this.type === 'map-value-ind' && - parent.type !== 'flow-collection') { - const prev = getPrevProps(parent); - const start = getFirstKeyStartProps(prev); - fixFlowSeqItems(fc); - const sep = fc.end.splice(1, fc.end.length); - sep.push(this.sourceToken); - const map = { - type: 'block-map', - offset: fc.offset, - indent: fc.indent, - items: [{ start, key: fc, sep }] - }; - this.onKeyLine = true; - this.stack[this.stack.length - 1] = map; + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, dateTimeDeserializer); + } else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } catch (err) { } - else { - yield* this.lineEnd(fc); + if (statusCode > 299) { + let msg; + if (obj && obj.message) { + msg = obj.message; + } else if (contents && contents.length > 0) { + msg = contents; + } else { + msg = `Failed request: (${statusCode})`; + } + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } else { + resolve(response); } + })); + }); + } + }; + exports2.HttpClient = HttpClient; + var lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); + } +}); + +// node_modules/@actions/http-client/lib/auth.js +var require_auth = __commonJS({ + "node_modules/@actions/http-client/lib/auth.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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); + } } - } - flowScalar(type) { - if (this.onNewLine) { - let nl = this.source.indexOf('\n') + 1; - while (nl !== 0) { - this.onNewLine(this.offset + nl); - nl = this.source.indexOf('\n', nl) + 1; - } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } } - return { - type, - offset: this.offset, - indent: this.indent, - source: this.source - }; - } - startBlockValue(parent) { - switch (this.type) { - case 'alias': - case 'scalar': - case 'single-quoted-scalar': - case 'double-quoted-scalar': - return this.flowScalar(this.type); - case 'block-scalar-header': - return { - type: 'block-scalar', - offset: this.offset, - indent: this.indent, - props: [this.sourceToken], - source: '' - }; - case 'flow-map-start': - case 'flow-seq-start': - return { - type: 'flow-collection', - offset: this.offset, - indent: this.indent, - start: this.sourceToken, - items: [], - end: [] - }; - case 'seq-item-ind': - return { - type: 'block-seq', - offset: this.offset, - indent: this.indent, - items: [{ start: [this.sourceToken] }] - }; - case 'explicit-key-ind': { - this.onKeyLine = true; - const prev = getPrevProps(parent); - const start = getFirstKeyStartProps(prev); - start.push(this.sourceToken); - return { - type: 'block-map', - offset: this.offset, - indent: this.indent, - items: [{ start, explicitKey: true }] - }; - } - case 'map-value-ind': { - this.onKeyLine = true; - const prev = getPrevProps(parent); - const start = getFirstKeyStartProps(prev); - return { - type: 'block-map', - offset: this.offset, - indent: this.indent, - items: [{ start, key: null, sep: [this.sourceToken] }] - }; - } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - return null; - } - atIndentedComment(start, indent) { - if (this.type !== 'comment') - return false; - if (this.indent <= indent) - return false; - return start.every(st => st.type === 'newline' || st.type === 'space'); - } - *documentEnd(docEnd) { - if (this.type !== 'doc-mode') { - if (docEnd.end) - docEnd.end.push(this.sourceToken); - else - docEnd.end = [this.sourceToken]; - if (this.type === 'newline') - yield* this.pop(); + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.PersonalAccessTokenCredentialHandler = exports2.BearerCredentialHandler = exports2.BasicCredentialHandler = void 0; + var BasicCredentialHandler = class { + constructor(username, password) { + this.username = username; + this.password = password; + } + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); } - } - *lineEnd(token) { - switch (this.type) { - case 'comma': - case 'doc-start': - case 'doc-end': - case 'flow-seq-end': - case 'flow-map-end': - case 'map-value-ind': - yield* this.pop(); - yield* this.step(); - break; - case 'newline': - this.onKeyLine = false; - // fallthrough - case 'space': - case 'comment': - default: - // all other values are errors - if (token.end) - token.end.push(this.sourceToken); - else - token.end = [this.sourceToken]; - if (this.type === 'newline') - yield* this.pop(); + options.headers["Authorization"] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BasicCredentialHandler = BasicCredentialHandler; + var BearerCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); } - } -} - -exports.Parser = Parser; - - -/***/ }), - -/***/ 4047: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - + options.headers["Authorization"] = `Bearer ${this.token}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BearerCredentialHandler = BearerCredentialHandler; + var PersonalAccessTokenCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Basic ${Buffer.from(`PAT:${this.token}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; + } +}); -var composer = __nccwpck_require__(9984); -var Document = __nccwpck_require__(3021); -var errors = __nccwpck_require__(1464); -var log = __nccwpck_require__(7249); -var identity = __nccwpck_require__(1127); -var lineCounter = __nccwpck_require__(6628); -var parser = __nccwpck_require__(3456); +// node_modules/@actions/core/lib/oidc-utils.js +var require_oidc_utils = __commonJS({ + "node_modules/@actions/core/lib/oidc-utils.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.OidcClient = void 0; + var http_client_1 = require_lib(); + var auth_1 = require_auth(); + var core_1 = require_core(); + var OidcClient = class _OidcClient { + static createHttpClient(allowRetry = true, maxRetry = 10) { + const requestOptions = { + allowRetries: allowRetry, + maxRetries: maxRetry + }; + return new http_client_1.HttpClient("actions/oidc-client", [new auth_1.BearerCredentialHandler(_OidcClient.getRequestToken())], requestOptions); + } + static getRequestToken() { + const token = process.env["ACTIONS_ID_TOKEN_REQUEST_TOKEN"]; + if (!token) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable"); + } + return token; + } + static getIDTokenUrl() { + const runtimeUrl = process.env["ACTIONS_ID_TOKEN_REQUEST_URL"]; + if (!runtimeUrl) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable"); + } + return runtimeUrl; + } + static getCall(id_token_url) { + var _a2; + return __awaiter(this, void 0, void 0, function* () { + const httpclient = _OidcClient.createHttpClient(); + const res = yield httpclient.getJson(id_token_url).catch((error2) => { + throw new Error(`Failed to get ID Token. + + Error Code : ${error2.statusCode} + + Error Message: ${error2.message}`); + }); + const id_token = (_a2 = res.result) === null || _a2 === void 0 ? void 0 : _a2.value; + if (!id_token) { + throw new Error("Response json body do not have ID Token field"); + } + return id_token; + }); + } + static getIDToken(audience) { + return __awaiter(this, void 0, void 0, function* () { + try { + let id_token_url = _OidcClient.getIDTokenUrl(); + if (audience) { + const encodedAudience = encodeURIComponent(audience); + id_token_url = `${id_token_url}&audience=${encodedAudience}`; + } + (0, core_1.debug)(`ID token url is ${id_token_url}`); + const id_token = yield _OidcClient.getCall(id_token_url); + (0, core_1.setSecret)(id_token); + return id_token; + } catch (error2) { + throw new Error(`Error message: ${error2.message}`); + } + }); + } + }; + exports2.OidcClient = OidcClient; + } +}); -function parseOptions(options) { - const prettyErrors = options.prettyErrors !== false; - const lineCounter$1 = options.lineCounter || (prettyErrors && new lineCounter.LineCounter()) || null; - return { lineCounter: lineCounter$1, prettyErrors }; -} -/** - * Parse the input as a stream of YAML documents. - * - * Documents should be separated from each other by `...` or `---` marker lines. - * - * @returns If an empty `docs` array is returned, it will be of type - * EmptyStream and contain additional stream information. In - * TypeScript, you should use `'empty' in docs` as a type guard for it. - */ -function parseAllDocuments(source, options = {}) { - const { lineCounter, prettyErrors } = parseOptions(options); - const parser$1 = new parser.Parser(lineCounter?.addNewLine); - const composer$1 = new composer.Composer(options); - const docs = Array.from(composer$1.compose(parser$1.parse(source))); - if (prettyErrors && lineCounter) - for (const doc of docs) { - doc.errors.forEach(errors.prettifyError(source, lineCounter)); - doc.warnings.forEach(errors.prettifyError(source, lineCounter)); +// node_modules/@actions/core/lib/summary.js +var require_summary = __commonJS({ + "node_modules/@actions/core/lib/summary.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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); + } } - if (docs.length > 0) - return docs; - return Object.assign([], { empty: true }, composer$1.streamInfo()); -} -/** Parse an input string into a single YAML.Document */ -function parseDocument(source, options = {}) { - const { lineCounter, prettyErrors } = parseOptions(options); - const parser$1 = new parser.Parser(lineCounter?.addNewLine); - const composer$1 = new composer.Composer(options); - // `doc` is always set by compose.end(true) at the very latest - let doc = null; - for (const _doc of composer$1.compose(parser$1.parse(source), true, source.length)) { - if (!doc) - doc = _doc; - else if (doc.options.logLevel !== 'silent') { - doc.errors.push(new errors.YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()')); - break; + 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(exports2, "__esModule", { value: true }); + exports2.summary = exports2.markdownSummary = exports2.SUMMARY_DOCS_URL = exports2.SUMMARY_ENV_VAR = void 0; + var os_1 = require("os"); + var fs_1 = require("fs"); + var { access, appendFile, writeFile } = fs_1.promises; + exports2.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY"; + exports2.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary"; + var Summary = class { + constructor() { + this._buffer = ""; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[exports2.SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${exports2.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); + } catch (_a2) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join(""); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance + */ + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: "utf8" }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ""; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(os_1.EOL); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, lang && { lang }); + const element = this.wrap("pre", this.wrap("code", code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? "ol" : "ul"; + const listItems = items.map((item) => this.wrap("li", item)).join(""); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows.map((row) => { + const cells = row.map((cell) => { + if (typeof cell === "string") { + return this.wrap("td", cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? "th" : "td"; + const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan }); + return this.wrap(tag, data, attrs); + }).join(""); + return this.wrap("tr", cells); + }).join(""); + const element = this.wrap("table", tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap("details", this.wrap("summary", label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, width && { width }), height && { height }); + const element = this.wrap("img", null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) ? tag : "h1"; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap("hr", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap("br", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, cite && { cite }); + const element = this.wrap("blockquote", text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap("a", text, { href }); + return this.addRaw(element).addEOL(); + } + }; + var _summary = new Summary(); + exports2.markdownSummary = _summary; + exports2.summary = _summary; + } +}); + +// node_modules/@actions/core/lib/path-utils.js +var require_path_utils = __commonJS({ + "node_modules/@actions/core/lib/path-utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = void 0; + var path2 = __importStar(require("path")); + function toPosixPath(pth) { + return pth.replace(/[\\]/g, "/"); } - if (prettyErrors && lineCounter) { - doc.errors.forEach(errors.prettifyError(source, lineCounter)); - doc.warnings.forEach(errors.prettifyError(source, lineCounter)); - } - return doc; -} -function parse(src, reviver, options) { - let _reviver = undefined; - if (typeof reviver === 'function') { - _reviver = reviver; + exports2.toPosixPath = toPosixPath; + function toWin32Path(pth) { + return pth.replace(/[/]/g, "\\"); } - else if (options === undefined && reviver && typeof reviver === 'object') { - options = reviver; + exports2.toWin32Path = toWin32Path; + function toPlatformPath(pth) { + return pth.replace(/[/\\]/g, path2.sep); } - const doc = parseDocument(src, options); - if (!doc) - return null; - doc.warnings.forEach(warning => log.warn(doc.options.logLevel, warning)); - if (doc.errors.length > 0) { - if (doc.options.logLevel !== 'silent') - throw doc.errors[0]; - else - doc.errors = []; + exports2.toPlatformPath = toPlatformPath; + } +}); + +// node_modules/@actions/io/lib/io-util.js +var require_io_util = __commonJS({ + "node_modules/@actions/io/lib/io-util.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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 _a2; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getCmdPath = exports2.tryGetExecutablePath = exports2.isRooted = exports2.isDirectory = exports2.exists = exports2.READONLY = exports2.UV_FS_O_EXLOCK = exports2.IS_WINDOWS = exports2.unlink = exports2.symlink = exports2.stat = exports2.rmdir = exports2.rm = exports2.rename = exports2.readlink = exports2.readdir = exports2.open = exports2.mkdir = exports2.lstat = exports2.copyFile = exports2.chmod = void 0; + var fs = __importStar(require("fs")); + var path2 = __importStar(require("path")); + _a2 = fs.promises, exports2.chmod = _a2.chmod, exports2.copyFile = _a2.copyFile, exports2.lstat = _a2.lstat, exports2.mkdir = _a2.mkdir, exports2.open = _a2.open, exports2.readdir = _a2.readdir, exports2.readlink = _a2.readlink, exports2.rename = _a2.rename, exports2.rm = _a2.rm, exports2.rmdir = _a2.rmdir, exports2.stat = _a2.stat, exports2.symlink = _a2.symlink, exports2.unlink = _a2.unlink; + exports2.IS_WINDOWS = process.platform === "win32"; + exports2.UV_FS_O_EXLOCK = 268435456; + exports2.READONLY = fs.constants.O_RDONLY; + function exists(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + try { + yield exports2.stat(fsPath); + } catch (err) { + if (err.code === "ENOENT") { + return false; + } + throw err; + } + return true; + }); } - return doc.toJS(Object.assign({ reviver: _reviver }, options)); -} -function stringify(value, replacer, options) { - let _replacer = null; - if (typeof replacer === 'function' || Array.isArray(replacer)) { - _replacer = replacer; + exports2.exists = exists; + function isDirectory(fsPath, useStat = false) { + return __awaiter(this, void 0, void 0, function* () { + const stats = useStat ? yield exports2.stat(fsPath) : yield exports2.lstat(fsPath); + return stats.isDirectory(); + }); } - else if (options === undefined && replacer) { - options = replacer; + exports2.isDirectory = isDirectory; + function isRooted(p) { + p = normalizeSeparators(p); + if (!p) { + throw new Error('isRooted() parameter "p" cannot be empty'); + } + if (exports2.IS_WINDOWS) { + return p.startsWith("\\") || /^[A-Z]:/i.test(p); + } + return p.startsWith("/"); } - if (typeof options === 'string') - options = options.length; - if (typeof options === 'number') { - const indent = Math.round(options); - options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent }; + exports2.isRooted = isRooted; + function tryGetExecutablePath(filePath, extensions) { + return __awaiter(this, void 0, void 0, function* () { + let stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + const upperExt = path2.extname(filePath).toUpperCase(); + if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) { + return filePath; + } + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + const originalFilePath = filePath; + for (const extension of extensions) { + filePath = originalFilePath + extension; + stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + try { + const directory = path2.dirname(filePath); + const upperName = path2.basename(filePath).toUpperCase(); + for (const actualName of yield exports2.readdir(directory)) { + if (upperName === actualName.toUpperCase()) { + filePath = path2.join(directory, actualName); + break; + } + } + } catch (err) { + console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); + } + return filePath; + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + } + return ""; + }); } - if (value === undefined) { - const { keepUndefined } = options ?? replacer ?? {}; - if (!keepUndefined) - return undefined; + exports2.tryGetExecutablePath = tryGetExecutablePath; + function normalizeSeparators(p) { + p = p || ""; + if (exports2.IS_WINDOWS) { + p = p.replace(/\//g, "\\"); + return p.replace(/\\\\+/g, "\\"); + } + return p.replace(/\/\/+/g, "/"); } - if (identity.isDocument(value) && !_replacer) - return value.toString(options); - return new Document.Document(value, _replacer, options).toString(options); -} - -exports.parse = parse; -exports.parseAllDocuments = parseAllDocuments; -exports.parseDocument = parseDocument; -exports.stringify = stringify; - - -/***/ }), - -/***/ 5840: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var map = __nccwpck_require__(7451); -var seq = __nccwpck_require__(1706); -var string = __nccwpck_require__(6464); -var tags = __nccwpck_require__(18); - -const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0; -class Schema { - constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) { - this.compat = Array.isArray(compat) - ? tags.getTags(compat, 'compat') - : compat - ? tags.getTags(null, compat) - : null; - this.name = (typeof schema === 'string' && schema) || 'core'; - this.knownTags = resolveKnownTags ? tags.coreKnownTags : {}; - this.tags = tags.getTags(customTags, this.name, merge); - this.toStringOptions = toStringDefaults ?? null; - Object.defineProperty(this, identity.MAP, { value: map.map }); - Object.defineProperty(this, identity.SCALAR, { value: string.string }); - Object.defineProperty(this, identity.SEQ, { value: seq.seq }); - // Used by createMap() - this.sortMapEntries = - typeof sortMapEntries === 'function' - ? sortMapEntries - : sortMapEntries === true - ? sortMapEntriesByKey - : null; - } - clone() { - const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this)); - copy.tags = this.tags.slice(); - return copy; + function isUnixExecutable(stats) { + return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid(); } -} - -exports.Schema = Schema; - - -/***/ }), - -/***/ 7451: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var YAMLMap = __nccwpck_require__(4454); - -const map = { - collection: 'map', - default: true, - nodeClass: YAMLMap.YAMLMap, - tag: 'tag:yaml.org,2002:map', - resolve(map, onError) { - if (!identity.isMap(map)) - onError('Expected a mapping for this tag'); - return map; - }, - createNode: (schema, obj, ctx) => YAMLMap.YAMLMap.from(schema, obj, ctx) -}; - -exports.map = map; - - -/***/ }), - -/***/ 3632: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Scalar = __nccwpck_require__(3301); - -const nullTag = { - identify: value => value == null, - createNode: () => new Scalar.Scalar(null), - default: true, - tag: 'tag:yaml.org,2002:null', - test: /^(?:~|[Nn]ull|NULL)?$/, - resolve: () => new Scalar.Scalar(null), - stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source) - ? source - : ctx.options.nullStr -}; - -exports.nullTag = nullTag; - - -/***/ }), - -/***/ 1706: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var YAMLSeq = __nccwpck_require__(2223); - -const seq = { - collection: 'seq', - default: true, - nodeClass: YAMLSeq.YAMLSeq, - tag: 'tag:yaml.org,2002:seq', - resolve(seq, onError) { - if (!identity.isSeq(seq)) - onError('Expected a sequence for this tag'); - return seq; - }, - createNode: (schema, obj, ctx) => YAMLSeq.YAMLSeq.from(schema, obj, ctx) -}; - -exports.seq = seq; - - -/***/ }), - -/***/ 6464: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var stringifyString = __nccwpck_require__(3069); - -const string = { - identify: value => typeof value === 'string', - default: true, - tag: 'tag:yaml.org,2002:str', - resolve: str => str, - stringify(item, ctx, onComment, onChompKeep) { - ctx = Object.assign({ actualString: true }, ctx); - return stringifyString.stringifyString(item, ctx, onComment, onChompKeep); + function getCmdPath() { + var _a3; + return (_a3 = process.env["COMSPEC"]) !== null && _a3 !== void 0 ? _a3 : `cmd.exe`; } -}; - -exports.string = string; - - -/***/ }), - -/***/ 3959: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Scalar = __nccwpck_require__(3301); + exports2.getCmdPath = getCmdPath; + } +}); -const boolTag = { - identify: value => typeof value === 'boolean', - default: true, - tag: 'tag:yaml.org,2002:bool', - test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/, - resolve: str => new Scalar.Scalar(str[0] === 't' || str[0] === 'T'), - stringify({ source, value }, ctx) { - if (source && boolTag.test.test(source)) { - const sv = source[0] === 't' || source[0] === 'T'; - if (value === sv) - return source; +// node_modules/@actions/io/lib/io.js +var require_io = __commonJS({ + "node_modules/@actions/io/lib/io.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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); + } } - return value ? ctx.options.trueStr : ctx.options.falseStr; - } -}; - -exports.boolTag = boolTag; - - -/***/ }), - -/***/ 8405: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Scalar = __nccwpck_require__(3301); -var stringifyNumber = __nccwpck_require__(8689); - -const floatNaN = { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/, - resolve: str => str.slice(-3).toLowerCase() === 'nan' - ? NaN - : str[0] === '-' - ? Number.NEGATIVE_INFINITY - : Number.POSITIVE_INFINITY, - stringify: stringifyNumber.stringifyNumber -}; -const floatExp = { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - format: 'EXP', - test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/, - resolve: str => parseFloat(str), - stringify(node) { - const num = Number(node.value); - return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node); - } -}; -const float = { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/, - resolve(str) { - const node = new Scalar.Scalar(parseFloat(str)); - const dot = str.indexOf('.'); - if (dot !== -1 && str[str.length - 1] === '0') - node.minFractionDigits = str.length - dot - 1; - return node; - }, - stringify: stringifyNumber.stringifyNumber -}; - -exports.float = float; -exports.floatExp = floatExp; -exports.floatNaN = floatNaN; - - -/***/ }), - -/***/ 9874: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var stringifyNumber = __nccwpck_require__(8689); - -const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value); -const intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix)); -function intStringify(node, radix, prefix) { - const { value } = node; - if (intIdentify(value) && value >= 0) - return prefix + value.toString(radix); - return stringifyNumber.stringifyNumber(node); -} -const intOct = { - identify: value => intIdentify(value) && value >= 0, - default: true, - tag: 'tag:yaml.org,2002:int', - format: 'OCT', - test: /^0o[0-7]+$/, - resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt), - stringify: node => intStringify(node, 8, '0o') -}; -const int = { - identify: intIdentify, - default: true, - tag: 'tag:yaml.org,2002:int', - test: /^[-+]?[0-9]+$/, - resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt), - stringify: stringifyNumber.stringifyNumber -}; -const intHex = { - identify: value => intIdentify(value) && value >= 0, - default: true, - tag: 'tag:yaml.org,2002:int', - format: 'HEX', - test: /^0x[0-9a-fA-F]+$/, - resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt), - stringify: node => intStringify(node, 16, '0x') -}; - -exports.int = int; -exports.intHex = intHex; -exports.intOct = intOct; - - -/***/ }), - -/***/ 896: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var map = __nccwpck_require__(7451); -var _null = __nccwpck_require__(3632); -var seq = __nccwpck_require__(1706); -var string = __nccwpck_require__(6464); -var bool = __nccwpck_require__(3959); -var float = __nccwpck_require__(8405); -var int = __nccwpck_require__(9874); - -const schema = [ - map.map, - seq.seq, - string.string, - _null.nullTag, - bool.boolTag, - int.intOct, - int.int, - int.intHex, - float.floatNaN, - float.floatExp, - float.float -]; - -exports.schema = schema; - - -/***/ }), - -/***/ 3559: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Scalar = __nccwpck_require__(3301); -var map = __nccwpck_require__(7451); -var seq = __nccwpck_require__(1706); - -function intIdentify(value) { - return typeof value === 'bigint' || Number.isInteger(value); -} -const stringifyJSON = ({ value }) => JSON.stringify(value); -const jsonScalars = [ - { - identify: value => typeof value === 'string', - default: true, - tag: 'tag:yaml.org,2002:str', - resolve: str => str, - stringify: stringifyJSON - }, - { - identify: value => value == null, - createNode: () => new Scalar.Scalar(null), - default: true, - tag: 'tag:yaml.org,2002:null', - test: /^null$/, - resolve: () => null, - stringify: stringifyJSON - }, - { - identify: value => typeof value === 'boolean', - default: true, - tag: 'tag:yaml.org,2002:bool', - test: /^true$|^false$/, - resolve: str => str === 'true', - stringify: stringifyJSON - }, - { - identify: intIdentify, - default: true, - tag: 'tag:yaml.org,2002:int', - test: /^-?(?:0|[1-9][0-9]*)$/, - resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10), - stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value) - }, - { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/, - resolve: str => parseFloat(str), - stringify: stringifyJSON + 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(exports2, "__esModule", { value: true }); + exports2.findInPath = exports2.which = exports2.mkdirP = exports2.rmRF = exports2.mv = exports2.cp = void 0; + var assert_1 = require("assert"); + var path2 = __importStar(require("path")); + var ioUtil = __importStar(require_io_util()); + function cp(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + const { force, recursive, copySourceDirectory } = readCopyOptions(options); + const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; + if (destStat && destStat.isFile() && !force) { + return; + } + const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path2.join(dest, path2.basename(source)) : dest; + if (!(yield ioUtil.exists(source))) { + throw new Error(`no such file or directory: ${source}`); + } + const sourceStat = yield ioUtil.stat(source); + if (sourceStat.isDirectory()) { + if (!recursive) { + throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); + } else { + yield cpDirRecursive(source, newDest, 0, force); + } + } else { + if (path2.relative(source, newDest) === "") { + throw new Error(`'${newDest}' and '${source}' are the same file`); + } + yield copyFile(source, newDest, force); + } + }); } -]; -const jsonError = { - default: true, - tag: '', - test: /^/, - resolve(str, onError) { - onError(`Unresolved plain scalar ${JSON.stringify(str)}`); - return str; + exports2.cp = cp; + function mv(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + if (yield ioUtil.exists(dest)) { + let destExists = true; + if (yield ioUtil.isDirectory(dest)) { + dest = path2.join(dest, path2.basename(source)); + destExists = yield ioUtil.exists(dest); + } + if (destExists) { + if (options.force == null || options.force) { + yield rmRF(dest); + } else { + throw new Error("Destination already exists"); + } + } + } + yield mkdirP(path2.dirname(dest)); + yield ioUtil.rename(source, dest); + }); } -}; -const schema = [map.map, seq.seq].concat(jsonScalars, jsonError); - -exports.schema = schema; - - -/***/ }), - -/***/ 18: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var map = __nccwpck_require__(7451); -var _null = __nccwpck_require__(3632); -var seq = __nccwpck_require__(1706); -var string = __nccwpck_require__(6464); -var bool = __nccwpck_require__(3959); -var float = __nccwpck_require__(8405); -var int = __nccwpck_require__(9874); -var schema = __nccwpck_require__(896); -var schema$1 = __nccwpck_require__(3559); -var binary = __nccwpck_require__(6083); -var merge = __nccwpck_require__(452); -var omap = __nccwpck_require__(303); -var pairs = __nccwpck_require__(8385); -var schema$2 = __nccwpck_require__(5913); -var set = __nccwpck_require__(1528); -var timestamp = __nccwpck_require__(6752); - -const schemas = new Map([ - ['core', schema.schema], - ['failsafe', [map.map, seq.seq, string.string]], - ['json', schema$1.schema], - ['yaml11', schema$2.schema], - ['yaml-1.1', schema$2.schema] -]); -const tagsByName = { - binary: binary.binary, - bool: bool.boolTag, - float: float.float, - floatExp: float.floatExp, - floatNaN: float.floatNaN, - floatTime: timestamp.floatTime, - int: int.int, - intHex: int.intHex, - intOct: int.intOct, - intTime: timestamp.intTime, - map: map.map, - merge: merge.merge, - null: _null.nullTag, - omap: omap.omap, - pairs: pairs.pairs, - seq: seq.seq, - set: set.set, - timestamp: timestamp.timestamp -}; -const coreKnownTags = { - 'tag:yaml.org,2002:binary': binary.binary, - 'tag:yaml.org,2002:merge': merge.merge, - 'tag:yaml.org,2002:omap': omap.omap, - 'tag:yaml.org,2002:pairs': pairs.pairs, - 'tag:yaml.org,2002:set': set.set, - 'tag:yaml.org,2002:timestamp': timestamp.timestamp -}; -function getTags(customTags, schemaName, addMergeTag) { - const schemaTags = schemas.get(schemaName); - if (schemaTags && !customTags) { - return addMergeTag && !schemaTags.includes(merge.merge) - ? schemaTags.concat(merge.merge) - : schemaTags.slice(); - } - let tags = schemaTags; - if (!tags) { - if (Array.isArray(customTags)) - tags = []; - else { - const keys = Array.from(schemas.keys()) - .filter(key => key !== 'yaml11') - .map(key => JSON.stringify(key)) - .join(', '); - throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`); + exports2.mv = mv; + function rmRF(inputPath) { + return __awaiter(this, void 0, void 0, function* () { + if (ioUtil.IS_WINDOWS) { + if (/[*"<>|]/.test(inputPath)) { + throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows'); + } + } + try { + yield ioUtil.rm(inputPath, { + force: true, + maxRetries: 3, + recursive: true, + retryDelay: 300 + }); + } catch (err) { + throw new Error(`File was unable to be removed ${err}`); } + }); } - if (Array.isArray(customTags)) { - for (const tag of customTags) - tags = tags.concat(tag); + exports2.rmRF = rmRF; + function mkdirP(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(fsPath, "a path argument must be provided"); + yield ioUtil.mkdir(fsPath, { recursive: true }); + }); } - else if (typeof customTags === 'function') { - tags = customTags(tags.slice()); + exports2.mkdirP = mkdirP; + function which(tool, check) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + if (check) { + const result = yield which(tool, false); + if (!result) { + if (ioUtil.IS_WINDOWS) { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); + } else { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); + } + } + return result; + } + const matches = yield findInPath(tool); + if (matches && matches.length > 0) { + return matches[0]; + } + return ""; + }); } - if (addMergeTag) - tags = tags.concat(merge.merge); - return tags.reduce((tags, tag) => { - const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag; - if (!tagObj) { - const tagName = JSON.stringify(tag); - const keys = Object.keys(tagsByName) - .map(key => JSON.stringify(key)) - .join(', '); - throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`); - } - if (!tags.includes(tagObj)) - tags.push(tagObj); - return tags; - }, []); -} - -exports.coreKnownTags = coreKnownTags; -exports.getTags = getTags; - - -/***/ }), - -/***/ 6083: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var node_buffer = __nccwpck_require__(181); -var Scalar = __nccwpck_require__(3301); -var stringifyString = __nccwpck_require__(3069); - -const binary = { - identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array - default: false, - tag: 'tag:yaml.org,2002:binary', - /** - * Returns a Buffer in node and an Uint8Array in browsers - * - * To use the resulting buffer as an image, you'll want to do something like: - * - * const blob = new Blob([buffer], { type: 'image/jpeg' }) - * document.querySelector('#photo').src = URL.createObjectURL(blob) - */ - resolve(src, onError) { - if (typeof node_buffer.Buffer === 'function') { - return node_buffer.Buffer.from(src, 'base64'); - } - else if (typeof atob === 'function') { - // On IE 11, atob() can't handle newlines - const str = atob(src.replace(/[\n\r]/g, '')); - const buffer = new Uint8Array(str.length); - for (let i = 0; i < str.length; ++i) - buffer[i] = str.charCodeAt(i); - return buffer; + exports2.which = which; + function findInPath(tool) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); } - else { - onError('This environment does not support reading binary tags; either Buffer or atob is required'); - return src; + const extensions = []; + if (ioUtil.IS_WINDOWS && process.env["PATHEXT"]) { + for (const extension of process.env["PATHEXT"].split(path2.delimiter)) { + if (extension) { + extensions.push(extension); + } + } } - }, - stringify({ comment, type, value }, ctx, onComment, onChompKeep) { - if (!value) - return ''; - const buf = value; // checked earlier by binary.identify() - let str; - if (typeof node_buffer.Buffer === 'function') { - str = - buf instanceof node_buffer.Buffer - ? buf.toString('base64') - : node_buffer.Buffer.from(buf.buffer).toString('base64'); - } - else if (typeof btoa === 'function') { - let s = ''; - for (let i = 0; i < buf.length; ++i) - s += String.fromCharCode(buf[i]); - str = btoa(s); + if (ioUtil.isRooted(tool)) { + const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); + if (filePath) { + return [filePath]; + } + return []; } - else { - throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required'); + if (tool.includes(path2.sep)) { + return []; } - type ?? (type = Scalar.Scalar.BLOCK_LITERAL); - if (type !== Scalar.Scalar.QUOTE_DOUBLE) { - const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth); - const n = Math.ceil(str.length / lineWidth); - const lines = new Array(n); - for (let i = 0, o = 0; i < n; ++i, o += lineWidth) { - lines[i] = str.substr(o, lineWidth); + const directories = []; + if (process.env.PATH) { + for (const p of process.env.PATH.split(path2.delimiter)) { + if (p) { + directories.push(p); } - str = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? '\n' : ' '); + } } - return stringifyString.stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep); + const matches = []; + for (const directory of directories) { + const filePath = yield ioUtil.tryGetExecutablePath(path2.join(directory, tool), extensions); + if (filePath) { + matches.push(filePath); + } + } + return matches; + }); } -}; - -exports.binary = binary; - - -/***/ }), - -/***/ 8398: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Scalar = __nccwpck_require__(3301); - -function boolStringify({ value, source }, ctx) { - const boolObj = value ? trueTag : falseTag; - if (source && boolObj.test.test(source)) - return source; - return value ? ctx.options.trueStr : ctx.options.falseStr; -} -const trueTag = { - identify: value => value === true, - default: true, - tag: 'tag:yaml.org,2002:bool', - test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/, - resolve: () => new Scalar.Scalar(true), - stringify: boolStringify -}; -const falseTag = { - identify: value => value === false, - default: true, - tag: 'tag:yaml.org,2002:bool', - test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/, - resolve: () => new Scalar.Scalar(false), - stringify: boolStringify -}; - -exports.falseTag = falseTag; -exports.trueTag = trueTag; - - -/***/ }), - -/***/ 5782: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var Scalar = __nccwpck_require__(3301); -var stringifyNumber = __nccwpck_require__(8689); - -const floatNaN = { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/, - resolve: (str) => str.slice(-3).toLowerCase() === 'nan' - ? NaN - : str[0] === '-' - ? Number.NEGATIVE_INFINITY - : Number.POSITIVE_INFINITY, - stringify: stringifyNumber.stringifyNumber -}; -const floatExp = { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - format: 'EXP', - test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/, - resolve: (str) => parseFloat(str.replace(/_/g, '')), - stringify(node) { - const num = Number(node.value); - return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node); + exports2.findInPath = findInPath; + function readCopyOptions(options) { + const force = options.force == null ? true : options.force; + const recursive = Boolean(options.recursive); + const copySourceDirectory = options.copySourceDirectory == null ? true : Boolean(options.copySourceDirectory); + return { force, recursive, copySourceDirectory }; } -}; -const float = { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/, - resolve(str) { - const node = new Scalar.Scalar(parseFloat(str.replace(/_/g, ''))); - const dot = str.indexOf('.'); - if (dot !== -1) { - const f = str.substring(dot + 1).replace(/_/g, ''); - if (f[f.length - 1] === '0') - node.minFractionDigits = f.length; - } - return node; - }, - stringify: stringifyNumber.stringifyNumber -}; - -exports.float = float; -exports.floatExp = floatExp; -exports.floatNaN = floatNaN; - - -/***/ }), - -/***/ 873: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var stringifyNumber = __nccwpck_require__(8689); - -const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value); -function intResolve(str, offset, radix, { intAsBigInt }) { - const sign = str[0]; - if (sign === '-' || sign === '+') - offset += 1; - str = str.substring(offset).replace(/_/g, ''); - if (intAsBigInt) { - switch (radix) { - case 2: - str = `0b${str}`; - break; - case 8: - str = `0o${str}`; - break; - case 16: - str = `0x${str}`; - break; + function cpDirRecursive(sourceDir, destDir, currentDepth, force) { + return __awaiter(this, void 0, void 0, function* () { + if (currentDepth >= 255) + return; + currentDepth++; + yield mkdirP(destDir); + const files = yield ioUtil.readdir(sourceDir); + for (const fileName of files) { + const srcFile = `${sourceDir}/${fileName}`; + const destFile = `${destDir}/${fileName}`; + const srcFileStat = yield ioUtil.lstat(srcFile); + if (srcFileStat.isDirectory()) { + yield cpDirRecursive(srcFile, destFile, currentDepth, force); + } else { + yield copyFile(srcFile, destFile, force); + } } - const n = BigInt(str); - return sign === '-' ? BigInt(-1) * n : n; - } - const n = parseInt(str, radix); - return sign === '-' ? -1 * n : n; -} -function intStringify(node, radix, prefix) { - const { value } = node; - if (intIdentify(value)) { - const str = value.toString(radix); - return value < 0 ? '-' + prefix + str.substr(1) : prefix + str; + yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); + }); } - return stringifyNumber.stringifyNumber(node); -} -const intBin = { - identify: intIdentify, - default: true, - tag: 'tag:yaml.org,2002:int', - format: 'BIN', - test: /^[-+]?0b[0-1_]+$/, - resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt), - stringify: node => intStringify(node, 2, '0b') -}; -const intOct = { - identify: intIdentify, - default: true, - tag: 'tag:yaml.org,2002:int', - format: 'OCT', - test: /^[-+]?0[0-7_]+$/, - resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt), - stringify: node => intStringify(node, 8, '0') -}; -const int = { - identify: intIdentify, - default: true, - tag: 'tag:yaml.org,2002:int', - test: /^[-+]?[0-9][0-9_]*$/, - resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt), - stringify: stringifyNumber.stringifyNumber -}; -const intHex = { - identify: intIdentify, - default: true, - tag: 'tag:yaml.org,2002:int', - format: 'HEX', - test: /^[-+]?0x[0-9a-fA-F_]+$/, - resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt), - stringify: node => intStringify(node, 16, '0x') -}; - -exports.int = int; -exports.intBin = intBin; -exports.intHex = intHex; -exports.intOct = intOct; - - -/***/ }), - -/***/ 452: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Scalar = __nccwpck_require__(3301); - -// If the value associated with a merge key is a single mapping node, each of -// its key/value pairs is inserted into the current mapping, unless the key -// already exists in it. If the value associated with the merge key is a -// sequence, then this sequence is expected to contain mapping nodes and each -// of these nodes is merged in turn according to its order in the sequence. -// Keys in mapping nodes earlier in the sequence override keys specified in -// later mapping nodes. -- http://yaml.org/type/merge.html -const MERGE_KEY = '<<'; -const merge = { - identify: value => value === MERGE_KEY || - (typeof value === 'symbol' && value.description === MERGE_KEY), - default: 'key', - tag: 'tag:yaml.org,2002:merge', - test: /^<<$/, - resolve: () => Object.assign(new Scalar.Scalar(Symbol(MERGE_KEY)), { - addToJSMap: addMergeToJSMap - }), - stringify: () => MERGE_KEY -}; -const isMergeKey = (ctx, key) => (merge.identify(key) || - (identity.isScalar(key) && - (!key.type || key.type === Scalar.Scalar.PLAIN) && - merge.identify(key.value))) && - ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default); -function addMergeToJSMap(ctx, map, value) { - value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value; - if (identity.isSeq(value)) - for (const it of value.items) - mergeValue(ctx, map, it); - else if (Array.isArray(value)) - for (const it of value) - mergeValue(ctx, map, it); - else - mergeValue(ctx, map, value); -} -function mergeValue(ctx, map, value) { - const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value; - if (!identity.isMap(source)) - throw new Error('Merge sources must be maps or map aliases'); - const srcMap = source.toJSON(null, ctx, Map); - for (const [key, value] of srcMap) { - if (map instanceof Map) { - if (!map.has(key)) - map.set(key, value); - } - else if (map instanceof Set) { - map.add(key); - } - else if (!Object.prototype.hasOwnProperty.call(map, key)) { - Object.defineProperty(map, key, { - value, - writable: true, - enumerable: true, - configurable: true - }); + function copyFile(srcFile, destFile, force) { + return __awaiter(this, void 0, void 0, function* () { + if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { + try { + yield ioUtil.lstat(destFile); + yield ioUtil.unlink(destFile); + } catch (e) { + if (e.code === "EPERM") { + yield ioUtil.chmod(destFile, "0666"); + yield ioUtil.unlink(destFile); + } + } + const symlinkFull = yield ioUtil.readlink(srcFile); + yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? "junction" : null); + } else if (!(yield ioUtil.exists(destFile)) || force) { + yield ioUtil.copyFile(srcFile, destFile); } + }); } - return map; -} - -exports.addMergeToJSMap = addMergeToJSMap; -exports.isMergeKey = isMergeKey; -exports.merge = merge; - - -/***/ }), - -/***/ 303: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var toJS = __nccwpck_require__(4043); -var YAMLMap = __nccwpck_require__(4454); -var YAMLSeq = __nccwpck_require__(2223); -var pairs = __nccwpck_require__(8385); + } +}); -class YAMLOMap extends YAMLSeq.YAMLSeq { - constructor() { +// node_modules/@actions/exec/lib/toolrunner.js +var require_toolrunner = __commonJS({ + "node_modules/@actions/exec/lib/toolrunner.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.argStringToArray = exports2.ToolRunner = void 0; + var os = __importStar(require("os")); + var events = __importStar(require("events")); + var child = __importStar(require("child_process")); + var path2 = __importStar(require("path")); + var io = __importStar(require_io()); + var ioUtil = __importStar(require_io_util()); + var timers_1 = require("timers"); + var IS_WINDOWS = process.platform === "win32"; + var ToolRunner = class extends events.EventEmitter { + constructor(toolPath, args, options) { super(); - this.add = YAMLMap.YAMLMap.prototype.add.bind(this); - this.delete = YAMLMap.YAMLMap.prototype.delete.bind(this); - this.get = YAMLMap.YAMLMap.prototype.get.bind(this); - this.has = YAMLMap.YAMLMap.prototype.has.bind(this); - this.set = YAMLMap.YAMLMap.prototype.set.bind(this); - this.tag = YAMLOMap.tag; - } - /** - * If `ctx` is given, the return type is actually `Map`, - * but TypeScript won't allow widening the signature of a child method. - */ - toJSON(_, ctx) { - if (!ctx) - return super.toJSON(_); - const map = new Map(); - if (ctx?.onCreate) - ctx.onCreate(map); - for (const pair of this.items) { - let key, value; - if (identity.isPair(pair)) { - key = toJS.toJS(pair.key, '', ctx); - value = toJS.toJS(pair.value, key, ctx); + if (!toolPath) { + throw new Error("Parameter 'toolPath' cannot be null or empty."); + } + this.toolPath = toolPath; + this.args = args || []; + this.options = options || {}; + } + _debug(message) { + if (this.options.listeners && this.options.listeners.debug) { + this.options.listeners.debug(message); + } + } + _getCommandString(options, noPrefix) { + const toolPath = this._getSpawnFileName(); + const args = this._getSpawnArgs(options); + let cmd = noPrefix ? "" : "[command]"; + if (IS_WINDOWS) { + if (this._isCmdFile()) { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; } - else { - key = toJS.toJS(pair, '', ctx); + } else if (options.windowsVerbatimArguments) { + cmd += `"${toolPath}"`; + for (const a of args) { + cmd += ` ${a}`; + } + } else { + cmd += this._windowsQuoteCmdArg(toolPath); + for (const a of args) { + cmd += ` ${this._windowsQuoteCmdArg(a)}`; } - if (map.has(key)) - throw new Error('Ordered maps must not include duplicate keys'); - map.set(key, value); + } + } else { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } } - return map; - } - static from(schema, iterable, ctx) { - const pairs$1 = pairs.createPairs(schema, iterable, ctx); - const omap = new this(); - omap.items = pairs$1.items; - return omap; - } -} -YAMLOMap.tag = 'tag:yaml.org,2002:omap'; -const omap = { - collection: 'seq', - identify: value => value instanceof Map, - nodeClass: YAMLOMap, - default: false, - tag: 'tag:yaml.org,2002:omap', - resolve(seq, onError) { - const pairs$1 = pairs.resolvePairs(seq, onError); - const seenKeys = []; - for (const { key } of pairs$1.items) { - if (identity.isScalar(key)) { - if (seenKeys.includes(key.value)) { - onError(`Ordered maps must not include duplicate keys: ${key.value}`); - } - else { - seenKeys.push(key.value); - } + return cmd; + } + _processLineBuffer(data, strBuffer, onLine) { + try { + let s = strBuffer + data.toString(); + let n = s.indexOf(os.EOL); + while (n > -1) { + const line = s.substring(0, n); + onLine(line); + s = s.substring(n + os.EOL.length); + n = s.indexOf(os.EOL); + } + return s; + } catch (err) { + this._debug(`error processing line. Failed with error ${err}`); + return ""; + } + } + _getSpawnFileName() { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + return process.env["COMSPEC"] || "cmd.exe"; + } + } + return this.toolPath; + } + _getSpawnArgs(options) { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; + for (const a of this.args) { + argline += " "; + argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a); + } + argline += '"'; + return [argline]; + } + } + return this.args; + } + _endsWith(str, end) { + return str.endsWith(end); + } + _isCmdFile() { + const upperToolPath = this.toolPath.toUpperCase(); + return this._endsWith(upperToolPath, ".CMD") || this._endsWith(upperToolPath, ".BAT"); + } + _windowsQuoteCmdArg(arg) { + if (!this._isCmdFile()) { + return this._uvQuoteCmdArg(arg); + } + if (!arg) { + return '""'; + } + const cmdSpecialChars = [ + " ", + " ", + "&", + "(", + ")", + "[", + "]", + "{", + "}", + "^", + "=", + ";", + "!", + "'", + "+", + ",", + "`", + "~", + "|", + "<", + ">", + '"' + ]; + let needsQuotes = false; + for (const char of arg) { + if (cmdSpecialChars.some((x) => x === char)) { + needsQuotes = true; + break; + } + } + if (!needsQuotes) { + return arg; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += '"'; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _uvQuoteCmdArg(arg) { + if (!arg) { + return '""'; + } + if (!arg.includes(" ") && !arg.includes(" ") && !arg.includes('"')) { + return arg; + } + if (!arg.includes('"') && !arg.includes("\\")) { + return `"${arg}"`; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += "\\"; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _cloneExecOptions(options) { + options = options || {}; + const result = { + cwd: options.cwd || process.cwd(), + env: options.env || process.env, + silent: options.silent || false, + windowsVerbatimArguments: options.windowsVerbatimArguments || false, + failOnStdErr: options.failOnStdErr || false, + ignoreReturnCode: options.ignoreReturnCode || false, + delay: options.delay || 1e4 + }; + result.outStream = options.outStream || process.stdout; + result.errStream = options.errStream || process.stderr; + return result; + } + _getSpawnOptions(options, toolPath) { + options = options || {}; + const result = {}; + result.cwd = options.cwd; + result.env = options.env; + result["windowsVerbatimArguments"] = options.windowsVerbatimArguments || this._isCmdFile(); + if (options.windowsVerbatimArguments) { + result.argv0 = `"${toolPath}"`; + } + return result; + } + /** + * Exec a tool. + * Output will be streamed to the live console. + * Returns promise with return code + * + * @param tool path to tool to exec + * @param options optional exec options. See ExecOptions + * @returns number + */ + exec() { + return __awaiter(this, void 0, void 0, function* () { + if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\"))) { + this.toolPath = path2.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); + } + this.toolPath = yield io.which(this.toolPath, true); + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + this._debug(`exec tool: ${this.toolPath}`); + this._debug("arguments:"); + for (const arg of this.args) { + this._debug(` ${arg}`); } - } - return Object.assign(new YAMLOMap(), pairs$1); - }, - createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx) -}; - -exports.YAMLOMap = YAMLOMap; -exports.omap = omap; - - -/***/ }), - -/***/ 8385: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Pair = __nccwpck_require__(7165); -var Scalar = __nccwpck_require__(3301); -var YAMLSeq = __nccwpck_require__(2223); - -function resolvePairs(seq, onError) { - if (identity.isSeq(seq)) { - for (let i = 0; i < seq.items.length; ++i) { - let item = seq.items[i]; - if (identity.isPair(item)) - continue; - else if (identity.isMap(item)) { - if (item.items.length > 1) - onError('Each pair must have its own sequence indicator'); - const pair = item.items[0] || new Pair.Pair(new Scalar.Scalar(null)); - if (item.commentBefore) - pair.key.commentBefore = pair.key.commentBefore - ? `${item.commentBefore}\n${pair.key.commentBefore}` - : item.commentBefore; - if (item.comment) { - const cn = pair.value ?? pair.key; - cn.comment = cn.comment - ? `${item.comment}\n${cn.comment}` - : item.comment; - } - item = pair; + const optionsNonNull = this._cloneExecOptions(this.options); + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); } - seq.items[i] = identity.isPair(item) ? item : new Pair.Pair(item); - } - } - else - onError('Expected a sequence for this tag'); - return seq; -} -function createPairs(schema, iterable, ctx) { - const { replacer } = ctx; - const pairs = new YAMLSeq.YAMLSeq(schema); - pairs.tag = 'tag:yaml.org,2002:pairs'; - let i = 0; - if (iterable && Symbol.iterator in Object(iterable)) - for (let it of iterable) { - if (typeof replacer === 'function') - it = replacer.call(iterable, String(i++), it); - let key, value; - if (Array.isArray(it)) { - if (it.length === 2) { - key = it[0]; - value = it[1]; + const state = new ExecState(optionsNonNull, this.toolPath); + state.on("debug", (message) => { + this._debug(message); + }); + if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) { + return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); + } + const fileName = this._getSpawnFileName(); + const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); + let stdbuffer = ""; + if (cp.stdout) { + cp.stdout.on("data", (data) => { + if (this.options.listeners && this.options.listeners.stdout) { + this.options.listeners.stdout(data); + } + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(data); } - else - throw new TypeError(`Expected [key, value] tuple: ${it}`); + stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { + if (this.options.listeners && this.options.listeners.stdline) { + this.options.listeners.stdline(line); + } + }); + }); } - else if (it && it instanceof Object) { - const keys = Object.keys(it); - if (keys.length === 1) { - key = keys[0]; - value = it[key]; + let errbuffer = ""; + if (cp.stderr) { + cp.stderr.on("data", (data) => { + state.processStderr = true; + if (this.options.listeners && this.options.listeners.stderr) { + this.options.listeners.stderr(data); } - else { - throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`); + if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) { + const s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream; + s.write(data); } + errbuffer = this._processLineBuffer(data, errbuffer, (line) => { + if (this.options.listeners && this.options.listeners.errline) { + this.options.listeners.errline(line); + } + }); + }); } - else { - key = it; + cp.on("error", (err) => { + state.processError = err.message; + state.processExited = true; + state.processClosed = true; + state.CheckComplete(); + }); + cp.on("exit", (code) => { + state.processExitCode = code; + state.processExited = true; + this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); + state.CheckComplete(); + }); + cp.on("close", (code) => { + state.processExitCode = code; + state.processExited = true; + state.processClosed = true; + this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); + state.CheckComplete(); + }); + state.on("done", (error2, exitCode) => { + if (stdbuffer.length > 0) { + this.emit("stdline", stdbuffer); + } + if (errbuffer.length > 0) { + this.emit("errline", errbuffer); + } + cp.removeAllListeners(); + if (error2) { + reject(error2); + } else { + resolve(exitCode); + } + }); + if (this.options.input) { + if (!cp.stdin) { + throw new Error("child process missing stdin"); + } + cp.stdin.end(this.options.input); } - pairs.items.push(Pair.createPair(key, value, ctx)); + })); + }); + } + }; + exports2.ToolRunner = ToolRunner; + function argStringToArray(argString) { + const args = []; + let inQuotes = false; + let escaped = false; + let arg = ""; + function append(c) { + if (escaped && c !== '"') { + arg += "\\"; } - return pairs; -} -const pairs = { - collection: 'seq', - default: false, - tag: 'tag:yaml.org,2002:pairs', - resolve: resolvePairs, - createNode: createPairs -}; - -exports.createPairs = createPairs; -exports.pairs = pairs; -exports.resolvePairs = resolvePairs; - - -/***/ }), - -/***/ 5913: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var map = __nccwpck_require__(7451); -var _null = __nccwpck_require__(3632); -var seq = __nccwpck_require__(1706); -var string = __nccwpck_require__(6464); -var binary = __nccwpck_require__(6083); -var bool = __nccwpck_require__(8398); -var float = __nccwpck_require__(5782); -var int = __nccwpck_require__(873); -var merge = __nccwpck_require__(452); -var omap = __nccwpck_require__(303); -var pairs = __nccwpck_require__(8385); -var set = __nccwpck_require__(1528); -var timestamp = __nccwpck_require__(6752); - -const schema = [ - map.map, - seq.seq, - string.string, - _null.nullTag, - bool.trueTag, - bool.falseTag, - int.intBin, - int.intOct, - int.int, - int.intHex, - float.floatNaN, - float.floatExp, - float.float, - binary.binary, - merge.merge, - omap.omap, - pairs.pairs, - set.set, - timestamp.intTime, - timestamp.floatTime, - timestamp.timestamp -]; - -exports.schema = schema; - - -/***/ }), - -/***/ 1528: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Pair = __nccwpck_require__(7165); -var YAMLMap = __nccwpck_require__(4454); - -class YAMLSet extends YAMLMap.YAMLMap { - constructor(schema) { - super(schema); - this.tag = YAMLSet.tag; - } - add(key) { - let pair; - if (identity.isPair(key)) - pair = key; - else if (key && - typeof key === 'object' && - 'key' in key && - 'value' in key && - key.value === null) - pair = new Pair.Pair(key.key, null); - else - pair = new Pair.Pair(key, null); - const prev = YAMLMap.findPair(this.items, pair.key); - if (!prev) - this.items.push(pair); - } - /** - * If `keepPair` is `true`, returns the Pair matching `key`. - * Otherwise, returns the value of that Pair's key. - */ - get(key, keepPair) { - const pair = YAMLMap.findPair(this.items, key); - return !keepPair && identity.isPair(pair) - ? identity.isScalar(pair.key) - ? pair.key.value - : pair.key - : pair; - } - set(key, value) { - if (typeof value !== 'boolean') - throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`); - const prev = YAMLMap.findPair(this.items, key); - if (prev && !value) { - this.items.splice(this.items.indexOf(prev), 1); + arg += c; + escaped = false; + } + for (let i = 0; i < argString.length; i++) { + const c = argString.charAt(i); + if (c === '"') { + if (!escaped) { + inQuotes = !inQuotes; + } else { + append(c); + } + continue; } - else if (!prev && value) { - this.items.push(new Pair.Pair(key)); + if (c === "\\" && escaped) { + append(c); + continue; } - } - toJSON(_, ctx) { - return super.toJSON(_, ctx, Set); - } - toString(ctx, onComment, onChompKeep) { - if (!ctx) - return JSON.stringify(this); - if (this.hasAllNullValues(true)) - return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep); - else - throw new Error('Set items must all have null values'); - } - static from(schema, iterable, ctx) { - const { replacer } = ctx; - const set = new this(schema); - if (iterable && Symbol.iterator in Object(iterable)) - for (let value of iterable) { - if (typeof replacer === 'function') - value = replacer.call(iterable, value, value); - set.items.push(Pair.createPair(value, null, ctx)); - } - return set; - } -} -YAMLSet.tag = 'tag:yaml.org,2002:set'; -const set = { - collection: 'map', - identify: value => value instanceof Set, - nodeClass: YAMLSet, - default: false, - tag: 'tag:yaml.org,2002:set', - createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx), - resolve(map, onError) { - if (identity.isMap(map)) { - if (map.hasAllNullValues(true)) - return Object.assign(new YAMLSet(), map); - else - onError('Set items must all have null values'); + if (c === "\\" && inQuotes) { + escaped = true; + continue; } - else - onError('Expected a mapping for this tag'); - return map; - } -}; - -exports.YAMLSet = YAMLSet; -exports.set = set; - - -/***/ }), - -/***/ 6752: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var stringifyNumber = __nccwpck_require__(8689); - -/** Internal types handle bigint as number, because TS can't figure it out. */ -function parseSexagesimal(str, asBigInt) { - const sign = str[0]; - const parts = sign === '-' || sign === '+' ? str.substring(1) : str; - const num = (n) => asBigInt ? BigInt(n) : Number(n); - const res = parts - .replace(/_/g, '') - .split(':') - .reduce((res, p) => res * num(60) + num(p), num(0)); - return (sign === '-' ? num(-1) * res : res); -} -/** - * hhhh:mm:ss.sss - * - * Internal types handle bigint as number, because TS can't figure it out. - */ -function stringifySexagesimal(node) { - let { value } = node; - let num = (n) => n; - if (typeof value === 'bigint') - num = n => BigInt(n); - else if (isNaN(value) || !isFinite(value)) - return stringifyNumber.stringifyNumber(node); - let sign = ''; - if (value < 0) { - sign = '-'; - value *= num(-1); - } - const _60 = num(60); - const parts = [value % _60]; // seconds, including ms - if (value < 60) { - parts.unshift(0); // at least one : is required - } - else { - value = (value - parts[0]) / _60; - parts.unshift(value % _60); // minutes - if (value >= 60) { - value = (value - parts[0]) / _60; - parts.unshift(value); // hours + if (c === " " && !inQuotes) { + if (arg.length > 0) { + args.push(arg); + arg = ""; + } + continue; } + append(c); + } + if (arg.length > 0) { + args.push(arg.trim()); + } + return args; } - return (sign + - parts - .map(n => String(n).padStart(2, '0')) - .join(':') - .replace(/000000\d*$/, '') // % 60 may introduce error - ); -} -const intTime = { - identify: value => typeof value === 'bigint' || Number.isInteger(value), - default: true, - tag: 'tag:yaml.org,2002:int', - format: 'TIME', - test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/, - resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt), - stringify: stringifySexagesimal -}; -const floatTime = { - identify: value => typeof value === 'number', - default: true, - tag: 'tag:yaml.org,2002:float', - format: 'TIME', - test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/, - resolve: str => parseSexagesimal(str, false), - stringify: stringifySexagesimal -}; -const timestamp = { - identify: value => value instanceof Date, - default: true, - tag: 'tag:yaml.org,2002:timestamp', - // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part - // may be omitted altogether, resulting in a date format. In such a case, the time part is - // assumed to be 00:00:00Z (start of day, UTC). - test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd - '(?:' + // time is optional - '(?:t|T|[ \\t]+)' + // t | T | whitespace - '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)? - '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30 - ')?$'), - resolve(str) { - const match = str.match(timestamp.test); - if (!match) - throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd'); - const [, year, month, day, hour, minute, second] = match.map(Number); - const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0; - let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec); - const tz = match[8]; - if (tz && tz !== 'Z') { - let d = parseSexagesimal(tz, false); - if (Math.abs(d) < 30) - d *= 60; - date -= 60000 * d; + exports2.argStringToArray = argStringToArray; + var ExecState = class _ExecState extends events.EventEmitter { + constructor(options, toolPath) { + super(); + this.processClosed = false; + this.processError = ""; + this.processExitCode = 0; + this.processExited = false; + this.processStderr = false; + this.delay = 1e4; + this.done = false; + this.timeout = null; + if (!toolPath) { + throw new Error("toolPath must not be empty"); } - return new Date(date); - }, - stringify: ({ value }) => value?.toISOString().replace(/(T00:00:00)?\.000Z$/, '') ?? '' -}; - -exports.floatTime = floatTime; -exports.intTime = intTime; -exports.timestamp = timestamp; - - -/***/ }), - -/***/ 4475: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; + this.options = options; + this.toolPath = toolPath; + if (options.delay) { + this.delay = options.delay; + } + } + CheckComplete() { + if (this.done) { + return; + } + if (this.processClosed) { + this._setResult(); + } else if (this.processExited) { + this.timeout = timers_1.setTimeout(_ExecState.HandleTimeout, this.delay, this); + } + } + _debug(message) { + this.emit("debug", message); + } + _setResult() { + let error2; + if (this.processExited) { + if (this.processError) { + error2 = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); + } else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { + error2 = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); + } else if (this.processStderr && this.options.failOnStdErr) { + error2 = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); + } + } + if (this.timeout) { + clearTimeout(this.timeout); + this.timeout = null; + } + this.done = true; + this.emit("done", error2, this.processExitCode); + } + static HandleTimeout(state) { + if (state.done) { + return; + } + if (!state.processClosed && state.processExited) { + const message = `The STDIO streams did not close within ${state.delay / 1e3} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; + state._debug(message); + } + state._setResult(); + } + }; + } +}); +// node_modules/@actions/exec/lib/exec.js +var require_exec = __commonJS({ + "node_modules/@actions/exec/lib/exec.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getExecOutput = exports2.exec = void 0; + var string_decoder_1 = require("string_decoder"); + var tr = __importStar(require_toolrunner()); + function exec(commandLine, args, options) { + return __awaiter(this, void 0, void 0, function* () { + const commandArgs = tr.argStringToArray(commandLine); + if (commandArgs.length === 0) { + throw new Error(`Parameter 'commandLine' cannot be null or empty.`); + } + const toolPath = commandArgs[0]; + args = commandArgs.slice(1).concat(args || []); + const runner = new tr.ToolRunner(toolPath, args, options); + return runner.exec(); + }); + } + exports2.exec = exec; + function getExecOutput(commandLine, args, options) { + var _a2, _b; + return __awaiter(this, void 0, void 0, function* () { + let stdout = ""; + let stderr = ""; + const stdoutDecoder = new string_decoder_1.StringDecoder("utf8"); + const stderrDecoder = new string_decoder_1.StringDecoder("utf8"); + const originalStdoutListener = (_a2 = options === null || options === void 0 ? void 0 : options.listeners) === null || _a2 === void 0 ? void 0 : _a2.stdout; + const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr; + const stdErrListener = (data) => { + stderr += stderrDecoder.write(data); + if (originalStdErrListener) { + originalStdErrListener(data); + } + }; + const stdOutListener = (data) => { + stdout += stdoutDecoder.write(data); + if (originalStdoutListener) { + originalStdoutListener(data); + } + }; + const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener }); + const exitCode = yield exec(commandLine, args, Object.assign(Object.assign({}, options), { listeners })); + stdout += stdoutDecoder.end(); + stderr += stderrDecoder.end(); + return { + exitCode, + stdout, + stderr + }; + }); + } + exports2.getExecOutput = getExecOutput; + } +}); -const FOLD_FLOW = 'flow'; -const FOLD_BLOCK = 'block'; -const FOLD_QUOTED = 'quoted'; -/** - * Tries to keep input at up to `lineWidth` characters, splitting only on spaces - * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are - * terminated with `\n` and started with `indent`. - */ -function foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) { - if (!lineWidth || lineWidth < 0) - return text; - if (lineWidth < minContentWidth) - minContentWidth = 0; - const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length); - if (text.length <= endStep) - return text; - const folds = []; - const escapedFolds = {}; - let end = lineWidth - indent.length; - if (typeof indentAtStart === 'number') { - if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) - folds.push(0); - else - end = lineWidth - indentAtStart; - } - let split = undefined; - let prev = undefined; - let overflow = false; - let i = -1; - let escStart = -1; - let escEnd = -1; - if (mode === FOLD_BLOCK) { - i = consumeMoreIndentedLines(text, i, indent.length); - if (i !== -1) - end = i + endStep; - } - for (let ch; (ch = text[(i += 1)]);) { - if (mode === FOLD_QUOTED && ch === '\\') { - escStart = i; - switch (text[i + 1]) { - case 'x': - i += 3; - break; - case 'u': - i += 5; - break; - case 'U': - i += 9; - break; - default: - i += 1; - } - escEnd = i; +// node_modules/@actions/core/lib/platform.js +var require_platform = __commonJS({ + "node_modules/@actions/core/lib/platform.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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); + } } - if (ch === '\n') { - if (mode === FOLD_BLOCK) - i = consumeMoreIndentedLines(text, i, indent.length); - end = i + indent.length + endStep; - split = undefined; + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } } - else { - if (ch === ' ' && - prev && - prev !== ' ' && - prev !== '\n' && - prev !== '\t') { - // space surrounded by non-space can be replaced with newline + indent - const next = text[i + 1]; - if (next && next !== ' ' && next !== '\n' && next !== '\t') - split = i; - } - if (i >= end) { - if (split) { - folds.push(split); - end = split + endStep; - split = undefined; - } - else if (mode === FOLD_QUOTED) { - // white-space collected at end may stretch past lineWidth - while (prev === ' ' || prev === '\t') { - prev = ch; - ch = text[(i += 1)]; - overflow = true; - } - // Account for newline escape, but don't break preceding escape - const j = i > escEnd + 1 ? i - 2 : escStart - 1; - // Bail out if lineWidth & minContentWidth are shorter than an escape string - if (escapedFolds[j]) - return text; - folds.push(j); - escapedFolds[j] = true; - end = j + endStep; - split = undefined; - } - else { - overflow = true; - } - } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getDetails = exports2.isLinux = exports2.isMacOS = exports2.isWindows = exports2.arch = exports2.platform = void 0; + var os_1 = __importDefault(require("os")); + var exec = __importStar(require_exec()); + var getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout: version } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', void 0, { + silent: true + }); + const { stdout: name } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', void 0, { + silent: true + }); + return { + name: name.trim(), + version: version.trim() + }; + }); + var getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + var _a2, _b, _c, _d; + const { stdout } = yield exec.getExecOutput("sw_vers", void 0, { + silent: true + }); + const version = (_b = (_a2 = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a2 === void 0 ? void 0 : _a2[1]) !== null && _b !== void 0 ? _b : ""; + const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ""; + return { + name, + version + }; + }); + var getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout } = yield exec.getExecOutput("lsb_release", ["-i", "-r", "-s"], { + silent: true + }); + const [name, version] = stdout.trim().split("\n"); + return { + name, + version + }; + }); + exports2.platform = os_1.default.platform(); + exports2.arch = os_1.default.arch(); + exports2.isWindows = exports2.platform === "win32"; + exports2.isMacOS = exports2.platform === "darwin"; + exports2.isLinux = exports2.platform === "linux"; + function getDetails() { + return __awaiter(this, void 0, void 0, function* () { + return Object.assign(Object.assign({}, yield exports2.isWindows ? getWindowsInfo() : exports2.isMacOS ? getMacOsInfo() : getLinuxInfo()), { + platform: exports2.platform, + arch: exports2.arch, + isWindows: exports2.isWindows, + isMacOS: exports2.isMacOS, + isLinux: exports2.isLinux + }); + }); + } + exports2.getDetails = getDetails; + } +}); + +// node_modules/@actions/core/lib/core.js +var require_core = __commonJS({ + "node_modules/@actions/core/lib/core.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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); + } } - prev = ch; - } - if (overflow && onOverflow) - onOverflow(); - if (folds.length === 0) - return text; - if (onFold) - onFold(); - let res = text.slice(0, folds[0]); - for (let i = 0; i < folds.length; ++i) { - const fold = folds[i]; - const end = folds[i + 1] || text.length; - if (fold === 0) - res = `\n${indent}${text.slice(0, end)}`; - else { - if (mode === FOLD_QUOTED && escapedFolds[fold]) - res += `${text[fold]}\\`; - res += `\n${indent}${text.slice(fold + 1, end)}`; + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } } - } - return res; -} -/** - * Presumes `i + 1` is at the start of a line - * @returns index of last newline in more-indented block - */ -function consumeMoreIndentedLines(text, i, indent) { - let end = i; - let start = i + 1; - let ch = text[start]; - while (ch === ' ' || ch === '\t') { - if (i < start + indent) { - ch = text[++i]; + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - else { - do { - ch = text[++i]; - } while (ch && ch !== '\n'); - end = i; - start = i + 1; - ch = text[start]; + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.platform = exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = exports2.markdownSummary = exports2.summary = exports2.getIDToken = exports2.getState = exports2.saveState = exports2.group = exports2.endGroup = exports2.startGroup = exports2.info = exports2.notice = exports2.warning = exports2.error = exports2.debug = exports2.isDebug = exports2.setFailed = exports2.setCommandEcho = exports2.setOutput = exports2.getBooleanInput = exports2.getMultilineInput = exports2.getInput = exports2.addPath = exports2.setSecret = exports2.exportVariable = exports2.ExitCode = void 0; + var command_1 = require_command(); + var file_command_1 = require_file_command(); + var utils_1 = require_utils(); + var os = __importStar(require("os")); + var path2 = __importStar(require("path")); + var oidc_utils_1 = require_oidc_utils(); + var ExitCode; + (function(ExitCode2) { + ExitCode2[ExitCode2["Success"] = 0] = "Success"; + ExitCode2[ExitCode2["Failure"] = 1] = "Failure"; + })(ExitCode || (exports2.ExitCode = ExitCode = {})); + function exportVariable(name, val) { + const convertedVal = (0, utils_1.toCommandValue)(val); + process.env[name] = convertedVal; + const filePath = process.env["GITHUB_ENV"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("ENV", (0, file_command_1.prepareKeyValueMessage)(name, val)); + } + (0, command_1.issueCommand)("set-env", { name }, convertedVal); + } + exports2.exportVariable = exportVariable; + function setSecret(secret) { + (0, command_1.issueCommand)("add-mask", {}, secret); + } + exports2.setSecret = setSecret; + function addPath(inputPath) { + const filePath = process.env["GITHUB_PATH"] || ""; + if (filePath) { + (0, file_command_1.issueFileCommand)("PATH", inputPath); + } else { + (0, command_1.issueCommand)("add-path", {}, inputPath); + } + process.env["PATH"] = `${inputPath}${path2.delimiter}${process.env["PATH"]}`; + } + exports2.addPath = addPath; + function getInput2(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || ""; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); + } + exports2.getInput = getInput2; + function getMultilineInput(name, options) { + const inputs = getInput2(name, options).split("\n").filter((x) => x !== ""); + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map((input) => input.trim()); + } + exports2.getMultilineInput = getMultilineInput; + function getBooleanInput2(name, options) { + const trueValue = ["true", "True", "TRUE"]; + const falseValue = ["false", "False", "FALSE"]; + const val = getInput2(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} +Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); + } + exports2.getBooleanInput = getBooleanInput2; + function setOutput(name, value) { + const filePath = process.env["GITHUB_OUTPUT"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("OUTPUT", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + process.stdout.write(os.EOL); + (0, command_1.issueCommand)("set-output", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.setOutput = setOutput; + function setCommandEcho(enabled) { + (0, command_1.issue)("echo", enabled ? "on" : "off"); + } + exports2.setCommandEcho = setCommandEcho; + function setFailed(message) { + process.exitCode = ExitCode.Failure; + error2(message); + } + exports2.setFailed = setFailed; + function isDebug() { + return process.env["RUNNER_DEBUG"] === "1"; + } + exports2.isDebug = isDebug; + function debug(message) { + (0, command_1.issueCommand)("debug", {}, message); + } + exports2.debug = debug; + function error2(message, properties = {}) { + (0, command_1.issueCommand)("error", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.error = error2; + function warning(message, properties = {}) { + (0, command_1.issueCommand)("warning", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.warning = warning; + function notice(message, properties = {}) { + (0, command_1.issueCommand)("notice", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.notice = notice; + function info2(message) { + process.stdout.write(message + os.EOL); + } + exports2.info = info2; + function startGroup(name) { + (0, command_1.issue)("group", name); + } + exports2.startGroup = startGroup; + function endGroup() { + (0, command_1.issue)("endgroup"); + } + exports2.endGroup = endGroup; + function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup(name); + let result; + try { + result = yield fn(); + } finally { + endGroup(); } + return result; + }); } - return end; -} - -exports.FOLD_BLOCK = FOLD_BLOCK; -exports.FOLD_FLOW = FOLD_FLOW; -exports.FOLD_QUOTED = FOLD_QUOTED; -exports.foldFlowLines = foldFlowLines; - - -/***/ }), - -/***/ 2148: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; + exports2.group = group; + function saveState(name, value) { + const filePath = process.env["GITHUB_STATE"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("STATE", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + (0, command_1.issueCommand)("save-state", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.saveState = saveState; + function getState(name) { + return process.env[`STATE_${name}`] || ""; + } + exports2.getState = getState; + function getIDToken(aud) { + return __awaiter(this, void 0, void 0, function* () { + return yield oidc_utils_1.OidcClient.getIDToken(aud); + }); + } + exports2.getIDToken = getIDToken; + var summary_1 = require_summary(); + Object.defineProperty(exports2, "summary", { enumerable: true, get: function() { + return summary_1.summary; + } }); + var summary_2 = require_summary(); + Object.defineProperty(exports2, "markdownSummary", { enumerable: true, get: function() { + return summary_2.markdownSummary; + } }); + var path_utils_1 = require_path_utils(); + Object.defineProperty(exports2, "toPosixPath", { enumerable: true, get: function() { + return path_utils_1.toPosixPath; + } }); + Object.defineProperty(exports2, "toWin32Path", { enumerable: true, get: function() { + return path_utils_1.toWin32Path; + } }); + Object.defineProperty(exports2, "toPlatformPath", { enumerable: true, get: function() { + return path_utils_1.toPlatformPath; + } }); + exports2.platform = __importStar(require_platform()); + } +}); +// src/index.ts +var index_exports = {}; +__export(index_exports, { + isValidConventionalCommitMessage: () => isValidConventionalCommitMessage, + main: () => main +}); +module.exports = __toCommonJS(index_exports); +var import_node_console = require("node:console"); +var import_node_fs = require("node:fs"); +var import_yaml = __toESM(require_dist()); +var import_core = __toESM(require_core()); -var anchors = __nccwpck_require__(1596); -var identity = __nccwpck_require__(1127); -var stringifyComment = __nccwpck_require__(9799); -var stringifyString = __nccwpck_require__(3069); +// node_modules/@stainless-api/sdk/internal/tslib.mjs +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +// node_modules/@stainless-api/sdk/internal/utils/uuid.mjs +var uuid4 = function() { + const { crypto } = globalThis; + if (crypto?.randomUUID) { + uuid4 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16)); +}; -function createStringifyContext(doc, options) { - const opt = Object.assign({ - blockQuote: true, - commentString: stringifyComment.stringifyComment, - defaultKeyType: null, - defaultStringType: 'PLAIN', - directives: null, - doubleQuotedAsJSON: false, - doubleQuotedMinMultiLineLength: 40, - falseStr: 'false', - flowCollectionPadding: true, - indentSeq: true, - lineWidth: 80, - minContentWidth: 20, - nullStr: 'null', - simpleKeys: false, - singleQuote: null, - trueStr: 'true', - verifyAliasOrder: true - }, doc.schema.toStringOptions, options); - let inFlow; - switch (opt.collectionStyle) { - case 'block': - inFlow = false; - break; - case 'flow': - inFlow = true; - break; - default: - inFlow = null; +// node_modules/@stainless-api/sdk/internal/errors.mjs +function isAbortError(err) { + return typeof err === "object" && err !== null && // Spec-compliant fetch implementations + ("name" in err && err.name === "AbortError" || // Expo fetch + "message" in err && String(err.message).includes("FetchRequestCanceledException")); +} +var castToError = (err) => { + if (err instanceof Error) + return err; + if (typeof err === "object" && err !== null) { + try { + if (Object.prototype.toString.call(err) === "[object Error]") { + const error2 = new Error(err.message, err.cause ? { cause: err.cause } : {}); + if (err.stack) + error2.stack = err.stack; + if (err.cause && !error2.cause) + error2.cause = err.cause; + if (err.name) + error2.name = err.name; + return error2; + } + } catch { } - return { - anchors: new Set(), - doc, - flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '', - indent: '', - indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : ' ', - inFlow, - options: opt - }; -} -function getTagObject(tags, item) { - if (item.tag) { - const match = tags.filter(t => t.tag === item.tag); - if (match.length > 0) - return match.find(t => t.format === item.format) ?? match[0]; + try { + return new Error(JSON.stringify(err)); + } catch { } - let tagObj = undefined; - let obj; - if (identity.isScalar(item)) { - obj = item.value; - let match = tags.filter(t => t.identify?.(obj)); - if (match.length > 1) { - const testMatch = match.filter(t => t.test); - if (testMatch.length > 0) - match = testMatch; - } - tagObj = - match.find(t => t.format === item.format) ?? match.find(t => !t.format); + } + return new Error(err); +}; + +// node_modules/@stainless-api/sdk/core/error.mjs +var StainlessError = class extends Error { +}; +var APIError = class _APIError extends StainlessError { + constructor(status, error2, message, headers) { + super(`${_APIError.makeMessage(status, error2, message)}`); + this.status = status; + this.headers = headers; + this.error = error2; + } + static makeMessage(status, error2, message) { + const msg = error2?.message ? typeof error2.message === "string" ? error2.message : JSON.stringify(error2.message) : error2 ? JSON.stringify(error2) : message; + if (status && msg) { + return `${status} ${msg}`; } - else { - obj = item; - tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass); + if (status) { + return `${status} status code (no body)`; } - if (!tagObj) { - const name = obj?.constructor?.name ?? (obj === null ? 'null' : typeof obj); - throw new Error(`Tag not resolved for ${name} value`); + if (msg) { + return msg; } - return tagObj; -} -// needs to be called before value stringifier to allow for circular anchor refs -function stringifyProps(node, tagObj, { anchors: anchors$1, doc }) { - if (!doc.directives) - return ''; - const props = []; - const anchor = (identity.isScalar(node) || identity.isCollection(node)) && node.anchor; - if (anchor && anchors.anchorIsValid(anchor)) { - anchors$1.add(anchor); - props.push(`&${anchor}`); + return "(no status code or body)"; + } + static generate(status, errorResponse, message, headers) { + if (!status || !headers) { + return new APIConnectionError({ message, cause: castToError(errorResponse) }); } - const tag = node.tag ?? (tagObj.default ? null : tagObj.tag); - if (tag) - props.push(doc.directives.tagString(tag)); - return props.join(' '); -} -function stringify(item, ctx, onComment, onChompKeep) { - if (identity.isPair(item)) - return item.toString(ctx, onComment, onChompKeep); - if (identity.isAlias(item)) { - if (ctx.doc.directives) - return item.toString(ctx); - if (ctx.resolvedAliases?.has(item)) { - throw new TypeError(`Cannot stringify circular structure without alias nodes`); - } - else { - if (ctx.resolvedAliases) - ctx.resolvedAliases.add(item); - else - ctx.resolvedAliases = new Set([item]); - item = item.resolve(ctx.doc); - } + const error2 = errorResponse; + if (status === 400) { + return new BadRequestError(status, error2, message, headers); } - let tagObj = undefined; - const node = identity.isNode(item) - ? item - : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) }); - tagObj ?? (tagObj = getTagObject(ctx.doc.schema.tags, node)); - const props = stringifyProps(node, tagObj, ctx); - if (props.length > 0) - ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1; - const str = typeof tagObj.stringify === 'function' - ? tagObj.stringify(node, ctx, onComment, onChompKeep) - : identity.isScalar(node) - ? stringifyString.stringifyString(node, ctx, onComment, onChompKeep) - : node.toString(ctx, onComment, onChompKeep); - if (!props) - return str; - return identity.isScalar(node) || str[0] === '{' || str[0] === '[' - ? `${props} ${str}` - : `${props}\n${ctx.indent}${str}`; -} - -exports.createStringifyContext = createStringifyContext; -exports.stringify = stringify; - - -/***/ }), - -/***/ 1212: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var stringify = __nccwpck_require__(2148); -var stringifyComment = __nccwpck_require__(9799); - -function stringifyCollection(collection, ctx, options) { - const flow = ctx.inFlow ?? collection.flow; - const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection; - return stringify(collection, ctx, options); -} -function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) { - const { indent, options: { commentString } } = ctx; - const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null }); - let chompKeep = false; // flag for the preceding node's status - const lines = []; - for (let i = 0; i < items.length; ++i) { - const item = items[i]; - let comment = null; - if (identity.isNode(item)) { - if (!chompKeep && item.spaceBefore) - lines.push(''); - addCommentBefore(ctx, lines, item.commentBefore, chompKeep); - if (item.comment) - comment = item.comment; - } - else if (identity.isPair(item)) { - const ik = identity.isNode(item.key) ? item.key : null; - if (ik) { - if (!chompKeep && ik.spaceBefore) - lines.push(''); - addCommentBefore(ctx, lines, ik.commentBefore, chompKeep); - } - } - chompKeep = false; - let str = stringify.stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true)); - if (comment) - str += stringifyComment.lineComment(str, itemIndent, commentString(comment)); - if (chompKeep && comment) - chompKeep = false; - lines.push(blockItemPrefix + str); + if (status === 401) { + return new AuthenticationError(status, error2, message, headers); } - let str; - if (lines.length === 0) { - str = flowChars.start + flowChars.end; + if (status === 403) { + return new PermissionDeniedError(status, error2, message, headers); } - else { - str = lines[0]; - for (let i = 1; i < lines.length; ++i) { - const line = lines[i]; - str += line ? `\n${indent}${line}` : '\n'; - } + if (status === 404) { + return new NotFoundError(status, error2, message, headers); } - if (comment) { - str += '\n' + stringifyComment.indentComment(commentString(comment), indent); - if (onComment) - onComment(); + if (status === 409) { + return new ConflictError(status, error2, message, headers); } - else if (chompKeep && onChompKeep) - onChompKeep(); - return str; -} -function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) { - const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx; - itemIndent += indentStep; - const itemCtx = Object.assign({}, ctx, { - indent: itemIndent, - inFlow: true, - type: null - }); - let reqNewline = false; - let linesAtValue = 0; - const lines = []; - for (let i = 0; i < items.length; ++i) { - const item = items[i]; - let comment = null; - if (identity.isNode(item)) { - if (item.spaceBefore) - lines.push(''); - addCommentBefore(ctx, lines, item.commentBefore, false); - if (item.comment) - comment = item.comment; - } - else if (identity.isPair(item)) { - const ik = identity.isNode(item.key) ? item.key : null; - if (ik) { - if (ik.spaceBefore) - lines.push(''); - addCommentBefore(ctx, lines, ik.commentBefore, false); - if (ik.comment) - reqNewline = true; - } - const iv = identity.isNode(item.value) ? item.value : null; - if (iv) { - if (iv.comment) - comment = iv.comment; - if (iv.commentBefore) - reqNewline = true; - } - else if (item.value == null && ik?.comment) { - comment = ik.comment; - } - } - if (comment) - reqNewline = true; - let str = stringify.stringify(item, itemCtx, () => (comment = null)); - if (i < items.length - 1) - str += ','; - if (comment) - str += stringifyComment.lineComment(str, itemIndent, commentString(comment)); - if (!reqNewline && (lines.length > linesAtValue || str.includes('\n'))) - reqNewline = true; - lines.push(str); - linesAtValue = lines.length; + if (status === 422) { + return new UnprocessableEntityError(status, error2, message, headers); } - const { start, end } = flowChars; - if (lines.length === 0) { - return start + end; + if (status === 429) { + return new RateLimitError(status, error2, message, headers); } - else { - if (!reqNewline) { - const len = lines.reduce((sum, line) => sum + line.length + 2, 2); - reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth; - } - if (reqNewline) { - let str = start; - for (const line of lines) - str += line ? `\n${indentStep}${indent}${line}` : '\n'; - return `${str}\n${indent}${end}`; - } - else { - return `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`; - } + if (status >= 500) { + return new InternalServerError(status, error2, message, headers); } + return new _APIError(status, error2, message, headers); + } +}; +var APIUserAbortError = class extends APIError { + constructor({ message } = {}) { + super(void 0, void 0, message || "Request was aborted.", void 0); + } +}; +var APIConnectionError = class extends APIError { + constructor({ message, cause }) { + super(void 0, void 0, message || "Connection error.", void 0); + if (cause) + this.cause = cause; + } +}; +var APIConnectionTimeoutError = class extends APIConnectionError { + constructor({ message } = {}) { + super({ message: message ?? "Request timed out." }); + } +}; +var BadRequestError = class extends APIError { +}; +var AuthenticationError = class extends APIError { +}; +var PermissionDeniedError = class extends APIError { +}; +var NotFoundError = class extends APIError { +}; +var ConflictError = class extends APIError { +}; +var UnprocessableEntityError = class extends APIError { +}; +var RateLimitError = class extends APIError { +}; +var InternalServerError = class extends APIError { +}; + +// node_modules/@stainless-api/sdk/internal/utils/values.mjs +var startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i; +var isAbsoluteURL = (url) => { + return startsWithSchemeRegexp.test(url); +}; +var isArray = (val) => (isArray = Array.isArray, isArray(val)); +var isReadonlyArray = isArray; +function maybeObj(x) { + if (typeof x !== "object") { + return {}; + } + return x ?? {}; } -function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) { - if (comment && chompKeep) - comment = comment.replace(/^\n+/, ''); - if (comment) { - const ic = stringifyComment.indentComment(commentString(comment), indent); - lines.push(ic.trimStart()); // Avoid double indent on first line - } +function isEmptyObj(obj) { + if (!obj) + return true; + for (const _k in obj) + return false; + return true; } - -exports.stringifyCollection = stringifyCollection; - - -/***/ }), - -/***/ 9799: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -/** - * Stringifies a comment. - * - * Empty comment lines are left empty, - * lines consisting of a single space are replaced by `#`, - * and all other lines are prefixed with a `#`. - */ -const stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#'); -function indentComment(comment, indent) { - if (/^\n+$/.test(comment)) - return comment.substring(1); - return indent ? comment.replace(/^(?! *$)/gm, indent) : comment; +function hasOwn(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); } -const lineComment = (str, indent, comment) => str.endsWith('\n') - ? indentComment(comment, indent) - : comment.includes('\n') - ? '\n' + indentComment(comment, indent) - : (str.endsWith(' ') ? '' : ' ') + comment; - -exports.indentComment = indentComment; -exports.lineComment = lineComment; -exports.stringifyComment = stringifyComment; - - -/***/ }), - -/***/ 6829: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; +var validatePositiveInteger = (name, n) => { + if (typeof n !== "number" || !Number.isInteger(n)) { + throw new StainlessError(`${name} must be an integer`); + } + if (n < 0) { + throw new StainlessError(`${name} must be a positive integer`); + } + return n; +}; +var safeJSON = (text) => { + try { + return JSON.parse(text); + } catch (err) { + return void 0; + } +}; +// node_modules/@stainless-api/sdk/internal/utils/sleep.mjs +var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); -var identity = __nccwpck_require__(1127); -var stringify = __nccwpck_require__(2148); -var stringifyComment = __nccwpck_require__(9799); +// node_modules/@stainless-api/sdk/version.mjs +var VERSION = "0.1.0-alpha.11"; -function stringifyDocument(doc, options) { - const lines = []; - let hasDirectives = options.directives === true; - if (options.directives !== false && doc.directives) { - const dir = doc.directives.toString(doc); - if (dir) { - lines.push(dir); - hasDirectives = true; - } - else if (doc.directives.docStart) - hasDirectives = true; - } - if (hasDirectives) - lines.push('---'); - const ctx = stringify.createStringifyContext(doc, options); - const { commentString } = ctx.options; - if (doc.commentBefore) { - if (lines.length !== 1) - lines.unshift(''); - const cs = commentString(doc.commentBefore); - lines.unshift(stringifyComment.indentComment(cs, '')); - } - let chompKeep = false; - let contentComment = null; - if (doc.contents) { - if (identity.isNode(doc.contents)) { - if (doc.contents.spaceBefore && hasDirectives) - lines.push(''); - if (doc.contents.commentBefore) { - const cs = commentString(doc.contents.commentBefore); - lines.push(stringifyComment.indentComment(cs, '')); - } - // top-level block scalars need to be indented if followed by a comment - ctx.forceBlockIndent = !!doc.comment; - contentComment = doc.contents.comment; - } - const onChompKeep = contentComment ? undefined : () => (chompKeep = true); - let body = stringify.stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep); - if (contentComment) - body += stringifyComment.lineComment(body, '', commentString(contentComment)); - if ((body[0] === '|' || body[0] === '>') && - lines[lines.length - 1] === '---') { - // Top-level block scalars with a preceding doc marker ought to use the - // same line for their header. - lines[lines.length - 1] = `--- ${body}`; - } - else - lines.push(body); - } - else { - lines.push(stringify.stringify(doc.contents, ctx)); - } - if (doc.directives?.docEnd) { - if (doc.comment) { - const cs = commentString(doc.comment); - if (cs.includes('\n')) { - lines.push('...'); - lines.push(stringifyComment.indentComment(cs, '')); - } - else { - lines.push(`... ${cs}`); - } - } - else { - lines.push('...'); - } - } - else { - let dc = doc.comment; - if (dc && chompKeep) - dc = dc.replace(/^\n+/, ''); - if (dc) { - if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '') - lines.push(''); - lines.push(stringifyComment.indentComment(commentString(dc), '')); - } +// node_modules/@stainless-api/sdk/internal/detect-platform.mjs +function getDetectedPlatform() { + if (typeof Deno !== "undefined" && Deno.build != null) { + return "deno"; + } + if (typeof EdgeRuntime !== "undefined") { + return "edge"; + } + if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") { + return "node"; + } + return "unknown"; +} +var getPlatformProperties = () => { + const detectedPlatform = getDetectedPlatform(); + if (detectedPlatform === "deno") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(Deno.build.os), + "X-Stainless-Arch": normalizeArch(Deno.build.arch), + "X-Stainless-Runtime": "deno", + "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown" + }; + } + if (typeof EdgeRuntime !== "undefined") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": `other:${EdgeRuntime}`, + "X-Stainless-Runtime": "edge", + "X-Stainless-Runtime-Version": globalThis.process.version + }; + } + if (detectedPlatform === "node") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"), + "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"), + "X-Stainless-Runtime": "node", + "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown" + }; + } + const browserInfo = getBrowserInfo(); + if (browserInfo) { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": `browser:${browserInfo.browser}`, + "X-Stainless-Runtime-Version": browserInfo.version + }; + } + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": "unknown", + "X-Stainless-Runtime-Version": "unknown" + }; +}; +function getBrowserInfo() { + if (typeof navigator === "undefined" || !navigator) { + return null; + } + const browserPatterns = [ + { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ } + ]; + for (const { key, pattern } of browserPatterns) { + const match = pattern.exec(navigator.userAgent); + if (match) { + const major = match[1] || 0; + const minor = match[2] || 0; + const patch = match[3] || 0; + return { browser: key, version: `${major}.${minor}.${patch}` }; + } + } + return null; +} +var normalizeArch = (arch) => { + if (arch === "x32") + return "x32"; + if (arch === "x86_64" || arch === "x64") + return "x64"; + if (arch === "arm") + return "arm"; + if (arch === "aarch64" || arch === "arm64") + return "arm64"; + if (arch) + return `other:${arch}`; + return "unknown"; +}; +var normalizePlatform = (platform) => { + platform = platform.toLowerCase(); + if (platform.includes("ios")) + return "iOS"; + if (platform === "android") + return "Android"; + if (platform === "darwin") + return "MacOS"; + if (platform === "win32") + return "Windows"; + if (platform === "freebsd") + return "FreeBSD"; + if (platform === "openbsd") + return "OpenBSD"; + if (platform === "linux") + return "Linux"; + if (platform) + return `Other:${platform}`; + return "Unknown"; +}; +var _platformHeaders; +var getPlatformHeaders = () => { + return _platformHeaders ?? (_platformHeaders = getPlatformProperties()); +}; + +// node_modules/@stainless-api/sdk/internal/shims.mjs +function getDefaultFetch() { + if (typeof fetch !== "undefined") { + return fetch; + } + throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Stainless({ fetch })` or polyfill the global, `globalThis.fetch = fetch`"); +} +function makeReadableStream(...args) { + const ReadableStream = globalThis.ReadableStream; + if (typeof ReadableStream === "undefined") { + throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`"); + } + return new ReadableStream(...args); +} +function ReadableStreamFrom(iterable) { + let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); + return makeReadableStream({ + start() { + }, + async pull(controller) { + const { done, value } = await iter.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel() { + await iter.return?.(); } - return lines.join('\n') + '\n'; + }); +} +async function CancelReadableStream(stream) { + if (stream === null || typeof stream !== "object") + return; + if (stream[Symbol.asyncIterator]) { + await stream[Symbol.asyncIterator]().return?.(); + return; + } + const reader = stream.getReader(); + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; } -exports.stringifyDocument = stringifyDocument; - - -/***/ }), - -/***/ 8689: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; +// node_modules/@stainless-api/sdk/internal/request-options.mjs +var FallbackEncoder = ({ headers, body }) => { + return { + bodyHeaders: { + "content-type": "application/json" + }, + body: JSON.stringify(body) + }; +}; +// node_modules/@stainless-api/sdk/internal/qs/formats.mjs +var default_format = "RFC3986"; +var default_formatter = (v) => String(v); +var formatters = { + RFC1738: (v) => String(v).replace(/%20/g, "+"), + RFC3986: default_formatter +}; +var RFC1738 = "RFC1738"; -function stringifyNumber({ format, minFractionDigits, tag, value }) { - if (typeof value === 'bigint') - return String(value); - const num = typeof value === 'number' ? value : Number(value); - if (!isFinite(num)) - return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf'; - let n = JSON.stringify(value); - if (!format && - minFractionDigits && - (!tag || tag === 'tag:yaml.org,2002:float') && - /^\d/.test(n)) { - let i = n.indexOf('.'); - if (i < 0) { - i = n.length; - n += '.'; - } - let d = minFractionDigits - (n.length - i - 1); - while (d-- > 0) - n += '0'; +// node_modules/@stainless-api/sdk/internal/qs/utils.mjs +var has = (obj, key) => (has = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), has(obj, key)); +var hex_table = /* @__PURE__ */ (() => { + const array = []; + for (let i = 0; i < 256; ++i) { + array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + } + return array; +})(); +var limit = 1024; +var encode = (str, _defaultEncoder, charset, _kind, format) => { + if (str.length === 0) { + return str; + } + let string = str; + if (typeof str === "symbol") { + string = Symbol.prototype.toString.call(str); + } else if (typeof str !== "string") { + string = String(str); + } + if (charset === "iso-8859-1") { + return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) { + return "%26%23" + parseInt($0.slice(2), 16) + "%3B"; + }); + } + let out = ""; + for (let j = 0; j < string.length; j += limit) { + const segment = string.length >= limit ? string.slice(j, j + limit) : string; + const arr = []; + for (let i = 0; i < segment.length; ++i) { + let c = segment.charCodeAt(i); + if (c === 45 || // - + c === 46 || // . + c === 95 || // _ + c === 126 || // ~ + c >= 48 && c <= 57 || // 0-9 + c >= 65 && c <= 90 || // a-z + c >= 97 && c <= 122 || // A-Z + format === RFC1738 && (c === 40 || c === 41)) { + arr[arr.length] = segment.charAt(i); + continue; + } + if (c < 128) { + arr[arr.length] = hex_table[c]; + continue; + } + if (c < 2048) { + arr[arr.length] = hex_table[192 | c >> 6] + hex_table[128 | c & 63]; + continue; + } + if (c < 55296 || c >= 57344) { + arr[arr.length] = hex_table[224 | c >> 12] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + continue; + } + i += 1; + c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023); + arr[arr.length] = hex_table[240 | c >> 18] + hex_table[128 | c >> 12 & 63] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + } + out += arr.join(""); + } + return out; +}; +function is_buffer(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); +} +function maybe_map(val, fn) { + if (isArray(val)) { + const mapped = []; + for (let i = 0; i < val.length; i += 1) { + mapped.push(fn(val[i])); } - return n; + return mapped; + } + return fn(val); } -exports.stringifyNumber = stringifyNumber; - - -/***/ }), - -/***/ 9748: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); -var Scalar = __nccwpck_require__(3301); -var stringify = __nccwpck_require__(2148); -var stringifyComment = __nccwpck_require__(9799); - -function stringifyPair({ key, value }, ctx, onComment, onChompKeep) { - const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx; - let keyComment = (identity.isNode(key) && key.comment) || null; - if (simpleKeys) { - if (keyComment) { - throw new Error('With simple keys, key nodes cannot have comments'); - } - if (identity.isCollection(key) || (!identity.isNode(key) && typeof key === 'object')) { - const msg = 'With simple keys, collection cannot be used as a key value'; - throw new Error(msg); - } +// node_modules/@stainless-api/sdk/internal/qs/stringify.mjs +var array_prefix_generators = { + brackets(prefix) { + return String(prefix) + "[]"; + }, + comma: "comma", + indices(prefix, key) { + return String(prefix) + "[" + key + "]"; + }, + repeat(prefix) { + return String(prefix); + } +}; +var push_to_array = function(arr, value_or_array) { + Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]); +}; +var toISOString; +var defaults = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: encode, + encodeValuesOnly: false, + format: default_format, + formatter: default_formatter, + /** @deprecated */ + indices: false, + serializeDate(date) { + return (toISOString ?? (toISOString = Function.prototype.call.bind(Date.prototype.toISOString)))(date); + }, + skipNulls: false, + strictNullHandling: false +}; +function is_non_nullish_primitive(v) { + return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint"; +} +var sentinel = {}; +function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { + let obj = object; + let tmp_sc = sideChannel; + let step = 0; + let find_flag = false; + while ((tmp_sc = tmp_sc.get(sentinel)) !== void 0 && !find_flag) { + const pos = tmp_sc.get(object); + step += 1; + if (typeof pos !== "undefined") { + if (pos === step) { + throw new RangeError("Cyclic object value"); + } else { + find_flag = true; + } } - let explicitKey = !simpleKeys && - (!key || - (keyComment && value == null && !ctx.inFlow) || - identity.isCollection(key) || - (identity.isScalar(key) - ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL - : typeof key === 'object')); - ctx = Object.assign({}, ctx, { - allNullValues: false, - implicitKey: !explicitKey && (simpleKeys || !allNullValues), - indent: indent + indentStep + if (typeof tmp_sc.get(sentinel) === "undefined") { + step = 0; + } + } + if (typeof filter === "function") { + obj = filter(prefix, obj); + } else if (obj instanceof Date) { + obj = serializeDate?.(obj); + } else if (generateArrayPrefix === "comma" && isArray(obj)) { + obj = maybe_map(obj, function(value) { + if (value instanceof Date) { + return serializeDate?.(value); + } + return value; }); - let keyCommentDone = false; - let chompKeep = false; - let str = stringify.stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true)); - if (!explicitKey && !ctx.inFlow && str.length > 1024) { - if (simpleKeys) - throw new Error('With simple keys, single line scalar must not span more than 1024 characters'); - explicitKey = true; + } + if (obj === null) { + if (strictNullHandling) { + return encoder && !encodeValuesOnly ? ( + // @ts-expect-error + encoder(prefix, defaults.encoder, charset, "key", format) + ) : prefix; } - if (ctx.inFlow) { - if (allNullValues || value == null) { - if (keyCommentDone && onComment) - onComment(); - return str === '' ? '?' : explicitKey ? `? ${str}` : str; - } + obj = ""; + } + if (is_non_nullish_primitive(obj) || is_buffer(obj)) { + if (encoder) { + const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format); + return [ + formatter?.(key_value) + "=" + // @ts-expect-error + formatter?.(encoder(obj, defaults.encoder, charset, "value", format)) + ]; } - else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) { - str = `? ${str}`; - if (keyComment && !keyCommentDone) { - str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment)); - } - else if (chompKeep && onChompKeep) - onChompKeep(); - return str; + return [formatter?.(prefix) + "=" + formatter?.(String(obj))]; + } + const values = []; + if (typeof obj === "undefined") { + return values; + } + let obj_keys; + if (generateArrayPrefix === "comma" && isArray(obj)) { + if (encodeValuesOnly && encoder) { + obj = maybe_map(obj, encoder); } - if (keyCommentDone) - keyComment = null; - if (explicitKey) { - if (keyComment) - str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment)); - str = `? ${str}\n${indent}:`; + obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray(filter)) { + obj_keys = filter; + } else { + const keys = Object.keys(obj); + obj_keys = sort ? keys.sort(sort) : keys; + } + const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + const adjusted_prefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix; + if (allowEmptyArrays && isArray(obj) && obj.length === 0) { + return adjusted_prefix + "[]"; + } + for (let j = 0; j < obj_keys.length; ++j) { + const key = obj_keys[j]; + const value = ( + // @ts-ignore + typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key] + ); + if (skipNulls && value === null) { + continue; + } + const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key; + const key_prefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]"); + sideChannel.set(object, step); + const valueSideChannel = /* @__PURE__ */ new WeakMap(); + valueSideChannel.set(sentinel, sideChannel); + push_to_array(values, inner_stringify( + value, + key_prefix, + generateArrayPrefix, + commaRoundTrip, + allowEmptyArrays, + strictNullHandling, + skipNulls, + encodeDotInKeys, + // @ts-ignore + generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, + filter, + sort, + allowDots, + serializeDate, + format, + formatter, + encodeValuesOnly, + charset, + valueSideChannel + )); + } + return values; +} +function normalize_stringify_options(opts = defaults) { + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") { + throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") { + throw new TypeError("Encoder has to be a function."); + } + const charset = opts.charset || defaults.charset; + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + let format = default_format; + if (typeof opts.format !== "undefined") { + if (!has(formatters, opts.format)) { + throw new TypeError("Unknown format option provided."); } - else { - str = `${str}:`; - if (keyComment) - str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment)); + format = opts.format; + } + const formatter = formatters[format]; + let filter = defaults.filter; + if (typeof opts.filter === "function" || isArray(opts.filter)) { + filter = opts.filter; + } + let arrayFormat; + if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) { + arrayFormat = opts.arrayFormat; + } else if ("indices" in opts) { + arrayFormat = opts.indices ? "indices" : "repeat"; + } else { + arrayFormat = defaults.arrayFormat; + } + if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") { + throw new TypeError("`commaRoundTrip` must be a boolean, or absent"); + } + const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix, + // @ts-ignore + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays, + arrayFormat, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel, + commaRoundTrip: !!opts.commaRoundTrip, + delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter, + encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode, + encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys, + encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder, + encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly, + filter, + format, + formatter, + serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate, + skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls, + // @ts-ignore + sort: typeof opts.sort === "function" ? opts.sort : null, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling + }; +} +function stringify(object, opts = {}) { + let obj = object; + const options = normalize_stringify_options(opts); + let obj_keys; + let filter; + if (typeof options.filter === "function") { + filter = options.filter; + obj = filter("", obj); + } else if (isArray(options.filter)) { + filter = options.filter; + obj_keys = filter; + } + const keys = []; + if (typeof obj !== "object" || obj === null) { + return ""; + } + const generateArrayPrefix = array_prefix_generators[options.arrayFormat]; + const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip; + if (!obj_keys) { + obj_keys = Object.keys(obj); + } + if (options.sort) { + obj_keys.sort(options.sort); + } + const sideChannel = /* @__PURE__ */ new WeakMap(); + for (let i = 0; i < obj_keys.length; ++i) { + const key = obj_keys[i]; + if (options.skipNulls && obj[key] === null) { + continue; + } + push_to_array(keys, inner_stringify( + obj[key], + key, + // @ts-expect-error + generateArrayPrefix, + commaRoundTrip, + options.allowEmptyArrays, + options.strictNullHandling, + options.skipNulls, + options.encodeDotInKeys, + options.encode ? options.encoder : null, + options.filter, + options.sort, + options.allowDots, + options.serializeDate, + options.format, + options.formatter, + options.encodeValuesOnly, + options.charset, + sideChannel + )); + } + const joined = keys.join(options.delimiter); + let prefix = options.addQueryPrefix === true ? "?" : ""; + if (options.charsetSentinel) { + if (options.charset === "iso-8859-1") { + prefix += "utf8=%26%2310003%3B&"; + } else { + prefix += "utf8=%E2%9C%93&"; } - let vsb, vcb, valueComment; - if (identity.isNode(value)) { - vsb = !!value.spaceBefore; - vcb = value.commentBefore; - valueComment = value.comment; + } + return joined.length > 0 ? prefix + joined : ""; +} + +// node_modules/@stainless-api/sdk/internal/utils/log.mjs +var levelNumbers = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500 +}; +var parseLogLevel = (maybeLevel, sourceName, client) => { + if (!maybeLevel) { + return void 0; + } + if (hasOwn(levelNumbers, maybeLevel)) { + return maybeLevel; + } + loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`); + return void 0; +}; +function noop() { +} +function makeLogFn(fnLevel, logger, logLevel) { + if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) { + return noop; + } else { + return logger[fnLevel].bind(logger); + } +} +var noopLogger = { + error: noop, + warn: noop, + info: noop, + debug: noop +}; +var cachedLoggers = /* @__PURE__ */ new WeakMap(); +function loggerFor(client) { + const logger = client.logger; + const logLevel = client.logLevel ?? "off"; + if (!logger) { + return noopLogger; + } + const cachedLogger = cachedLoggers.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) { + return cachedLogger[1]; + } + const levelLogger = { + error: makeLogFn("error", logger, logLevel), + warn: makeLogFn("warn", logger, logLevel), + info: makeLogFn("info", logger, logLevel), + debug: makeLogFn("debug", logger, logLevel) + }; + cachedLoggers.set(logger, [logLevel, levelLogger]); + return levelLogger; +} +var formatRequestDetails = (details) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options["headers"]; + } + if (details.headers) { + details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [ + name, + name.toLowerCase() === "authorization" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value + ])); + } + if ("retryOfRequestLogID" in details) { + if (details.retryOfRequestLogID) { + details.retryOf = details.retryOfRequestLogID; + } + delete details.retryOfRequestLogID; + } + return details; +}; + +// node_modules/@stainless-api/sdk/internal/parse.mjs +async function defaultParseResponse(client, props) { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + const body = await (async () => { + if (response.status === 204) { + return null; } - else { - vsb = false; - vcb = null; - valueComment = null; - if (value && typeof value === 'object') - value = doc.createNode(value); + if (props.options.__binaryResponse) { + return response; + } + const contentType = response.headers.get("content-type"); + const mediaType = contentType?.split(";")[0]?.trim(); + const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json"); + if (isJSON) { + const json = await response.json(); + return json; + } + const text = await response.text(); + return text; + })(); + loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body, + durationMs: Date.now() - startTime + })); + return body; +} + +// node_modules/@stainless-api/sdk/core/api-promise.mjs +var _APIPromise_client; +var APIPromise = class _APIPromise extends Promise { + constructor(client, responsePromise, parseResponse = defaultParseResponse) { + super((resolve) => { + resolve(null); + }); + this.responsePromise = responsePromise; + this.parseResponse = parseResponse; + _APIPromise_client.set(this, void 0); + __classPrivateFieldSet(this, _APIPromise_client, client, "f"); + } + _thenUnwrap(transform) { + return new _APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props)); + } + /** + * Gets the raw `Response` instance instead of parsing the response + * data. + * + * If you want to parse the response body but still get the `Response` + * instance, you can use {@link withResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + asResponse() { + return this.responsePromise.then((p) => p.response); + } + /** + * Gets the parsed response data and the raw `Response` instance. + * + * If you just want to get the raw `Response` instance without parsing it, + * you can use {@link asResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + async withResponse() { + const [data, response] = await Promise.all([this.parse(), this.asResponse()]); + return { data, response }; + } + parse() { + if (!this.parsedPromise) { + this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet(this, _APIPromise_client, "f"), data)); } - ctx.implicitKey = false; - if (!explicitKey && !keyComment && identity.isScalar(value)) - ctx.indentAtStart = str.length + 1; - chompKeep = false; - if (!indentSeq && - indentStep.length >= 2 && - !ctx.inFlow && - !explicitKey && - identity.isSeq(value) && - !value.flow && - !value.tag && - !value.anchor) { - // If indentSeq === false, consider '- ' as part of indentation where possible - ctx.indent = ctx.indent.substring(2); + return this.parsedPromise; + } + then(onfulfilled, onrejected) { + return this.parse().then(onfulfilled, onrejected); + } + catch(onrejected) { + return this.parse().catch(onrejected); + } + finally(onfinally) { + return this.parse().finally(onfinally); + } +}; +_APIPromise_client = /* @__PURE__ */ new WeakMap(); + +// node_modules/@stainless-api/sdk/core/pagination.mjs +var _AbstractPage_client; +var AbstractPage = class { + constructor(client, response, body, options) { + _AbstractPage_client.set(this, void 0); + __classPrivateFieldSet(this, _AbstractPage_client, client, "f"); + this.options = options; + this.response = response; + this.body = body; + } + hasNextPage() { + const items = this.getPaginatedItems(); + if (!items.length) + return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + const nextOptions = this.nextPageRequestOptions(); + if (!nextOptions) { + throw new StainlessError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); } - let valueCommentDone = false; - const valueStr = stringify.stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true)); - let ws = ' '; - if (keyComment || vsb || vcb) { - ws = vsb ? '\n' : ''; - if (vcb) { - const cs = commentString(vcb); - ws += `\n${stringifyComment.indentComment(cs, ctx.indent)}`; - } - if (valueStr === '' && !ctx.inFlow) { - if (ws === '\n') - ws = '\n\n'; - } - else { - ws += `\n${ctx.indent}`; - } + return await __classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions); + } + async *iterPages() { + let page = this; + yield page; + while (page.hasNextPage()) { + page = await page.getNextPage(); + yield page; } - else if (!explicitKey && identity.isCollection(value)) { - const vs0 = valueStr[0]; - const nl0 = valueStr.indexOf('\n'); - const hasNewline = nl0 !== -1; - const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0; - if (hasNewline || !flow) { - let hasPropsLine = false; - if (hasNewline && (vs0 === '&' || vs0 === '!')) { - let sp0 = valueStr.indexOf(' '); - if (vs0 === '&' && - sp0 !== -1 && - sp0 < nl0 && - valueStr[sp0 + 1] === '!') { - sp0 = valueStr.indexOf(' ', sp0 + 1); - } - if (sp0 === -1 || nl0 < sp0) - hasPropsLine = true; - } - if (!hasPropsLine) - ws = `\n${ctx.indent}`; - } + } + async *[(_AbstractPage_client = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (const page of this.iterPages()) { + for (const item of page.getPaginatedItems()) { + yield item; + } } - else if (valueStr === '' || valueStr[0] === '\n') { - ws = ''; + } +}; +var PagePromise = class extends APIPromise { + constructor(client, request, Page2) { + super(client, request, async (client2, props) => new Page2(client2, props.response, await defaultParseResponse(client2, props), props.options)); + } + /** + * Allow auto-paginating iteration on an unawaited list call, eg: + * + * for await (const item of client.items.list()) { + * console.log(item) + * } + */ + async *[Symbol.asyncIterator]() { + const page = await this; + for await (const item of page) { + yield item; } - str += ws + valueStr; - if (ctx.inFlow) { - if (valueCommentDone && onComment) - onComment(); + } +}; +var Page = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.next_cursor = body.next_cursor || ""; + } + getPaginatedItems() { + return this.data ?? []; + } + nextPageRequestOptions() { + const cursor = this.next_cursor; + if (!cursor) { + return null; } - else if (valueComment && !valueCommentDone) { - str += stringifyComment.lineComment(str, ctx.indent, commentString(valueComment)); + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + cursor + } + }; + } +}; + +// node_modules/@stainless-api/sdk/internal/uploads.mjs +var checkFileSupport = () => { + if (typeof File === "undefined") { + const { process: process2 } = globalThis; + const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20; + throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : "")); + } +}; +function makeFile(fileBits, fileName, options) { + checkFileSupport(); + return new File(fileBits, fileName ?? "unknown_file", options); +} +function getName(value) { + return (typeof value === "object" && value !== null && ("name" in value && value.name && String(value.name) || "url" in value && value.url && String(value.url) || "filename" in value && value.filename && String(value.filename) || "path" in value && value.path && String(value.path)) || "").split(/[\\/]/).pop() || void 0; +} +var isAsyncIterable = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function"; + +// node_modules/@stainless-api/sdk/internal/to-file.mjs +var isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function"; +var isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value); +var isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function"; +async function toFile(value, name, options) { + checkFileSupport(); + value = await value; + if (isFileLike(value)) { + if (value instanceof File) { + return value; } - else if (chompKeep && onChompKeep) { - onChompKeep(); + return makeFile([await value.arrayBuffer()], value.name); + } + if (isResponseLike(value)) { + const blob = await value.blob(); + name || (name = new URL(value.url).pathname.split(/[\\/]/).pop()); + return makeFile(await getBytes(blob), name, options); + } + const parts = await getBytes(value); + name || (name = getName(value)); + if (!options?.type) { + const type = parts.find((part) => typeof part === "object" && "type" in part && part.type); + if (typeof type === "string") { + options = { ...options, type }; } - return str; + } + return makeFile(parts, name, options); +} +async function getBytes(value) { + let parts = []; + if (typeof value === "string" || ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc. + value instanceof ArrayBuffer) { + parts.push(value); + } else if (isBlobLike(value)) { + parts.push(value instanceof Blob ? value : await value.arrayBuffer()); + } else if (isAsyncIterable(value)) { + for await (const chunk of value) { + parts.push(...await getBytes(chunk)); + } + } else { + const constructor = value?.constructor?.name; + throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ""}${propsForError(value)}`); + } + return parts; +} +function propsForError(value) { + if (typeof value !== "object" || value === null) + return ""; + const props = Object.getOwnPropertyNames(value); + return `; props: [${props.map((p) => `"${p}"`).join(", ")}]`; } -exports.stringifyPair = stringifyPair; +// node_modules/@stainless-api/sdk/core/resource.mjs +var APIResource = class { + constructor(client) { + this._client = client; + } +}; + +// node_modules/@stainless-api/sdk/internal/utils/path.mjs +function encodeURIPath(str) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); +var createPathTagFunction = (pathEncoder = encodeURIPath) => function path2(statics, ...params) { + if (statics.length === 1) + return statics[0]; + let postPath = false; + const invalidSegments = []; + const path3 = statics.reduce((previousValue, currentValue, index) => { + if (/[?#]/.test(currentValue)) { + postPath = true; + } + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value); + if (index !== params.length && (value == null || typeof value === "object" && // handle values from other realms + value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)?.toString)) { + encoded = value + ""; + invalidSegments.push({ + start: previousValue.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter` + }); + } + return previousValue + currentValue + (index === params.length ? "" : encoded); + }, ""); + const pathOnly = path3.split(/[?#]/, 1)[0]; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { + invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can't be safely passed as a path parameter` + }); + } + invalidSegments.sort((a, b) => a.start - b.start); + if (invalidSegments.length > 0) { + let lastEnd = 0; + const underline = invalidSegments.reduce((acc, segment) => { + const spaces = " ".repeat(segment.start - lastEnd); + const arrows = "^".repeat(segment.length); + lastEnd = segment.start + segment.length; + return acc + spaces + arrows; + }, ""); + throw new StainlessError(`Path parameters result in path with invalid segments: +${invalidSegments.map((e) => e.error).join("\n")} +${path3} +${underline}`); + } + return path3; +}; +var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath); + +// node_modules/@stainless-api/sdk/resources/builds/diagnostics.mjs +var Diagnostics = class extends APIResource { + /** + * Get diagnostics for a build + */ + list(buildID, query = {}, options) { + return this._client.getAPIList(path`/v0/builds/${buildID}/diagnostics`, Page, { + query, + ...options + }); + } +}; + +// node_modules/@stainless-api/sdk/resources/builds/target-outputs.mjs +var TargetOutputs = class extends APIResource { + /** + * Download the output of a build target + */ + retrieve(query, options) { + return this._client.get("/v0/build_target_outputs", { query, ...options }); + } +}; +// node_modules/@stainless-api/sdk/resources/builds/builds.mjs +var Builds = class extends APIResource { + constructor() { + super(...arguments); + this.diagnostics = new Diagnostics(this._client); + this.targetOutputs = new TargetOutputs(this._client); + } + /** + * Create a new build + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds", { body: { project, ...body }, ...options }); + } + /** + * Retrieve a build by ID + */ + retrieve(buildID, options) { + return this._client.get(path`/v0/builds/${buildID}`, options); + } + /** + * List builds for a project + */ + list(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.getAPIList("/v0/builds", Page, { + query: { project, ...query }, + ...options + }); + } + /** + * Creates two builds whose outputs can be compared directly + */ + compare(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds/compare", { body: { project, ...body }, ...options }); + } +}; +Builds.Diagnostics = Diagnostics; +Builds.TargetOutputs = TargetOutputs; -/***/ }), +// node_modules/@stainless-api/sdk/resources/generate.mjs +var Generate = class extends APIResource { + createSpec(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/generate/spec", { body: { project, ...body }, ...options }); + } +}; -/***/ 3069: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +// node_modules/@stainless-api/sdk/resources/orgs.mjs +var Orgs = class extends APIResource { + /** + * Retrieve an organization by name + */ + retrieve(org, options) { + return this._client.get(path`/v0/orgs/${org}`, options); + } + /** + * List organizations the user has access to + */ + list(options) { + return this._client.get("/v0/orgs", options); + } +}; -"use strict"; +// node_modules/@stainless-api/sdk/resources/projects/branches.mjs +var Branches = class extends APIResource { + /** + * Create a new branch for a project + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/branches`, { body, ...options }); + } + /** + * Retrieve a project branch + */ + retrieve(branch, params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/branches/${branch}`, options); + } +}; +// node_modules/@stainless-api/sdk/resources/projects/configs.mjs +var Configs = class extends APIResource { + /** + * Retrieve configuration files for a project + */ + retrieve(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/configs`, { query, ...options }); + } + /** + * Generate configuration suggestions based on an OpenAPI spec + */ + guess(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/configs/guess`, { body, ...options }); + } +}; -var Scalar = __nccwpck_require__(3301); -var foldFlowLines = __nccwpck_require__(4475); +// node_modules/@stainless-api/sdk/resources/projects/projects.mjs +var Projects = class extends APIResource { + constructor() { + super(...arguments); + this.branches = new Branches(this._client); + this.configs = new Configs(this._client); + } + /** + * Create a new project + */ + create(body, options) { + return this._client.post("/v0/projects", { body, ...options }); + } + /** + * Retrieve a project by name + */ + retrieve(params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}`, options); + } + /** + * Update a project's properties + */ + update(params = {}, options) { + const { project = this._client.project, ...body } = params ?? {}; + return this._client.patch(path`/v0/projects/${project}`, { body, ...options }); + } + /** + * List projects in an organization, from oldest to newest + */ + list(query = {}, options) { + return this._client.getAPIList("/v0/projects", Page, { query, ...options }); + } +}; +Projects.Branches = Branches; +Projects.Configs = Configs; -const getFoldOptions = (ctx, isBlock) => ({ - indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart, - lineWidth: ctx.options.lineWidth, - minContentWidth: ctx.options.minContentWidth -}); -// Also checks for lines starting with %, as parsing the output as YAML 1.1 will -// presume that's starting a new document. -const containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str); -function lineLengthOverLimit(str, lineWidth, indentLength) { - if (!lineWidth || lineWidth < 0) - return false; - const limit = lineWidth - indentLength; - const strLen = str.length; - if (strLen <= limit) - return false; - for (let i = 0, start = 0; i < strLen; ++i) { - if (str[i] === '\n') { - if (i - start > limit) - return true; - start = i + 1; - if (strLen - start <= limit) - return false; - } - } - return true; -} -function doubleQuotedString(value, ctx) { - const json = JSON.stringify(value); - if (ctx.options.doubleQuotedAsJSON) - return json; - const { implicitKey } = ctx; - const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength; - const indent = ctx.indent || (containsDocumentMarker(value) ? ' ' : ''); - let str = ''; - let start = 0; - for (let i = 0, ch = json[i]; ch; ch = json[++i]) { - if (ch === ' ' && json[i + 1] === '\\' && json[i + 2] === 'n') { - // space before newline needs to be escaped to not be folded - str += json.slice(start, i) + '\\ '; - i += 1; - start = i; - ch = '\\'; - } - if (ch === '\\') - switch (json[i + 1]) { - case 'u': - { - str += json.slice(start, i); - const code = json.substr(i + 2, 4); - switch (code) { - case '0000': - str += '\\0'; - break; - case '0007': - str += '\\a'; - break; - case '000b': - str += '\\v'; - break; - case '001b': - str += '\\e'; - break; - case '0085': - str += '\\N'; - break; - case '00a0': - str += '\\_'; - break; - case '2028': - str += '\\L'; - break; - case '2029': - str += '\\P'; - break; - default: - if (code.substr(0, 2) === '00') - str += '\\x' + code.substr(2); - else - str += json.substr(i, 6); - } - i += 5; - start = i + 1; - } - break; - case 'n': - if (implicitKey || - json[i + 2] === '"' || - json.length < minMultiLineLength) { - i += 1; - } - else { - // folding will eat first newline - str += json.slice(start, i) + '\n\n'; - while (json[i + 2] === '\\' && - json[i + 3] === 'n' && - json[i + 4] !== '"') { - str += '\n'; - i += 2; - } - str += indent; - // space after newline needs to be escaped to not be folded - if (json[i + 2] === ' ') - str += '\\'; - i += 1; - start = i + 1; - } - break; - default: - i += 1; - } +// node_modules/@stainless-api/sdk/internal/headers.mjs +var brand_privateNullableHeaders = /* @__PURE__ */ Symbol("brand.privateNullableHeaders"); +function* iterateHeaders(headers) { + if (!headers) + return; + if (brand_privateNullableHeaders in headers) { + const { values, nulls } = headers; + yield* values.entries(); + for (const name of nulls) { + yield [name, null]; } - str = start ? str + json.slice(start) : json; - return implicitKey - ? str - : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false)); -} -function singleQuotedString(value, ctx) { - if (ctx.options.singleQuote === false || - (ctx.implicitKey && value.includes('\n')) || - /[ \t]\n|\n[ \t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline - ) - return doubleQuotedString(value, ctx); - const indent = ctx.indent || (containsDocumentMarker(value) ? ' ' : ''); - const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'"; - return ctx.implicitKey - ? res - : foldFlowLines.foldFlowLines(res, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false)); -} -function quotedString(value, ctx) { - const { singleQuote } = ctx.options; - let qs; - if (singleQuote === false) - qs = doubleQuotedString; - else { - const hasDouble = value.includes('"'); - const hasSingle = value.includes("'"); - if (hasDouble && !hasSingle) - qs = singleQuotedString; - else if (hasSingle && !hasDouble) - qs = doubleQuotedString; - else - qs = singleQuote ? singleQuotedString : doubleQuotedString; + return; + } + let shouldClear = false; + let iter; + if (headers instanceof Headers) { + iter = headers.entries(); + } else if (isReadonlyArray(headers)) { + iter = headers; + } else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== "string") + throw new TypeError("expected header name to be a string"); + const values = isReadonlyArray(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === void 0) + continue; + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} +var buildHeaders = (newHeaders) => { + const targetHeaders = new Headers(); + const nullHeaders = /* @__PURE__ */ new Set(); + for (const headers of newHeaders) { + const seenHeaders = /* @__PURE__ */ new Set(); + for (const [name, value] of iterateHeaders(headers)) { + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(name); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(name); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(name, value); + nullHeaders.delete(lowerName); + } } - return qs(value, ctx); -} -// The negative lookbehind avoids a polynomial search, -// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind -let blockEndNewlines; -try { - blockEndNewlines = new RegExp('(^|(? { + if (typeof globalThis.process !== "undefined") { + return globalThis.process.env?.[env]?.trim() ?? void 0; + } + if (typeof globalThis.Deno !== "undefined") { + return globalThis.Deno.env?.get?.(env)?.trim(); + } + return void 0; +}; + +// node_modules/@stainless-api/sdk/lib/unwrap.mjs +async function unwrapFile(value) { + if (value === null) { + return null; + } + if (value.type === "content") { + return value.content; + } + const response = await fetch(value.url); + return response.text(); } -function blockString({ comment, type, value }, ctx, onComment, onChompKeep) { - const { blockQuote, commentString, lineWidth } = ctx.options; - // 1. Block can't end in whitespace unless the last line is non-empty. - // 2. Strings consisting of only whitespace are best rendered explicitly. - if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) { - return quotedString(value, ctx); - } - const indent = ctx.indent || - (ctx.forceBlockIndent || containsDocumentMarker(value) ? ' ' : ''); - const literal = blockQuote === 'literal' - ? true - : blockQuote === 'folded' || type === Scalar.Scalar.BLOCK_FOLDED - ? false - : type === Scalar.Scalar.BLOCK_LITERAL - ? true - : !lineLengthOverLimit(value, lineWidth, indent.length); - if (!value) - return literal ? '|\n' : '>\n'; - // determine chomping from whitespace at value end - let chomp; - let endStart; - for (endStart = value.length; endStart > 0; --endStart) { - const ch = value[endStart - 1]; - if (ch !== '\n' && ch !== '\t' && ch !== ' ') - break; - } - let end = value.substring(endStart); - const endNlPos = end.indexOf('\n'); - if (endNlPos === -1) { - chomp = '-'; // strip - } - else if (value === end || endNlPos !== end.length - 1) { - chomp = '+'; // keep - if (onChompKeep) - onChompKeep(); - } - else { - chomp = ''; // clip - } - if (end) { - value = value.slice(0, -end.length); - if (end[end.length - 1] === '\n') - end = end.slice(0, -1); - end = end.replace(blockEndNewlines, `$&${indent}`); - } - // determine indent indicator from whitespace at value start - let startWithSpace = false; - let startEnd; - let startNlPos = -1; - for (startEnd = 0; startEnd < value.length; ++startEnd) { - const ch = value[startEnd]; - if (ch === ' ') - startWithSpace = true; - else if (ch === '\n') - startNlPos = startEnd; - else - break; - } - let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd); - if (start) { - value = value.substring(start.length); - start = start.replace(/\n+/g, `$&${indent}`); - } - const indentSize = indent ? '2' : '1'; // root is at -1 - // Leading | or > is added later - let header = (startWithSpace ? indentSize : '') + chomp; - if (comment) { - header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' ')); - if (onComment) - onComment(); + +// node_modules/@stainless-api/sdk/client.mjs +var _Stainless_instances; +var _a; +var _Stainless_encoder; +var _Stainless_baseURLOverridden; +var Stainless = class { + /** + * API Client for interfacing with the Stainless API. + * + * @param {string | null | undefined} [opts.apiKey=process.env['STAINLESS_API_KEY'] ?? null] + * @param {string | null | undefined} [opts.project] + * @param {string} [opts.baseURL=process.env['STAINLESS_BASE_URL'] ?? https://api.stainless.com] - Override the default base URL for the API. + * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out. + * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls. + * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation. + * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request. + * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API. + * @param {Record} opts.defaultQuery - Default query parameters to include with every request to the API. + */ + constructor({ baseURL = readEnv("STAINLESS_BASE_URL"), apiKey = readEnv("STAINLESS_API_KEY") ?? null, project = null, ...opts } = {}) { + _Stainless_instances.add(this); + _Stainless_encoder.set(this, void 0); + this.projects = new Projects(this); + this.builds = new Builds(this); + this.orgs = new Orgs(this); + this.generate = new Generate(this); + const options = { + apiKey, + project, + ...opts, + baseURL: baseURL || `https://api.stainless.com` + }; + this.baseURL = options.baseURL; + this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT; + this.logger = options.logger ?? console; + const defaultLogLevel = "warn"; + this.logLevel = defaultLogLevel; + this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("STAINLESS_LOG"), "process.env['STAINLESS_LOG']", this) ?? defaultLogLevel; + this.fetchOptions = options.fetchOptions; + this.maxRetries = options.maxRetries ?? 2; + this.fetch = options.fetch ?? getDefaultFetch(); + __classPrivateFieldSet(this, _Stainless_encoder, FallbackEncoder, "f"); + this._options = options; + this.apiKey = apiKey; + this.project = project; + } + /** + * Create a new client instance re-using the same options given to the current client with optional overriding. + */ + withOptions(options) { + return new this.constructor({ + ...this._options, + baseURL: this.baseURL, + maxRetries: this.maxRetries, + timeout: this.timeout, + logger: this.logger, + logLevel: this.logLevel, + fetch: this.fetch, + fetchOptions: this.fetchOptions, + apiKey: this.apiKey, + project: this.project, + ...options + }); + } + defaultQuery() { + return this._options.defaultQuery; + } + validateHeaders({ values, nulls }) { + if (this.apiKey && values.get("authorization")) { + return; } - if (!literal) { - const foldedValue = value - .replace(/\n+/g, '\n$&') - .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded - // ^ more-ind. ^ empty ^ capture next empty lines only at end of indent - .replace(/\n+/g, `$&${indent}`); - let literalFallback = false; - const foldOptions = getFoldOptions(ctx, true); - if (blockQuote !== 'folded' && type !== Scalar.Scalar.BLOCK_FOLDED) { - foldOptions.onOverflow = () => { - literalFallback = true; - }; - } - const body = foldFlowLines.foldFlowLines(`${start}${foldedValue}${end}`, indent, foldFlowLines.FOLD_BLOCK, foldOptions); - if (!literalFallback) - return `>${header}\n${indent}${body}`; + if (nulls.has("authorization")) { + return; } - value = value.replace(/\n+/g, `$&${indent}`); - return `|${header}\n${indent}${start}${value}${end}`; -} -function plainString(item, ctx, onComment, onChompKeep) { - const { type, value } = item; - const { actualString, implicitKey, indent, indentStep, inFlow } = ctx; - if ((implicitKey && value.includes('\n')) || - (inFlow && /[[\]{},]/.test(value))) { - return quotedString(value, ctx); + throw new Error('Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted'); + } + authHeaders(opts) { + if (this.apiKey == null) { + return void 0; } - if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) { - // not allowed: - // - '-' or '?' - // - start with an indicator character (except [?:-]) or /[?-] / - // - '\n ', ': ' or ' \n' anywhere - // - '#' not preceded by a non-space char - // - end with ' ' or ':' - return implicitKey || inFlow || !value.includes('\n') - ? quotedString(value, ctx) - : blockString(item, ctx, onComment, onChompKeep); - } - if (!implicitKey && - !inFlow && - type !== Scalar.Scalar.PLAIN && - value.includes('\n')) { - // Where allowed & type not set explicitly, prefer block style for multiline strings - return blockString(item, ctx, onComment, onChompKeep); + return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]); + } + stringifyQuery(query) { + return stringify(query, { arrayFormat: "comma" }); + } + getUserAgent() { + return `${this.constructor.name}/JS ${VERSION}`; + } + defaultIdempotencyKey() { + return `stainless-node-retry-${uuid4()}`; + } + makeStatusError(status, error2, message, headers) { + return APIError.generate(status, error2, message, headers); + } + buildURL(path2, query, defaultBaseURL) { + const baseURL = !__classPrivateFieldGet(this, _Stainless_instances, "m", _Stainless_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL; + const url = isAbsoluteURL(path2) ? new URL(path2) : new URL(baseURL + (baseURL.endsWith("/") && path2.startsWith("/") ? path2.slice(1) : path2)); + const defaultQuery = this.defaultQuery(); + if (!isEmptyObj(defaultQuery)) { + query = { ...defaultQuery, ...query }; } - if (containsDocumentMarker(value)) { - if (indent === '') { - ctx.forceBlockIndent = true; - return blockString(item, ctx, onComment, onChompKeep); - } - else if (implicitKey && indent === indentStep) { - return quotedString(value, ctx); - } + if (typeof query === "object" && query && !Array.isArray(query)) { + url.search = this.stringifyQuery(query); } - const str = value.replace(/\n+/g, `$&\n${indent}`); - // Verify that output will be parsed as a string, as e.g. plain numbers and - // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'), - // and others in v1.1. - if (actualString) { - const test = (tag) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str); - const { compat, tags } = ctx.doc.schema; - if (tags.some(test) || compat?.some(test)) - return quotedString(value, ctx); + return url.toString(); + } + /** + * Used as a callback for mutating the given `FinalRequestOptions` object. + */ + async prepareOptions(options) { + } + /** + * Used as a callback for mutating the given `RequestInit` object. + * + * This is useful for cases where you want to add certain headers based off of + * the request properties, e.g. `method` or `url`. + */ + async prepareRequest(request, { url, options }) { + } + get(path2, opts) { + return this.methodRequest("get", path2, opts); + } + post(path2, opts) { + return this.methodRequest("post", path2, opts); + } + patch(path2, opts) { + return this.methodRequest("patch", path2, opts); + } + put(path2, opts) { + return this.methodRequest("put", path2, opts); + } + delete(path2, opts) { + return this.methodRequest("delete", path2, opts); + } + methodRequest(method, path2, opts) { + return this.request(Promise.resolve(opts).then((opts2) => { + return { method, path: path2, ...opts2 }; + })); + } + request(options, remainingRetries = null) { + return new APIPromise(this, this.makeRequest(options, remainingRetries, void 0)); + } + async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { + const options = await optionsInput; + const maxRetries = options.maxRetries ?? this.maxRetries; + if (retriesRemaining == null) { + retriesRemaining = maxRetries; + } + await this.prepareOptions(options); + const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); + await this.prepareRequest(req, { url, options }); + const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0"); + const retryLogStr = retryOfRequestLogID === void 0 ? "" : `, retryOf: ${retryOfRequestLogID}`; + const startTime = Date.now(); + loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({ + retryOfRequestLogID, + method: options.method, + url, + options, + headers: req.headers + })); + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const controller = new AbortController(); + const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError); + const headersTime = Date.now(); + if (response instanceof Error) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : "")); + if (retriesRemaining) { + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID); + } + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + if (isTimeout) { + throw new APIConnectionTimeoutError(); + } + throw new APIConnectionError({ cause: response }); + } + const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`; + if (!response.ok) { + const shouldRetry = this.shouldRetry(response); + if (retriesRemaining && shouldRetry) { + const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`; + await CancelReadableStream(response.body); + loggerFor(this).info(`${responseInfo} - ${retryMessage2}`); + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers); + } + const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`; + loggerFor(this).info(`${responseInfo} - ${retryMessage}`); + const errText = await response.text().catch((err2) => castToError(err2).message); + const errJSON = safeJSON(errText); + const errMessage = errJSON ? void 0 : errText; + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + message: errMessage, + durationMs: Date.now() - startTime + })); + const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers); + throw err; + } + loggerFor(this).info(responseInfo); + loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return { response, options, controller, requestLogID, retryOfRequestLogID, startTime }; + } + getAPIList(path2, Page2, opts) { + return this.requestAPIList(Page2, { method: "get", path: path2, ...opts }); + } + requestAPIList(Page2, options) { + const request = this.makeRequest(options, null, void 0); + return new PagePromise(this, request, Page2); + } + async fetchWithTimeout(url, init, ms, controller) { + const { signal, method, ...options } = init || {}; + if (signal) + signal.addEventListener("abort", () => controller.abort()); + const timeout = setTimeout(() => controller.abort(), ms); + const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body; + const fetchOptions = { + signal: controller.signal, + ...isReadableBody ? { duplex: "half" } : {}, + method: "GET", + ...options + }; + if (method) { + fetchOptions.method = method.toUpperCase(); } - return implicitKey - ? str - : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false)); -} -function stringifyString(item, ctx, onComment, onChompKeep) { - const { implicitKey, inFlow } = ctx; - const ss = typeof item.value === 'string' - ? item - : Object.assign({}, item, { value: String(item.value) }); - let { type } = item; - if (type !== Scalar.Scalar.QUOTE_DOUBLE) { - // force double quotes on control characters & unpaired surrogates - if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value)) - type = Scalar.Scalar.QUOTE_DOUBLE; + try { + return await this.fetch.call(void 0, url, fetchOptions); + } finally { + clearTimeout(timeout); + } + } + shouldRetry(response) { + const shouldRetryHeader = response.headers.get("x-should-retry"); + if (shouldRetryHeader === "true") + return true; + if (shouldRetryHeader === "false") + return false; + if (response.status === 408) + return true; + if (response.status === 409) + return true; + if (response.status === 429) + return true; + if (response.status >= 500) + return true; + return false; + } + async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) { + let timeoutMillis; + const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms"); + if (retryAfterMillisHeader) { + const timeoutMs = parseFloat(retryAfterMillisHeader); + if (!Number.isNaN(timeoutMs)) { + timeoutMillis = timeoutMs; + } } - const _stringify = (_type) => { - switch (_type) { - case Scalar.Scalar.BLOCK_FOLDED: - case Scalar.Scalar.BLOCK_LITERAL: - return implicitKey || inFlow - ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers - : blockString(ss, ctx, onComment, onChompKeep); - case Scalar.Scalar.QUOTE_DOUBLE: - return doubleQuotedString(ss.value, ctx); - case Scalar.Scalar.QUOTE_SINGLE: - return singleQuotedString(ss.value, ctx); - case Scalar.Scalar.PLAIN: - return plainString(ss, ctx, onComment, onChompKeep); - default: - return null; - } + const retryAfterHeader = responseHeaders?.get("retry-after"); + if (retryAfterHeader && !timeoutMillis) { + const timeoutSeconds = parseFloat(retryAfterHeader); + if (!Number.isNaN(timeoutSeconds)) { + timeoutMillis = timeoutSeconds * 1e3; + } else { + timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + } + if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3)) { + const maxRetries = options.maxRetries ?? this.maxRetries; + timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); + } + await sleep(timeoutMillis); + return this.makeRequest(options, retriesRemaining - 1, requestLogID); + } + calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) { + const initialRetryDelay = 0.5; + const maxRetryDelay = 8; + const numRetries = maxRetries - retriesRemaining; + const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay); + const jitter = 1 - Math.random() * 0.25; + return sleepSeconds * jitter * 1e3; + } + buildRequest(inputOptions, { retryCount = 0 } = {}) { + const options = { ...inputOptions }; + const { method, path: path2, query, defaultBaseURL } = options; + const url = this.buildURL(path2, query, defaultBaseURL); + if ("timeout" in options) + validatePositiveInteger("timeout", options.timeout); + options.timeout = options.timeout ?? this.timeout; + const { bodyHeaders, body } = this.buildBody({ options }); + const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount }); + const req = { + method, + headers: reqHeaders, + ...options.signal && { signal: options.signal }, + ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" }, + ...body && { body }, + ...this.fetchOptions ?? {}, + ...options.fetchOptions ?? {} }; - let res = _stringify(type); - if (res === null) { - const { defaultKeyType, defaultStringType } = ctx.options; - const t = (implicitKey && defaultKeyType) || defaultStringType; - res = _stringify(t); - if (res === null) - throw new Error(`Unsupported default string type ${t}`); + return { req, url, timeout: options.timeout }; + } + buildHeaders({ options, method, bodyHeaders, retryCount }) { + let idempotencyHeaders = {}; + if (this.idempotencyHeader && method !== "get") { + if (!options.idempotencyKey) + options.idempotencyKey = this.defaultIdempotencyKey(); + idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; } - return res; -} - -exports.stringifyString = stringifyString; - - -/***/ }), - -/***/ 204: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -var identity = __nccwpck_require__(1127); - -const BREAK = Symbol('break visit'); -const SKIP = Symbol('skip children'); -const REMOVE = Symbol('remove node'); -/** - * Apply a visitor to an AST node or document. - * - * Walks through the tree (depth-first) starting from `node`, calling a - * `visitor` function with three arguments: - * - `key`: For sequence values and map `Pair`, the node's index in the - * collection. Within a `Pair`, `'key'` or `'value'`, correspondingly. - * `null` for the root node. - * - `node`: The current node. - * - `path`: The ancestry of the current node. - * - * The return value of the visitor may be used to control the traversal: - * - `undefined` (default): Do nothing and continue - * - `visit.SKIP`: Do not visit the children of this node, continue with next - * sibling - * - `visit.BREAK`: Terminate traversal completely - * - `visit.REMOVE`: Remove the current node, then continue with the next one - * - `Node`: Replace the current node, then continue by visiting it - * - `number`: While iterating the items of a sequence or map, set the index - * of the next step. This is useful especially if the index of the current - * node has changed. - * - * If `visitor` is a single function, it will be called with all values - * encountered in the tree, including e.g. `null` values. Alternatively, - * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`, - * `Alias` and `Scalar` node. To define the same visitor function for more than - * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar) - * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most - * specific defined one will be used for each node. - */ -function visit(node, visitor) { - const visitor_ = initVisitor(visitor); - if (identity.isDocument(node)) { - const cd = visit_(null, node.contents, visitor_, Object.freeze([node])); - if (cd === REMOVE) - node.contents = null; + const headers = buildHeaders([ + idempotencyHeaders, + { + Accept: "application/json", + "User-Agent": this.getUserAgent(), + "X-Stainless-Retry-Count": String(retryCount), + ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1e3)) } : {}, + ...getPlatformHeaders() + }, + this.authHeaders(options), + this._options.defaultHeaders, + bodyHeaders, + options.headers + ]); + this.validateHeaders(headers); + return headers.values; + } + buildBody({ options: { body, headers: rawHeaders } }) { + if (!body) { + return { bodyHeaders: void 0, body: void 0 }; } - else - visit_(null, node, visitor_, Object.freeze([])); -} -// Without the `as symbol` casts, TS declares these in the `visit` -// namespace using `var`, but then complains about that because -// `unique symbol` must be `const`. -/** Terminate visit traversal completely */ -visit.BREAK = BREAK; -/** Do not visit the children of the current node */ -visit.SKIP = SKIP; -/** Remove the current node */ -visit.REMOVE = REMOVE; -function visit_(key, node, visitor, path) { - const ctrl = callVisitor(key, node, visitor, path); - if (identity.isNode(ctrl) || identity.isPair(ctrl)) { - replaceNode(key, path, ctrl); - return visit_(key, ctrl, visitor, path); - } - if (typeof ctrl !== 'symbol') { - if (identity.isCollection(node)) { - path = Object.freeze(path.concat(node)); - for (let i = 0; i < node.items.length; ++i) { - const ci = visit_(i, node.items[i], visitor, path); - if (typeof ci === 'number') - i = ci - 1; - else if (ci === BREAK) - return BREAK; - else if (ci === REMOVE) { - node.items.splice(i, 1); - i -= 1; - } - } - } - else if (identity.isPair(node)) { - path = Object.freeze(path.concat(node)); - const ck = visit_('key', node.key, visitor, path); - if (ck === BREAK) - return BREAK; - else if (ck === REMOVE) - node.key = null; - const cv = visit_('value', node.value, visitor, path); - if (cv === BREAK) - return BREAK; - else if (cv === REMOVE) - node.value = null; - } - } - return ctrl; -} -/** - * Apply an async visitor to an AST node or document. - * - * Walks through the tree (depth-first) starting from `node`, calling a - * `visitor` function with three arguments: - * - `key`: For sequence values and map `Pair`, the node's index in the - * collection. Within a `Pair`, `'key'` or `'value'`, correspondingly. - * `null` for the root node. - * - `node`: The current node. - * - `path`: The ancestry of the current node. - * - * The return value of the visitor may be used to control the traversal: - * - `Promise`: Must resolve to one of the following values - * - `undefined` (default): Do nothing and continue - * - `visit.SKIP`: Do not visit the children of this node, continue with next - * sibling - * - `visit.BREAK`: Terminate traversal completely - * - `visit.REMOVE`: Remove the current node, then continue with the next one - * - `Node`: Replace the current node, then continue by visiting it - * - `number`: While iterating the items of a sequence or map, set the index - * of the next step. This is useful especially if the index of the current - * node has changed. - * - * If `visitor` is a single function, it will be called with all values - * encountered in the tree, including e.g. `null` values. Alternatively, - * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`, - * `Alias` and `Scalar` node. To define the same visitor function for more than - * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar) - * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most - * specific defined one will be used for each node. - */ -async function visitAsync(node, visitor) { - const visitor_ = initVisitor(visitor); - if (identity.isDocument(node)) { - const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node])); - if (cd === REMOVE) - node.contents = null; + const headers = buildHeaders([rawHeaders]); + if ( + // Pass raw type verbatim + ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && // Preserve legacy string encoding behavior for now + headers.values.has("content-type") || // `Blob` is superset of `File` + body instanceof Blob || // `FormData` -> `multipart/form-data` + body instanceof FormData || // `URLSearchParams` -> `application/x-www-form-urlencoded` + body instanceof URLSearchParams || // Send chunked stream (each chunk has own `length`) + globalThis.ReadableStream && body instanceof globalThis.ReadableStream + ) { + return { bodyHeaders: void 0, body }; + } else if (typeof body === "object" && (Symbol.asyncIterator in body || Symbol.iterator in body && "next" in body && typeof body.next === "function")) { + return { bodyHeaders: void 0, body: ReadableStreamFrom(body) }; + } else { + return __classPrivateFieldGet(this, _Stainless_encoder, "f").call(this, { body, headers }); } - else - await visitAsync_(null, node, visitor_, Object.freeze([])); -} -// Without the `as symbol` casts, TS declares these in the `visit` -// namespace using `var`, but then complains about that because -// `unique symbol` must be `const`. -/** Terminate visit traversal completely */ -visitAsync.BREAK = BREAK; -/** Do not visit the children of the current node */ -visitAsync.SKIP = SKIP; -/** Remove the current node */ -visitAsync.REMOVE = REMOVE; -async function visitAsync_(key, node, visitor, path) { - const ctrl = await callVisitor(key, node, visitor, path); - if (identity.isNode(ctrl) || identity.isPair(ctrl)) { - replaceNode(key, path, ctrl); - return visitAsync_(key, ctrl, visitor, path); - } - if (typeof ctrl !== 'symbol') { - if (identity.isCollection(node)) { - path = Object.freeze(path.concat(node)); - for (let i = 0; i < node.items.length; ++i) { - const ci = await visitAsync_(i, node.items[i], visitor, path); - if (typeof ci === 'number') - i = ci - 1; - else if (ci === BREAK) - return BREAK; - else if (ci === REMOVE) { - node.items.splice(i, 1); - i -= 1; - } - } - } - else if (identity.isPair(node)) { - path = Object.freeze(path.concat(node)); - const ck = await visitAsync_('key', node.key, visitor, path); - if (ck === BREAK) - return BREAK; - else if (ck === REMOVE) - node.key = null; - const cv = await visitAsync_('value', node.value, visitor, path); - if (cv === BREAK) - return BREAK; - else if (cv === REMOVE) - node.value = null; - } - } - return ctrl; + } +}; +_a = Stainless, _Stainless_encoder = /* @__PURE__ */ new WeakMap(), _Stainless_instances = /* @__PURE__ */ new WeakSet(), _Stainless_baseURLOverridden = function _Stainless_baseURLOverridden2() { + return this.baseURL !== "https://api.stainless.com"; +}; +Stainless.Stainless = _a; +Stainless.DEFAULT_TIMEOUT = 6e4; +Stainless.StainlessError = StainlessError; +Stainless.APIError = APIError; +Stainless.APIConnectionError = APIConnectionError; +Stainless.APIConnectionTimeoutError = APIConnectionTimeoutError; +Stainless.APIUserAbortError = APIUserAbortError; +Stainless.NotFoundError = NotFoundError; +Stainless.ConflictError = ConflictError; +Stainless.RateLimitError = RateLimitError; +Stainless.BadRequestError = BadRequestError; +Stainless.AuthenticationError = AuthenticationError; +Stainless.InternalServerError = InternalServerError; +Stainless.PermissionDeniedError = PermissionDeniedError; +Stainless.UnprocessableEntityError = UnprocessableEntityError; +Stainless.toFile = toFile; +Stainless.unwrapFile = unwrapFile; +Stainless.Projects = Projects; +Stainless.Builds = Builds; +Stainless.Orgs = Orgs; +Stainless.Generate = Generate; + +// src/index.ts +var CONVENTIONAL_COMMIT_REGEX = new RegExp( + /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?(!?): .*$/ +); +var isValidConventionalCommitMessage = (message) => { + return CONVENTIONAL_COMMIT_REGEX.test(message); +}; +function isGitLabCI() { + return process.env["GITLAB_CI"] === "true"; } -function initVisitor(visitor) { - if (typeof visitor === 'object' && - (visitor.Collection || visitor.Node || visitor.Value)) { - return Object.assign({ - Alias: visitor.Node, - Map: visitor.Node, - Scalar: visitor.Node, - Seq: visitor.Node - }, visitor.Value && { - Map: visitor.Value, - Scalar: visitor.Value, - Seq: visitor.Value - }, visitor.Collection && { - Map: visitor.Collection, - Seq: visitor.Collection - }, visitor); - } - return visitor; +function getInputValue(name, options) { + if (isGitLabCI()) { + const inputEnvName = `INPUT_${name.toUpperCase()}`; + const inputValue = process.env[inputEnvName]; + const directEnvName = name.toUpperCase(); + const directValue = process.env[directEnvName]; + const value = inputValue || directValue; + if (options?.required && !value) { + throw new Error(`Input required and not supplied: ${name}`); + } + return value || ""; + } else { + return (0, import_core.getInput)(name, options); + } } -function callVisitor(key, node, visitor, path) { - if (typeof visitor === 'function') - return visitor(key, node, path); - if (identity.isMap(node)) - return visitor.Map?.(key, node, path); - if (identity.isSeq(node)) - return visitor.Seq?.(key, node, path); - if (identity.isPair(node)) - return visitor.Pair?.(key, node, path); - if (identity.isScalar(node)) - return visitor.Scalar?.(key, node, path); - if (identity.isAlias(node)) - return visitor.Alias?.(key, node, path); - return undefined; +function getBooleanInputValue(name, options) { + if (isGitLabCI()) { + const inputEnvName = `INPUT_${name.toUpperCase()}`; + const inputValue = process.env[inputEnvName]?.toLowerCase(); + const directEnvName = name.toUpperCase(); + const directValue = process.env[directEnvName]?.toLowerCase(); + const value = inputValue || directValue; + if (options?.required && value === void 0) { + throw new Error(`Input required and not supplied: ${name}`); + } + return value === "true"; + } else { + return (0, import_core.getBooleanInput)(name, options); + } } -function replaceNode(key, path, node) { - const parent = path[path.length - 1]; - if (identity.isCollection(parent)) { - parent.items[key] = node; - } - else if (identity.isPair(parent)) { - if (key === 'key') - parent.key = node; - else - parent.value = node; - } - else if (identity.isDocument(parent)) { - parent.contents = node; - } - else { - const pt = identity.isAlias(parent) ? 'alias' : 'scalar'; - throw new Error(`Cannot replace node with ${pt} parent`); +async function main() { + const stainless_api_key = getInputValue("stainless_api_key", { + required: true + }); + const inputPath = getInputValue("input_path", { required: true }); + const configPath = getInputValue("config_path", { required: false }); + let projectName = getInputValue("project_name", { required: false }); + const commitMessage = getInputValue("commit_message", { required: false }); + const guessConfig = getBooleanInputValue("guess_config", { required: false }); + const branch = getInputValue("branch", { required: false }); + const outputPath = getInputValue("output_path"); + if (configPath && guessConfig) { + const errorMsg = "Can't set both configPath and guessConfig"; + (0, import_node_console.error)(errorMsg); + throw Error(errorMsg); + } + if (commitMessage && !isValidConventionalCommitMessage(commitMessage)) { + const errorMsg = "Invalid commit message format. Please follow the Conventional Commits format: https://www.conventionalcommits.org/en/v1.0.0/"; + (0, import_node_console.error)(errorMsg); + throw Error(errorMsg); + } + if (!projectName) { + const stainless = new Stainless({ apiKey: stainless_api_key }); + const projects = await stainless.projects.list({ limit: 2 }); + if (projects.data.length === 0) { + const errorMsg = "No projects found. Please create a project first."; + (0, import_node_console.error)(errorMsg); + throw Error(errorMsg); + } + projectName = projects.data[0].slug; + if (projects.data.length > 1) { + (0, import_node_console.warn)( + `Multiple projects found. Using ${projectName} as default, but we recommend specifying the project name in the inputs.` + ); + } + } + (0, import_node_console.info)( + configPath ? "Uploading spec and config files..." : "Uploading spec file..." + ); + const response = await uploadSpecAndConfig( + inputPath, + configPath, + stainless_api_key, + projectName, + commitMessage, + guessConfig, + branch + ); + if (!response.ok) { + const errorMsg = `Build failed with the following outcomes: ${JSON.stringify( + response.errors + )} See more details in the Stainless Studio.`; + (0, import_node_console.error)(errorMsg); + throw Error(errorMsg); + } + (0, import_node_console.info)("Uploaded!"); + if (outputPath) { + if (!response.decoratedSpec) { + const errorMsg = "Failed to get decorated spec"; + (0, import_node_console.error)(errorMsg); + throw Error(errorMsg); + } + if (!(outputPath.endsWith(".yml") || outputPath.endsWith(".yaml"))) { + response.decoratedSpec = JSON.stringify( + import_yaml.default.parse(response.decoratedSpec), + null, + 2 + ); + } + (0, import_node_fs.writeFileSync)(outputPath, response.decoratedSpec); + (0, import_node_console.info)("Wrote decorated spec to", outputPath); + } +} +async function uploadSpecAndConfig(specPath, configPath, token, projectName, commitMessage, guessConfig, branch) { + const stainless = new Stainless({ apiKey: token, project: projectName }); + const specContent = (0, import_node_fs.readFileSync)(specPath, "utf8"); + let configContent; + if (guessConfig) { + configContent = Object.values( + await stainless.projects.configs.guess({ + branch, + spec: specContent + }) + )[0]?.content; + } else if (configPath) { + configContent = (0, import_node_fs.readFileSync)(configPath, "utf8"); + } + const headers = {}; + if (isGitLabCI()) { + headers["X-GitLab-CI"] = "stainless-api/upload-openapi-spec-action"; + } else { + headers["X-GitHub-Action"] = "stainless-api/upload-openapi-spec-action"; + } + let build = await stainless.builds.create( + { + ...branch && { branch }, + ...commitMessage && { commit_message: commitMessage }, + revision: { + "openapi.yml": { content: specContent }, + ...configContent && { + "openapi.stainless.yml": { content: configContent } + } + }, + allow_empty: true + }, + { headers } + ); + const pollingStart = Date.now(); + let donePolling = false; + while (!donePolling && Date.now() - pollingStart < 10 * 60 * 1e3) { + build = await stainless.builds.retrieve(build.id); + donePolling = Object.values(build.targets).every( + (target) => target.commit.status === "completed" + ); + if (!donePolling) { + await new Promise((resolve) => setTimeout(resolve, 5 * 1e3)); } + } + const errors = Object.entries(build.targets).map(([target, value]) => { + if ( + // The remaining possible conclusions ('merge_conflict', 'fatal', 'payment_required', etc.) should + // all be considered failures. + value.commit?.status === "completed" && ["noop", "error", "warning", "note", "success"].includes( + value.commit.completed.conclusion + ) + ) { + return void 0; + } else if (value.commit?.status === "completed") { + return { + target, + outcome: value.commit.completed.conclusion + }; + } else { + return { + target, + outcome: "timed_out" + }; + } + }).filter((e) => e !== void 0); + const ok = errors.length === 0; + const decoratedSpec = await Stainless.unwrapFile(build.documented_spec); + return { ok, errors, decoratedSpec }; +} +if (require.main === module) { + main().catch((err) => { + console.error(err); + process.exit(1); + }); } +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + isValidConventionalCommitMessage, + main +}); +/*! Bundled license information: -exports.visit = visit; -exports.visitAsync = visitAsync; - - -/***/ }) +undici/lib/fetch/body.js: + (*! formdata-polyfill. MIT License. Jimmy Wärting *) -/******/ }); -/************************************************************************/ -/******/ // The module cache -/******/ var __webpack_module_cache__ = {}; -/******/ -/******/ // The require function -/******/ function __nccwpck_require__(moduleId) { -/******/ // Check if module is in cache -/******/ var cachedModule = __webpack_module_cache__[moduleId]; -/******/ if (cachedModule !== undefined) { -/******/ return cachedModule.exports; -/******/ } -/******/ // Create a new module (and put it into the cache) -/******/ var module = __webpack_module_cache__[moduleId] = { -/******/ // no module.id needed -/******/ // no module.loaded needed -/******/ exports: {} -/******/ }; -/******/ -/******/ // Execute the module function -/******/ var threw = true; -/******/ try { -/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__); -/******/ threw = false; -/******/ } finally { -/******/ if(threw) delete __webpack_module_cache__[moduleId]; -/******/ } -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/************************************************************************/ -/******/ /* webpack/runtime/compat */ -/******/ -/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/"; -/******/ -/************************************************************************/ -/******/ -/******/ // startup -/******/ // Load entry module and return exports -/******/ // This entry module is referenced by other modules so it can't be inlined -/******/ var __webpack_exports__ = __nccwpck_require__(98); -/******/ module.exports = __webpack_exports__; -/******/ -/******/ })() -; \ No newline at end of file +undici/lib/websocket/frame.js: + (*! ws. MIT License. Einar Otto Stangvik *) +*/ diff --git a/dist/licenses.txt b/dist/licenses.txt deleted file mode 100644 index 8d7a6107..00000000 --- a/dist/licenses.txt +++ /dev/null @@ -1,353 +0,0 @@ -@actions/core -MIT -The MIT License (MIT) - -Copyright 2019 GitHub - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -@actions/exec -MIT -The MIT License (MIT) - -Copyright 2019 GitHub - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -@actions/http-client -MIT -Actions Http Client for Node.js - -Copyright (c) GitHub, Inc. - -All rights reserved. - -MIT License - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and -associated documentation files (the "Software"), to deal in the Software without restriction, -including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, -and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, -subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT -LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN -NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - - -@actions/io -MIT -The MIT License (MIT) - -Copyright 2019 GitHub - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -@fastify/busboy -MIT -Copyright Brian White. All rights reserved. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to -deal in the Software without restriction, including without limitation the -rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -sell copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -IN THE SOFTWARE. - -@stainless-api/sdk -Apache-2.0 - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright 2025 Stainless - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - - -tunnel -MIT -The MIT License (MIT) - -Copyright (c) 2012 Koichi Kobayashi - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. - - -undici -MIT -MIT License - -Copyright (c) Matteo Collina and Undici contributors - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. - - -yaml -ISC -Copyright Eemeli Aro - -Permission to use, copy, modify, and/or distribute this software for any purpose -with or without fee is hereby granted, provided that the above copyright notice -and this permission notice appear in all copies. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH -REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, -INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS -OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER -TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF -THIS SOFTWARE. diff --git a/dist/merge.js b/dist/merge.js new file mode 100644 index 00000000..c69e64a5 --- /dev/null +++ b/dist/merge.js @@ -0,0 +1,33660 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// node_modules/@actions/core/lib/utils.js +var require_utils = __commonJS({ + "node_modules/@actions/core/lib/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.toCommandProperties = exports2.toCommandValue = void 0; + function toCommandValue(input) { + if (input === null || input === void 0) { + return ""; + } else if (typeof input === "string" || input instanceof String) { + return input; + } + return JSON.stringify(input); + } + exports2.toCommandValue = toCommandValue; + function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; + } + exports2.toCommandProperties = toCommandProperties; + } +}); + +// node_modules/@actions/core/lib/command.js +var require_command = __commonJS({ + "node_modules/@actions/core/lib/command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.issue = exports2.issueCommand = void 0; + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); + } + exports2.issueCommand = issueCommand; + function issue(name, message = "") { + issueCommand(name, {}, message); + } + exports2.issue = issue; + var CMD_STRING = "::"; + var Command = class { + constructor(command, properties, message) { + if (!command) { + command = "missing.command"; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += " "; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } else { + cmdStr += ","; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } + }; + function escapeData(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A"); + } + function escapeProperty(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C"); + } + } +}); + +// node_modules/@actions/core/lib/file-command.js +var require_file_command = __commonJS({ + "node_modules/@actions/core/lib/file-command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.prepareKeyValueMessage = exports2.issueFileCommand = void 0; + var crypto = __importStar(require("crypto")); + var fs2 = __importStar(require("fs")); + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs2.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs2.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { + encoding: "utf8" + }); + } + exports2.issueFileCommand = issueFileCommand; + function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${crypto.randomUUID()}`; + const convertedValue = (0, utils_1.toCommandValue)(value); + if (key.includes(delimiter)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + } + if (convertedValue.includes(delimiter)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + } + return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; + } + exports2.prepareKeyValueMessage = prepareKeyValueMessage; + } +}); + +// node_modules/@actions/http-client/lib/proxy.js +var require_proxy = __commonJS({ + "node_modules/@actions/http-client/lib/proxy.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.checkBypass = exports2.getProxyUrl = void 0; + function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === "https:"; + if (checkBypass(reqUrl)) { + return void 0; + } + const proxyVar = (() => { + if (usingSsl) { + return process.env["https_proxy"] || process.env["HTTPS_PROXY"]; + } else { + return process.env["http_proxy"] || process.env["HTTP_PROXY"]; + } + })(); + if (proxyVar) { + try { + return new DecodedURL(proxyVar); + } catch (_a2) { + if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) + return new DecodedURL(`http://${proxyVar}`); + } + } else { + return void 0; + } + } + exports2.getProxyUrl = getProxyUrl; + function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) { + return true; + } + const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || ""; + if (!noProxy) { + return false; + } + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } else if (reqUrl.protocol === "http:") { + reqPort = 80; + } else if (reqUrl.protocol === "https:") { + reqPort = 443; + } + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === "number") { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) { + if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) { + return true; + } + } + return false; + } + exports2.checkBypass = checkBypass; + function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]"); + } + var DecodedURL = class extends URL { + constructor(url, base) { + super(url, base); + this._decodedUsername = decodeURIComponent(super.username); + this._decodedPassword = decodeURIComponent(super.password); + } + get username() { + return this._decodedUsername; + } + get password() { + return this._decodedPassword; + } + }; + } +}); + +// node_modules/tunnel/lib/tunnel.js +var require_tunnel = __commonJS({ + "node_modules/tunnel/lib/tunnel.js"(exports2) { + "use strict"; + var net = require("net"); + var tls = require("tls"); + var http = require("http"); + var https = require("https"); + var events = require("events"); + var assert = require("assert"); + var util = require("util"); + exports2.httpOverHttp = httpOverHttp; + exports2.httpsOverHttp = httpsOverHttp; + exports2.httpOverHttps = httpOverHttps; + exports2.httpsOverHttps = httpsOverHttps; + function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; + } + function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; + } + function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function TunnelingAgent(options) { + var self2 = this; + self2.options = options || {}; + self2.proxyOptions = self2.options.proxy || {}; + self2.maxSockets = self2.options.maxSockets || http.Agent.defaultMaxSockets; + self2.requests = []; + self2.sockets = []; + self2.on("free", function onFree(socket, host, port, localAddress) { + var options2 = toOptions(host, port, localAddress); + for (var i = 0, len = self2.requests.length; i < len; ++i) { + var pending = self2.requests[i]; + if (pending.host === options2.host && pending.port === options2.port) { + self2.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self2.removeSocket(socket); + }); + } + util.inherits(TunnelingAgent, events.EventEmitter); + TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self2 = this; + var options = mergeOptions({ request: req }, self2.options, toOptions(host, port, localAddress)); + if (self2.sockets.length >= this.maxSockets) { + self2.requests.push(options); + return; + } + self2.createSocket(options, function(socket) { + socket.on("free", onFree); + socket.on("close", onCloseOrRemove); + socket.on("agentRemove", onCloseOrRemove); + req.onSocket(socket); + function onFree() { + self2.emit("free", socket, options); + } + function onCloseOrRemove(err) { + self2.removeSocket(socket); + socket.removeListener("free", onFree); + socket.removeListener("close", onCloseOrRemove); + socket.removeListener("agentRemove", onCloseOrRemove); + } + }); + }; + TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self2 = this; + var placeholder = {}; + self2.sockets.push(placeholder); + var connectOptions = mergeOptions({}, self2.proxyOptions, { + method: "CONNECT", + path: options.host + ":" + options.port, + agent: false, + headers: { + host: options.host + ":" + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64"); + } + debug("making CONNECT request"); + var connectReq = self2.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; + connectReq.once("response", onResponse); + connectReq.once("upgrade", onUpgrade); + connectReq.once("connect", onConnect); + connectReq.once("error", onError); + connectReq.end(); + function onResponse(res) { + res.upgrade = true; + } + function onUpgrade(res, socket, head) { + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + if (res.statusCode !== 200) { + debug( + "tunneling socket could not be established, statusCode=%d", + res.statusCode + ); + socket.destroy(); + var error = new Error("tunneling socket could not be established, statusCode=" + res.statusCode); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self2.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug("got illegal response body from proxy"); + socket.destroy(); + var error = new Error("got illegal response body from proxy"); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self2.removeSocket(placeholder); + return; + } + debug("tunneling connection has established"); + self2.sockets[self2.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + function onError(cause) { + connectReq.removeAllListeners(); + debug( + "tunneling socket could not be established, cause=%s\n", + cause.message, + cause.stack + ); + var error = new Error("tunneling socket could not be established, cause=" + cause.message); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self2.removeSocket(placeholder); + } + }; + TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket); + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + var pending = this.requests.shift(); + if (pending) { + this.createSocket(pending, function(socket2) { + pending.request.onSocket(socket2); + }); + } + }; + function createSecureSocket(options, cb) { + var self2 = this; + TunnelingAgent.prototype.createSocket.call(self2, options, function(socket) { + var hostHeader = options.request.getHeader("host"); + var tlsOptions = mergeOptions({}, self2.options, { + socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host + }); + var secureSocket = tls.connect(0, tlsOptions); + self2.sockets[self2.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); + } + function toOptions(host, port, localAddress) { + if (typeof host === "string") { + return { + host, + port, + localAddress + }; + } + return host; + } + function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === "object") { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== void 0) { + target[k] = overrides[k]; + } + } + } + } + return target; + } + var debug; + if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === "string") { + args[0] = "TUNNEL: " + args[0]; + } else { + args.unshift("TUNNEL:"); + } + console.error.apply(console, args); + }; + } else { + debug = function() { + }; + } + exports2.debug = debug; + } +}); + +// node_modules/tunnel/index.js +var require_tunnel2 = __commonJS({ + "node_modules/tunnel/index.js"(exports2, module2) { + module2.exports = require_tunnel(); + } +}); + +// node_modules/undici/lib/core/symbols.js +var require_symbols = __commonJS({ + "node_modules/undici/lib/core/symbols.js"(exports2, module2) { + module2.exports = { + kClose: Symbol("close"), + kDestroy: Symbol("destroy"), + kDispatch: Symbol("dispatch"), + kUrl: Symbol("url"), + kWriting: Symbol("writing"), + kResuming: Symbol("resuming"), + kQueue: Symbol("queue"), + kConnect: Symbol("connect"), + kConnecting: Symbol("connecting"), + kHeadersList: Symbol("headers list"), + kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"), + kKeepAliveMaxTimeout: Symbol("max keep alive timeout"), + kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"), + kKeepAliveTimeoutValue: Symbol("keep alive timeout"), + kKeepAlive: Symbol("keep alive"), + kHeadersTimeout: Symbol("headers timeout"), + kBodyTimeout: Symbol("body timeout"), + kServerName: Symbol("server name"), + kLocalAddress: Symbol("local address"), + kHost: Symbol("host"), + kNoRef: Symbol("no ref"), + kBodyUsed: Symbol("used"), + kRunning: Symbol("running"), + kBlocking: Symbol("blocking"), + kPending: Symbol("pending"), + kSize: Symbol("size"), + kBusy: Symbol("busy"), + kQueued: Symbol("queued"), + kFree: Symbol("free"), + kConnected: Symbol("connected"), + kClosed: Symbol("closed"), + kNeedDrain: Symbol("need drain"), + kReset: Symbol("reset"), + kDestroyed: Symbol.for("nodejs.stream.destroyed"), + kMaxHeadersSize: Symbol("max headers size"), + kRunningIdx: Symbol("running index"), + kPendingIdx: Symbol("pending index"), + kError: Symbol("error"), + kClients: Symbol("clients"), + kClient: Symbol("client"), + kParser: Symbol("parser"), + kOnDestroyed: Symbol("destroy callbacks"), + kPipelining: Symbol("pipelining"), + kSocket: Symbol("socket"), + kHostHeader: Symbol("host header"), + kConnector: Symbol("connector"), + kStrictContentLength: Symbol("strict content length"), + kMaxRedirections: Symbol("maxRedirections"), + kMaxRequests: Symbol("maxRequestsPerClient"), + kProxy: Symbol("proxy agent options"), + kCounter: Symbol("socket request counter"), + kInterceptors: Symbol("dispatch interceptors"), + kMaxResponseSize: Symbol("max response size"), + kHTTP2Session: Symbol("http2Session"), + kHTTP2SessionState: Symbol("http2Session state"), + kHTTP2BuildRequest: Symbol("http2 build request"), + kHTTP1BuildRequest: Symbol("http1 build request"), + kHTTP2CopyHeaders: Symbol("http2 copy headers"), + kHTTPConnVersion: Symbol("http connection version"), + kRetryHandlerDefaultRetry: Symbol("retry agent default retry"), + kConstruct: Symbol("constructable") + }; + } +}); + +// node_modules/undici/lib/core/errors.js +var require_errors = __commonJS({ + "node_modules/undici/lib/core/errors.js"(exports2, module2) { + "use strict"; + var UndiciError = class extends Error { + constructor(message) { + super(message); + this.name = "UndiciError"; + this.code = "UND_ERR"; + } + }; + var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ConnectTimeoutError); + this.name = "ConnectTimeoutError"; + this.message = message || "Connect Timeout Error"; + this.code = "UND_ERR_CONNECT_TIMEOUT"; + } + }; + var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersTimeoutError); + this.name = "HeadersTimeoutError"; + this.message = message || "Headers Timeout Error"; + this.code = "UND_ERR_HEADERS_TIMEOUT"; + } + }; + var HeadersOverflowError = class _HeadersOverflowError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersOverflowError); + this.name = "HeadersOverflowError"; + this.message = message || "Headers Overflow Error"; + this.code = "UND_ERR_HEADERS_OVERFLOW"; + } + }; + var BodyTimeoutError = class _BodyTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _BodyTimeoutError); + this.name = "BodyTimeoutError"; + this.message = message || "Body Timeout Error"; + this.code = "UND_ERR_BODY_TIMEOUT"; + } + }; + var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError { + constructor(message, statusCode, headers, body) { + super(message); + Error.captureStackTrace(this, _ResponseStatusCodeError); + this.name = "ResponseStatusCodeError"; + this.message = message || "Response Status Code Error"; + this.code = "UND_ERR_RESPONSE_STATUS_CODE"; + this.body = body; + this.status = statusCode; + this.statusCode = statusCode; + this.headers = headers; + } + }; + var InvalidArgumentError = class _InvalidArgumentError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidArgumentError); + this.name = "InvalidArgumentError"; + this.message = message || "Invalid Argument Error"; + this.code = "UND_ERR_INVALID_ARG"; + } + }; + var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidReturnValueError); + this.name = "InvalidReturnValueError"; + this.message = message || "Invalid Return Value Error"; + this.code = "UND_ERR_INVALID_RETURN_VALUE"; + } + }; + var RequestAbortedError = class _RequestAbortedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestAbortedError); + this.name = "AbortError"; + this.message = message || "Request aborted"; + this.code = "UND_ERR_ABORTED"; + } + }; + var InformationalError = class _InformationalError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InformationalError); + this.name = "InformationalError"; + this.message = message || "Request information"; + this.code = "UND_ERR_INFO"; + } + }; + var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestContentLengthMismatchError); + this.name = "RequestContentLengthMismatchError"; + this.message = message || "Request body length does not match content-length header"; + this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"; + } + }; + var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseContentLengthMismatchError); + this.name = "ResponseContentLengthMismatchError"; + this.message = message || "Response body length does not match content-length header"; + this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"; + } + }; + var ClientDestroyedError = class _ClientDestroyedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientDestroyedError); + this.name = "ClientDestroyedError"; + this.message = message || "The client is destroyed"; + this.code = "UND_ERR_DESTROYED"; + } + }; + var ClientClosedError = class _ClientClosedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientClosedError); + this.name = "ClientClosedError"; + this.message = message || "The client is closed"; + this.code = "UND_ERR_CLOSED"; + } + }; + var SocketError = class _SocketError extends UndiciError { + constructor(message, socket) { + super(message); + Error.captureStackTrace(this, _SocketError); + this.name = "SocketError"; + this.message = message || "Socket error"; + this.code = "UND_ERR_SOCKET"; + this.socket = socket; + } + }; + var NotSupportedError = class _NotSupportedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _NotSupportedError); + this.name = "NotSupportedError"; + this.message = message || "Not supported error"; + this.code = "UND_ERR_NOT_SUPPORTED"; + } + }; + var BalancedPoolMissingUpstreamError = class extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, NotSupportedError); + this.name = "MissingUpstreamError"; + this.message = message || "No upstream has been added to the BalancedPool"; + this.code = "UND_ERR_BPL_MISSING_UPSTREAM"; + } + }; + var HTTPParserError = class _HTTPParserError extends Error { + constructor(message, code, data) { + super(message); + Error.captureStackTrace(this, _HTTPParserError); + this.name = "HTTPParserError"; + this.code = code ? `HPE_${code}` : void 0; + this.data = data ? data.toString() : void 0; + } + }; + var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseExceededMaxSizeError); + this.name = "ResponseExceededMaxSizeError"; + this.message = message || "Response content exceeded max size"; + this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE"; + } + }; + var RequestRetryError = class _RequestRetryError extends UndiciError { + constructor(message, code, { headers, data }) { + super(message); + Error.captureStackTrace(this, _RequestRetryError); + this.name = "RequestRetryError"; + this.message = message || "Request retry error"; + this.code = "UND_ERR_REQ_RETRY"; + this.statusCode = code; + this.data = data; + this.headers = headers; + } + }; + module2.exports = { + HTTPParserError, + UndiciError, + HeadersTimeoutError, + HeadersOverflowError, + BodyTimeoutError, + RequestContentLengthMismatchError, + ConnectTimeoutError, + ResponseStatusCodeError, + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError, + ClientDestroyedError, + ClientClosedError, + InformationalError, + SocketError, + NotSupportedError, + ResponseContentLengthMismatchError, + BalancedPoolMissingUpstreamError, + ResponseExceededMaxSizeError, + RequestRetryError + }; + } +}); + +// node_modules/undici/lib/core/constants.js +var require_constants = __commonJS({ + "node_modules/undici/lib/core/constants.js"(exports2, module2) { + "use strict"; + var headerNameLowerCasedRecord = {}; + var wellknownHeaderNames = [ + "Accept", + "Accept-Encoding", + "Accept-Language", + "Accept-Ranges", + "Access-Control-Allow-Credentials", + "Access-Control-Allow-Headers", + "Access-Control-Allow-Methods", + "Access-Control-Allow-Origin", + "Access-Control-Expose-Headers", + "Access-Control-Max-Age", + "Access-Control-Request-Headers", + "Access-Control-Request-Method", + "Age", + "Allow", + "Alt-Svc", + "Alt-Used", + "Authorization", + "Cache-Control", + "Clear-Site-Data", + "Connection", + "Content-Disposition", + "Content-Encoding", + "Content-Language", + "Content-Length", + "Content-Location", + "Content-Range", + "Content-Security-Policy", + "Content-Security-Policy-Report-Only", + "Content-Type", + "Cookie", + "Cross-Origin-Embedder-Policy", + "Cross-Origin-Opener-Policy", + "Cross-Origin-Resource-Policy", + "Date", + "Device-Memory", + "Downlink", + "ECT", + "ETag", + "Expect", + "Expect-CT", + "Expires", + "Forwarded", + "From", + "Host", + "If-Match", + "If-Modified-Since", + "If-None-Match", + "If-Range", + "If-Unmodified-Since", + "Keep-Alive", + "Last-Modified", + "Link", + "Location", + "Max-Forwards", + "Origin", + "Permissions-Policy", + "Pragma", + "Proxy-Authenticate", + "Proxy-Authorization", + "RTT", + "Range", + "Referer", + "Referrer-Policy", + "Refresh", + "Retry-After", + "Sec-WebSocket-Accept", + "Sec-WebSocket-Extensions", + "Sec-WebSocket-Key", + "Sec-WebSocket-Protocol", + "Sec-WebSocket-Version", + "Server", + "Server-Timing", + "Service-Worker-Allowed", + "Service-Worker-Navigation-Preload", + "Set-Cookie", + "SourceMap", + "Strict-Transport-Security", + "Supports-Loading-Mode", + "TE", + "Timing-Allow-Origin", + "Trailer", + "Transfer-Encoding", + "Upgrade", + "Upgrade-Insecure-Requests", + "User-Agent", + "Vary", + "Via", + "WWW-Authenticate", + "X-Content-Type-Options", + "X-DNS-Prefetch-Control", + "X-Frame-Options", + "X-Permitted-Cross-Domain-Policies", + "X-Powered-By", + "X-Requested-With", + "X-XSS-Protection" + ]; + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = wellknownHeaderNames[i]; + const lowerCasedKey = key.toLowerCase(); + headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey; + } + Object.setPrototypeOf(headerNameLowerCasedRecord, null); + module2.exports = { + wellknownHeaderNames, + headerNameLowerCasedRecord + }; + } +}); + +// node_modules/undici/lib/core/util.js +var require_util = __commonJS({ + "node_modules/undici/lib/core/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { kDestroyed, kBodyUsed } = require_symbols(); + var { IncomingMessage } = require("http"); + var stream = require("stream"); + var net = require("net"); + var { InvalidArgumentError } = require_errors(); + var { Blob: Blob2 } = require("buffer"); + var nodeUtil = require("util"); + var { stringify: stringify3 } = require("querystring"); + var { headerNameLowerCasedRecord } = require_constants(); + var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v)); + function nop() { + } + function isStream(obj) { + return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; + } + function isBlobLike2(object) { + return Blob2 && object instanceof Blob2 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]); + } + function buildURL(url, queryParams) { + if (url.includes("?") || url.includes("#")) { + throw new Error('Query params cannot be passed when url already contains "?" or "#".'); + } + const stringified = stringify3(queryParams); + if (stringified) { + url += "?" + stringified; + } + return url; + } + function parseURL(url) { + if (typeof url === "string") { + url = new URL(url); + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + return url; + } + if (!url || typeof url !== "object") { + throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object."); + } + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + if (!(url instanceof URL)) { + if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) { + throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer."); + } + if (url.path != null && typeof url.path !== "string") { + throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined."); + } + if (url.pathname != null && typeof url.pathname !== "string") { + throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined."); + } + if (url.hostname != null && typeof url.hostname !== "string") { + throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined."); + } + if (url.origin != null && typeof url.origin !== "string") { + throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined."); + } + const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; + let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`; + let path3 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; + if (origin.endsWith("/")) { + origin = origin.substring(0, origin.length - 1); + } + if (path3 && !path3.startsWith("/")) { + path3 = `/${path3}`; + } + url = new URL(origin + path3); + } + return url; + } + function parseOrigin(url) { + url = parseURL(url); + if (url.pathname !== "/" || url.search || url.hash) { + throw new InvalidArgumentError("invalid url"); + } + return url; + } + function getHostname(host) { + if (host[0] === "[") { + const idx2 = host.indexOf("]"); + assert(idx2 !== -1); + return host.substring(1, idx2); + } + const idx = host.indexOf(":"); + if (idx === -1) return host; + return host.substring(0, idx); + } + function getServerName(host) { + if (!host) { + return null; + } + assert.strictEqual(typeof host, "string"); + const servername = getHostname(host); + if (net.isIP(servername)) { + return ""; + } + return servername; + } + function deepClone(obj) { + return JSON.parse(JSON.stringify(obj)); + } + function isAsyncIterable3(obj) { + return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function"); + } + function isIterable(obj) { + return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function")); + } + function bodyLength(body) { + if (body == null) { + return 0; + } else if (isStream(body)) { + const state = body._readableState; + return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; + } else if (isBlobLike2(body)) { + return body.size != null ? body.size : null; + } else if (isBuffer(body)) { + return body.byteLength; + } + return null; + } + function isDestroyed(stream2) { + return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]); + } + function isReadableAborted(stream2) { + const state = stream2 && stream2._readableState; + return isDestroyed(stream2) && state && !state.endEmitted; + } + function destroy(stream2, err) { + if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) { + return; + } + if (typeof stream2.destroy === "function") { + if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) { + stream2.socket = null; + } + stream2.destroy(err); + } else if (err) { + process.nextTick((stream3, err2) => { + stream3.emit("error", err2); + }, stream2, err); + } + if (stream2.destroyed !== true) { + stream2[kDestroyed] = true; + } + } + var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/; + function parseKeepAliveTimeout(val) { + const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR); + return m ? parseInt(m[1], 10) * 1e3 : null; + } + function headerNameToString(value) { + return headerNameLowerCasedRecord[value] || value.toLowerCase(); + } + function parseHeaders(headers, obj = {}) { + if (!Array.isArray(headers)) return headers; + for (let i = 0; i < headers.length; i += 2) { + const key = headers[i].toString().toLowerCase(); + let val = obj[key]; + if (!val) { + if (Array.isArray(headers[i + 1])) { + obj[key] = headers[i + 1].map((x) => x.toString("utf8")); + } else { + obj[key] = headers[i + 1].toString("utf8"); + } + } else { + if (!Array.isArray(val)) { + val = [val]; + obj[key] = val; + } + val.push(headers[i + 1].toString("utf8")); + } + } + if ("content-length" in obj && "content-disposition" in obj) { + obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1"); + } + return obj; + } + function parseRawHeaders(headers) { + const ret = []; + let hasContentLength = false; + let contentDispositionIdx = -1; + for (let n = 0; n < headers.length; n += 2) { + const key = headers[n + 0].toString(); + const val = headers[n + 1].toString("utf8"); + if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) { + ret.push(key, val); + hasContentLength = true; + } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) { + contentDispositionIdx = ret.push(key, val) - 1; + } else { + ret.push(key, val); + } + } + if (hasContentLength && contentDispositionIdx !== -1) { + ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1"); + } + return ret; + } + function isBuffer(buffer) { + return buffer instanceof Uint8Array || Buffer.isBuffer(buffer); + } + function validateHandler(handler, method, upgrade) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + if (typeof handler.onConnect !== "function") { + throw new InvalidArgumentError("invalid onConnect method"); + } + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) { + throw new InvalidArgumentError("invalid onBodySent method"); + } + if (upgrade || method === "CONNECT") { + if (typeof handler.onUpgrade !== "function") { + throw new InvalidArgumentError("invalid onUpgrade method"); + } + } else { + if (typeof handler.onHeaders !== "function") { + throw new InvalidArgumentError("invalid onHeaders method"); + } + if (typeof handler.onData !== "function") { + throw new InvalidArgumentError("invalid onData method"); + } + if (typeof handler.onComplete !== "function") { + throw new InvalidArgumentError("invalid onComplete method"); + } + } + } + function isDisturbed(body) { + return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body))); + } + function isErrored(body) { + return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test( + nodeUtil.inspect(body) + ))); + } + function isReadable(body) { + return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test( + nodeUtil.inspect(body) + ))); + } + function getSocketInfo(socket) { + return { + localAddress: socket.localAddress, + localPort: socket.localPort, + remoteAddress: socket.remoteAddress, + remotePort: socket.remotePort, + remoteFamily: socket.remoteFamily, + timeout: socket.timeout, + bytesWritten: socket.bytesWritten, + bytesRead: socket.bytesRead + }; + } + async function* convertIterableToBuffer(iterable) { + for await (const chunk of iterable) { + yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk); + } + } + var ReadableStream; + function ReadableStreamFrom3(iterable) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (ReadableStream.from) { + return ReadableStream.from(convertIterableToBuffer(iterable)); + } + let iterator; + return new ReadableStream( + { + async start() { + iterator = iterable[Symbol.asyncIterator](); + }, + async pull(controller) { + const { done, value } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + const buf = Buffer.isBuffer(value) ? value : Buffer.from(value); + controller.enqueue(new Uint8Array(buf)); + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + } + }, + 0 + ); + } + function isFormDataLike(object) { + return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData"; + } + function throwIfAborted(signal) { + if (!signal) { + return; + } + if (typeof signal.throwIfAborted === "function") { + signal.throwIfAborted(); + } else { + if (signal.aborted) { + const err = new Error("The operation was aborted"); + err.name = "AbortError"; + throw err; + } + } + } + function addAbortListener(signal, listener) { + if ("addEventListener" in signal) { + signal.addEventListener("abort", listener, { once: true }); + return () => signal.removeEventListener("abort", listener); + } + signal.addListener("abort", listener); + return () => signal.removeListener("abort", listener); + } + var hasToWellFormed = !!String.prototype.toWellFormed; + function toUSVString(val) { + if (hasToWellFormed) { + return `${val}`.toWellFormed(); + } else if (nodeUtil.toUSVString) { + return nodeUtil.toUSVString(val); + } + return `${val}`; + } + function parseRangeHeader(range) { + if (range == null || range === "") return { start: 0, end: null, size: null }; + const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null; + return m ? { + start: parseInt(m[1]), + end: m[2] ? parseInt(m[2]) : null, + size: m[3] ? parseInt(m[3]) : null + } : null; + } + var kEnumerableProperty = /* @__PURE__ */ Object.create(null); + kEnumerableProperty.enumerable = true; + module2.exports = { + kEnumerableProperty, + nop, + isDisturbed, + isErrored, + isReadable, + toUSVString, + isReadableAborted, + isBlobLike: isBlobLike2, + parseOrigin, + parseURL, + getServerName, + isStream, + isIterable, + isAsyncIterable: isAsyncIterable3, + isDestroyed, + headerNameToString, + parseRawHeaders, + parseHeaders, + parseKeepAliveTimeout, + destroy, + bodyLength, + deepClone, + ReadableStreamFrom: ReadableStreamFrom3, + isBuffer, + validateHandler, + getSocketInfo, + isFormDataLike, + buildURL, + throwIfAborted, + addAbortListener, + parseRangeHeader, + nodeMajor, + nodeMinor, + nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13, + safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"] + }; + } +}); + +// node_modules/undici/lib/timers.js +var require_timers = __commonJS({ + "node_modules/undici/lib/timers.js"(exports2, module2) { + "use strict"; + var fastNow = Date.now(); + var fastNowTimeout; + var fastTimers = []; + function onTimeout() { + fastNow = Date.now(); + let len = fastTimers.length; + let idx = 0; + while (idx < len) { + const timer = fastTimers[idx]; + if (timer.state === 0) { + timer.state = fastNow + timer.delay; + } else if (timer.state > 0 && fastNow >= timer.state) { + timer.state = -1; + timer.callback(timer.opaque); + } + if (timer.state === -1) { + timer.state = -2; + if (idx !== len - 1) { + fastTimers[idx] = fastTimers.pop(); + } else { + fastTimers.pop(); + } + len -= 1; + } else { + idx += 1; + } + } + if (fastTimers.length > 0) { + refreshTimeout(); + } + } + function refreshTimeout() { + if (fastNowTimeout && fastNowTimeout.refresh) { + fastNowTimeout.refresh(); + } else { + clearTimeout(fastNowTimeout); + fastNowTimeout = setTimeout(onTimeout, 1e3); + if (fastNowTimeout.unref) { + fastNowTimeout.unref(); + } + } + } + var Timeout = class { + constructor(callback, delay, opaque) { + this.callback = callback; + this.delay = delay; + this.opaque = opaque; + this.state = -2; + this.refresh(); + } + refresh() { + if (this.state === -2) { + fastTimers.push(this); + if (!fastNowTimeout || fastTimers.length === 1) { + refreshTimeout(); + } + } + this.state = 0; + } + clear() { + this.state = -1; + } + }; + module2.exports = { + setTimeout(callback, delay, opaque) { + return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque); + }, + clearTimeout(timeout) { + if (timeout instanceof Timeout) { + timeout.clear(); + } else { + clearTimeout(timeout); + } + } + }; + } +}); + +// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js +var require_sbmh = __commonJS({ + "node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + function SBMH(needle) { + if (typeof needle === "string") { + needle = Buffer.from(needle); + } + if (!Buffer.isBuffer(needle)) { + throw new TypeError("The needle has to be a String or a Buffer."); + } + const needleLength = needle.length; + if (needleLength === 0) { + throw new Error("The needle cannot be an empty String/Buffer."); + } + if (needleLength > 256) { + throw new Error("The needle cannot have a length bigger than 256."); + } + this.maxMatches = Infinity; + this.matches = 0; + this._occ = new Array(256).fill(needleLength); + this._lookbehind_size = 0; + this._needle = needle; + this._bufpos = 0; + this._lookbehind = Buffer.alloc(needleLength); + for (var i = 0; i < needleLength - 1; ++i) { + this._occ[needle[i]] = needleLength - 1 - i; + } + } + inherits(SBMH, EventEmitter); + SBMH.prototype.reset = function() { + this._lookbehind_size = 0; + this.matches = 0; + this._bufpos = 0; + }; + SBMH.prototype.push = function(chunk, pos) { + if (!Buffer.isBuffer(chunk)) { + chunk = Buffer.from(chunk, "binary"); + } + const chlen = chunk.length; + this._bufpos = pos || 0; + let r; + while (r !== chlen && this.matches < this.maxMatches) { + r = this._sbmh_feed(chunk); + } + return r; + }; + SBMH.prototype._sbmh_feed = function(data) { + const len = data.length; + const needle = this._needle; + const needleLength = needle.length; + const lastNeedleChar = needle[needleLength - 1]; + let pos = -this._lookbehind_size; + let ch; + if (pos < 0) { + while (pos < 0 && pos <= len - needleLength) { + ch = this._sbmh_lookup_char(data, pos + needleLength - 1); + if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) { + this._lookbehind_size = 0; + ++this.matches; + this.emit("info", true); + return this._bufpos = pos + needleLength; + } + pos += this._occ[ch]; + } + if (pos < 0) { + while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { + ++pos; + } + } + if (pos >= 0) { + this.emit("info", false, this._lookbehind, 0, this._lookbehind_size); + this._lookbehind_size = 0; + } else { + const bytesToCutOff = this._lookbehind_size + pos; + if (bytesToCutOff > 0) { + this.emit("info", false, this._lookbehind, 0, bytesToCutOff); + } + this._lookbehind.copy( + this._lookbehind, + 0, + bytesToCutOff, + this._lookbehind_size - bytesToCutOff + ); + this._lookbehind_size -= bytesToCutOff; + data.copy(this._lookbehind, this._lookbehind_size); + this._lookbehind_size += len; + this._bufpos = len; + return len; + } + } + pos += (pos >= 0) * this._bufpos; + if (data.indexOf(needle, pos) !== -1) { + pos = data.indexOf(needle, pos); + ++this.matches; + if (pos > 0) { + this.emit("info", true, data, this._bufpos, pos); + } else { + this.emit("info", true); + } + return this._bufpos = pos + needleLength; + } else { + pos = len - needleLength; + } + while (pos < len && (data[pos] !== needle[0] || Buffer.compare( + data.subarray(pos, pos + len - pos), + needle.subarray(0, len - pos) + ) !== 0)) { + ++pos; + } + if (pos < len) { + data.copy(this._lookbehind, 0, pos, pos + (len - pos)); + this._lookbehind_size = len - pos; + } + if (pos > 0) { + this.emit("info", false, data, this._bufpos, pos < len ? pos : len); + } + this._bufpos = len; + return len; + }; + SBMH.prototype._sbmh_lookup_char = function(data, pos) { + return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos]; + }; + SBMH.prototype._sbmh_memcmp = function(data, pos, len) { + for (var i = 0; i < len; ++i) { + if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { + return false; + } + } + return true; + }; + module2.exports = SBMH; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js +var require_PartStream = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) { + "use strict"; + var inherits = require("node:util").inherits; + var ReadableStream = require("node:stream").Readable; + function PartStream(opts) { + ReadableStream.call(this, opts); + } + inherits(PartStream, ReadableStream); + PartStream.prototype._read = function(n) { + }; + module2.exports = PartStream; + } +}); + +// node_modules/@fastify/busboy/lib/utils/getLimit.js +var require_getLimit = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) { + "use strict"; + module2.exports = function getLimit(limits, name, defaultLimit) { + if (!limits || limits[name] === void 0 || limits[name] === null) { + return defaultLimit; + } + if (typeof limits[name] !== "number" || isNaN(limits[name])) { + throw new TypeError("Limit " + name + " is not a valid number"); + } + return limits[name]; + }; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js +var require_HeaderParser = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + var getLimit = require_getLimit(); + var StreamSearch = require_sbmh(); + var B_DCRLF = Buffer.from("\r\n\r\n"); + var RE_CRLF = /\r\n/g; + var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/; + function HeaderParser(cfg) { + EventEmitter.call(this); + cfg = cfg || {}; + const self2 = this; + this.nread = 0; + this.maxed = false; + this.npairs = 0; + this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3); + this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024); + this.buffer = ""; + this.header = {}; + this.finished = false; + this.ss = new StreamSearch(B_DCRLF); + this.ss.on("info", function(isMatch, data, start, end) { + if (data && !self2.maxed) { + if (self2.nread + end - start >= self2.maxHeaderSize) { + end = self2.maxHeaderSize - self2.nread + start; + self2.nread = self2.maxHeaderSize; + self2.maxed = true; + } else { + self2.nread += end - start; + } + self2.buffer += data.toString("binary", start, end); + } + if (isMatch) { + self2._finish(); + } + }); + } + inherits(HeaderParser, EventEmitter); + HeaderParser.prototype.push = function(data) { + const r = this.ss.push(data); + if (this.finished) { + return r; + } + }; + HeaderParser.prototype.reset = function() { + this.finished = false; + this.buffer = ""; + this.header = {}; + this.ss.reset(); + }; + HeaderParser.prototype._finish = function() { + if (this.buffer) { + this._parseHeader(); + } + this.ss.matches = this.ss.maxMatches; + const header = this.header; + this.header = {}; + this.buffer = ""; + this.finished = true; + this.nread = this.npairs = 0; + this.maxed = false; + this.emit("header", header); + }; + HeaderParser.prototype._parseHeader = function() { + if (this.npairs === this.maxHeaderPairs) { + return; + } + const lines = this.buffer.split(RE_CRLF); + const len = lines.length; + let m, h; + for (var i = 0; i < len; ++i) { + if (lines[i].length === 0) { + continue; + } + if (lines[i][0] === " " || lines[i][0] === " ") { + if (h) { + this.header[h][this.header[h].length - 1] += lines[i]; + continue; + } + } + const posColon = lines[i].indexOf(":"); + if (posColon === -1 || posColon === 0) { + return; + } + m = RE_HDR.exec(lines[i]); + h = m[1].toLowerCase(); + this.header[h] = this.header[h] || []; + this.header[h].push(m[2] || ""); + if (++this.npairs === this.maxHeaderPairs) { + break; + } + } + }; + module2.exports = HeaderParser; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js +var require_Dicer = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var inherits = require("node:util").inherits; + var StreamSearch = require_sbmh(); + var PartStream = require_PartStream(); + var HeaderParser = require_HeaderParser(); + var DASH = 45; + var B_ONEDASH = Buffer.from("-"); + var B_CRLF = Buffer.from("\r\n"); + var EMPTY_FN = function() { + }; + function Dicer(cfg) { + if (!(this instanceof Dicer)) { + return new Dicer(cfg); + } + WritableStream.call(this, cfg); + if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") { + throw new TypeError("Boundary required"); + } + if (typeof cfg.boundary === "string") { + this.setBoundary(cfg.boundary); + } else { + this._bparser = void 0; + } + this._headerFirst = cfg.headerFirst; + this._dashes = 0; + this._parts = 0; + this._finished = false; + this._realFinish = false; + this._isPreamble = true; + this._justMatched = false; + this._firstWrite = true; + this._inHeader = true; + this._part = void 0; + this._cb = void 0; + this._ignoreData = false; + this._partOpts = { highWaterMark: cfg.partHwm }; + this._pause = false; + const self2 = this; + this._hparser = new HeaderParser(cfg); + this._hparser.on("header", function(header) { + self2._inHeader = false; + self2._part.emit("header", header); + }); + } + inherits(Dicer, WritableStream); + Dicer.prototype.emit = function(ev) { + if (ev === "finish" && !this._realFinish) { + if (!this._finished) { + const self2 = this; + process.nextTick(function() { + self2.emit("error", new Error("Unexpected end of multipart data")); + if (self2._part && !self2._ignoreData) { + const type = self2._isPreamble ? "Preamble" : "Part"; + self2._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data")); + self2._part.push(null); + process.nextTick(function() { + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + }); + return; + } + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + }); + } + } else { + WritableStream.prototype.emit.apply(this, arguments); + } + }; + Dicer.prototype._write = function(data, encoding, cb) { + if (!this._hparser && !this._bparser) { + return cb(); + } + if (this._headerFirst && this._isPreamble) { + if (!this._part) { + this._part = new PartStream(this._partOpts); + if (this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else { + this._ignore(); + } + } + const r = this._hparser.push(data); + if (!this._inHeader && r !== void 0 && r < data.length) { + data = data.slice(r); + } else { + return cb(); + } + } + if (this._firstWrite) { + this._bparser.push(B_CRLF); + this._firstWrite = false; + } + this._bparser.push(data); + if (this._pause) { + this._cb = cb; + } else { + cb(); + } + }; + Dicer.prototype.reset = function() { + this._part = void 0; + this._bparser = void 0; + this._hparser = void 0; + }; + Dicer.prototype.setBoundary = function(boundary) { + const self2 = this; + this._bparser = new StreamSearch("\r\n--" + boundary); + this._bparser.on("info", function(isMatch, data, start, end) { + self2._oninfo(isMatch, data, start, end); + }); + }; + Dicer.prototype._ignore = function() { + if (this._part && !this._ignoreData) { + this._ignoreData = true; + this._part.on("error", EMPTY_FN); + this._part.resume(); + } + }; + Dicer.prototype._oninfo = function(isMatch, data, start, end) { + let buf; + const self2 = this; + let i = 0; + let r; + let shouldWriteMore = true; + if (!this._part && this._justMatched && data) { + while (this._dashes < 2 && start + i < end) { + if (data[start + i] === DASH) { + ++i; + ++this._dashes; + } else { + if (this._dashes) { + buf = B_ONEDASH; + } + this._dashes = 0; + break; + } + } + if (this._dashes === 2) { + if (start + i < end && this.listenerCount("trailer") !== 0) { + this.emit("trailer", data.slice(start + i, end)); + } + this.reset(); + this._finished = true; + if (self2._parts === 0) { + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + } + } + if (this._dashes) { + return; + } + } + if (this._justMatched) { + this._justMatched = false; + } + if (!this._part) { + this._part = new PartStream(this._partOpts); + this._part._read = function(n) { + self2._unpause(); + }; + if (this._isPreamble && this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else if (this._isPreamble !== true && this.listenerCount("part") !== 0) { + this.emit("part", this._part); + } else { + this._ignore(); + } + if (!this._isPreamble) { + this._inHeader = true; + } + } + if (data && start < end && !this._ignoreData) { + if (this._isPreamble || !this._inHeader) { + if (buf) { + shouldWriteMore = this._part.push(buf); + } + shouldWriteMore = this._part.push(data.slice(start, end)); + if (!shouldWriteMore) { + this._pause = true; + } + } else if (!this._isPreamble && this._inHeader) { + if (buf) { + this._hparser.push(buf); + } + r = this._hparser.push(data.slice(start, end)); + if (!this._inHeader && r !== void 0 && r < end) { + this._oninfo(false, data, start + r, end); + } + } + } + if (isMatch) { + this._hparser.reset(); + if (this._isPreamble) { + this._isPreamble = false; + } else { + if (start !== end) { + ++this._parts; + this._part.on("end", function() { + if (--self2._parts === 0) { + if (self2._finished) { + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + } else { + self2._unpause(); + } + } + }); + } + } + this._part.push(null); + this._part = void 0; + this._ignoreData = false; + this._justMatched = true; + this._dashes = 0; + } + }; + Dicer.prototype._unpause = function() { + if (!this._pause) { + return; + } + this._pause = false; + if (this._cb) { + const cb = this._cb; + this._cb = void 0; + cb(); + } + }; + module2.exports = Dicer; + } +}); + +// node_modules/@fastify/busboy/lib/utils/decodeText.js +var require_decodeText = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) { + "use strict"; + var utf8Decoder = new TextDecoder("utf-8"); + var textDecoders = /* @__PURE__ */ new Map([ + ["utf-8", utf8Decoder], + ["utf8", utf8Decoder] + ]); + function getDecoder(charset) { + let lc; + while (true) { + switch (charset) { + case "utf-8": + case "utf8": + return decoders.utf8; + case "latin1": + case "ascii": + // TODO: Make these a separate, strict decoder? + case "us-ascii": + case "iso-8859-1": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "windows-1252": + case "iso_8859-1:1987": + case "cp1252": + case "x-cp1252": + return decoders.latin1; + case "utf16le": + case "utf-16le": + case "ucs2": + case "ucs-2": + return decoders.utf16le; + case "base64": + return decoders.base64; + default: + if (lc === void 0) { + lc = true; + charset = charset.toLowerCase(); + continue; + } + return decoders.other.bind(charset); + } + } + } + var decoders = { + utf8: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.utf8Slice(0, data.length); + }, + latin1: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + return data; + } + return data.latin1Slice(0, data.length); + }, + utf16le: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.ucs2Slice(0, data.length); + }, + base64: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.base64Slice(0, data.length); + }, + other: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + if (textDecoders.has(exports2.toString())) { + try { + return textDecoders.get(exports2).decode(data); + } catch { + } + } + return typeof data === "string" ? data : data.toString(); + } + }; + function decodeText(text, sourceEncoding, destEncoding) { + if (text) { + return getDecoder(destEncoding)(text, sourceEncoding); + } + return text; + } + module2.exports = decodeText; + } +}); + +// node_modules/@fastify/busboy/lib/utils/parseParams.js +var require_parseParams = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) { + "use strict"; + var decodeText = require_decodeText(); + var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g; + var EncodedLookup = { + "%00": "\0", + "%01": "", + "%02": "", + "%03": "", + "%04": "", + "%05": "", + "%06": "", + "%07": "\x07", + "%08": "\b", + "%09": " ", + "%0a": "\n", + "%0A": "\n", + "%0b": "\v", + "%0B": "\v", + "%0c": "\f", + "%0C": "\f", + "%0d": "\r", + "%0D": "\r", + "%0e": "", + "%0E": "", + "%0f": "", + "%0F": "", + "%10": "", + "%11": "", + "%12": "", + "%13": "", + "%14": "", + "%15": "", + "%16": "", + "%17": "", + "%18": "", + "%19": "", + "%1a": "", + "%1A": "", + "%1b": "\x1B", + "%1B": "\x1B", + "%1c": "", + "%1C": "", + "%1d": "", + "%1D": "", + "%1e": "", + "%1E": "", + "%1f": "", + "%1F": "", + "%20": " ", + "%21": "!", + "%22": '"', + "%23": "#", + "%24": "$", + "%25": "%", + "%26": "&", + "%27": "'", + "%28": "(", + "%29": ")", + "%2a": "*", + "%2A": "*", + "%2b": "+", + "%2B": "+", + "%2c": ",", + "%2C": ",", + "%2d": "-", + "%2D": "-", + "%2e": ".", + "%2E": ".", + "%2f": "/", + "%2F": "/", + "%30": "0", + "%31": "1", + "%32": "2", + "%33": "3", + "%34": "4", + "%35": "5", + "%36": "6", + "%37": "7", + "%38": "8", + "%39": "9", + "%3a": ":", + "%3A": ":", + "%3b": ";", + "%3B": ";", + "%3c": "<", + "%3C": "<", + "%3d": "=", + "%3D": "=", + "%3e": ">", + "%3E": ">", + "%3f": "?", + "%3F": "?", + "%40": "@", + "%41": "A", + "%42": "B", + "%43": "C", + "%44": "D", + "%45": "E", + "%46": "F", + "%47": "G", + "%48": "H", + "%49": "I", + "%4a": "J", + "%4A": "J", + "%4b": "K", + "%4B": "K", + "%4c": "L", + "%4C": "L", + "%4d": "M", + "%4D": "M", + "%4e": "N", + "%4E": "N", + "%4f": "O", + "%4F": "O", + "%50": "P", + "%51": "Q", + "%52": "R", + "%53": "S", + "%54": "T", + "%55": "U", + "%56": "V", + "%57": "W", + "%58": "X", + "%59": "Y", + "%5a": "Z", + "%5A": "Z", + "%5b": "[", + "%5B": "[", + "%5c": "\\", + "%5C": "\\", + "%5d": "]", + "%5D": "]", + "%5e": "^", + "%5E": "^", + "%5f": "_", + "%5F": "_", + "%60": "`", + "%61": "a", + "%62": "b", + "%63": "c", + "%64": "d", + "%65": "e", + "%66": "f", + "%67": "g", + "%68": "h", + "%69": "i", + "%6a": "j", + "%6A": "j", + "%6b": "k", + "%6B": "k", + "%6c": "l", + "%6C": "l", + "%6d": "m", + "%6D": "m", + "%6e": "n", + "%6E": "n", + "%6f": "o", + "%6F": "o", + "%70": "p", + "%71": "q", + "%72": "r", + "%73": "s", + "%74": "t", + "%75": "u", + "%76": "v", + "%77": "w", + "%78": "x", + "%79": "y", + "%7a": "z", + "%7A": "z", + "%7b": "{", + "%7B": "{", + "%7c": "|", + "%7C": "|", + "%7d": "}", + "%7D": "}", + "%7e": "~", + "%7E": "~", + "%7f": "\x7F", + "%7F": "\x7F", + "%80": "\x80", + "%81": "\x81", + "%82": "\x82", + "%83": "\x83", + "%84": "\x84", + "%85": "\x85", + "%86": "\x86", + "%87": "\x87", + "%88": "\x88", + "%89": "\x89", + "%8a": "\x8A", + "%8A": "\x8A", + "%8b": "\x8B", + "%8B": "\x8B", + "%8c": "\x8C", + "%8C": "\x8C", + "%8d": "\x8D", + "%8D": "\x8D", + "%8e": "\x8E", + "%8E": "\x8E", + "%8f": "\x8F", + "%8F": "\x8F", + "%90": "\x90", + "%91": "\x91", + "%92": "\x92", + "%93": "\x93", + "%94": "\x94", + "%95": "\x95", + "%96": "\x96", + "%97": "\x97", + "%98": "\x98", + "%99": "\x99", + "%9a": "\x9A", + "%9A": "\x9A", + "%9b": "\x9B", + "%9B": "\x9B", + "%9c": "\x9C", + "%9C": "\x9C", + "%9d": "\x9D", + "%9D": "\x9D", + "%9e": "\x9E", + "%9E": "\x9E", + "%9f": "\x9F", + "%9F": "\x9F", + "%a0": "\xA0", + "%A0": "\xA0", + "%a1": "\xA1", + "%A1": "\xA1", + "%a2": "\xA2", + "%A2": "\xA2", + "%a3": "\xA3", + "%A3": "\xA3", + "%a4": "\xA4", + "%A4": "\xA4", + "%a5": "\xA5", + "%A5": "\xA5", + "%a6": "\xA6", + "%A6": "\xA6", + "%a7": "\xA7", + "%A7": "\xA7", + "%a8": "\xA8", + "%A8": "\xA8", + "%a9": "\xA9", + "%A9": "\xA9", + "%aa": "\xAA", + "%Aa": "\xAA", + "%aA": "\xAA", + "%AA": "\xAA", + "%ab": "\xAB", + "%Ab": "\xAB", + "%aB": "\xAB", + "%AB": "\xAB", + "%ac": "\xAC", + "%Ac": "\xAC", + "%aC": "\xAC", + "%AC": "\xAC", + "%ad": "\xAD", + "%Ad": "\xAD", + "%aD": "\xAD", + "%AD": "\xAD", + "%ae": "\xAE", + "%Ae": "\xAE", + "%aE": "\xAE", + "%AE": "\xAE", + "%af": "\xAF", + "%Af": "\xAF", + "%aF": "\xAF", + "%AF": "\xAF", + "%b0": "\xB0", + "%B0": "\xB0", + "%b1": "\xB1", + "%B1": "\xB1", + "%b2": "\xB2", + "%B2": "\xB2", + "%b3": "\xB3", + "%B3": "\xB3", + "%b4": "\xB4", + "%B4": "\xB4", + "%b5": "\xB5", + "%B5": "\xB5", + "%b6": "\xB6", + "%B6": "\xB6", + "%b7": "\xB7", + "%B7": "\xB7", + "%b8": "\xB8", + "%B8": "\xB8", + "%b9": "\xB9", + "%B9": "\xB9", + "%ba": "\xBA", + "%Ba": "\xBA", + "%bA": "\xBA", + "%BA": "\xBA", + "%bb": "\xBB", + "%Bb": "\xBB", + "%bB": "\xBB", + "%BB": "\xBB", + "%bc": "\xBC", + "%Bc": "\xBC", + "%bC": "\xBC", + "%BC": "\xBC", + "%bd": "\xBD", + "%Bd": "\xBD", + "%bD": "\xBD", + "%BD": "\xBD", + "%be": "\xBE", + "%Be": "\xBE", + "%bE": "\xBE", + "%BE": "\xBE", + "%bf": "\xBF", + "%Bf": "\xBF", + "%bF": "\xBF", + "%BF": "\xBF", + "%c0": "\xC0", + "%C0": "\xC0", + "%c1": "\xC1", + "%C1": "\xC1", + "%c2": "\xC2", + "%C2": "\xC2", + "%c3": "\xC3", + "%C3": "\xC3", + "%c4": "\xC4", + "%C4": "\xC4", + "%c5": "\xC5", + "%C5": "\xC5", + "%c6": "\xC6", + "%C6": "\xC6", + "%c7": "\xC7", + "%C7": "\xC7", + "%c8": "\xC8", + "%C8": "\xC8", + "%c9": "\xC9", + "%C9": "\xC9", + "%ca": "\xCA", + "%Ca": "\xCA", + "%cA": "\xCA", + "%CA": "\xCA", + "%cb": "\xCB", + "%Cb": "\xCB", + "%cB": "\xCB", + "%CB": "\xCB", + "%cc": "\xCC", + "%Cc": "\xCC", + "%cC": "\xCC", + "%CC": "\xCC", + "%cd": "\xCD", + "%Cd": "\xCD", + "%cD": "\xCD", + "%CD": "\xCD", + "%ce": "\xCE", + "%Ce": "\xCE", + "%cE": "\xCE", + "%CE": "\xCE", + "%cf": "\xCF", + "%Cf": "\xCF", + "%cF": "\xCF", + "%CF": "\xCF", + "%d0": "\xD0", + "%D0": "\xD0", + "%d1": "\xD1", + "%D1": "\xD1", + "%d2": "\xD2", + "%D2": "\xD2", + "%d3": "\xD3", + "%D3": "\xD3", + "%d4": "\xD4", + "%D4": "\xD4", + "%d5": "\xD5", + "%D5": "\xD5", + "%d6": "\xD6", + "%D6": "\xD6", + "%d7": "\xD7", + "%D7": "\xD7", + "%d8": "\xD8", + "%D8": "\xD8", + "%d9": "\xD9", + "%D9": "\xD9", + "%da": "\xDA", + "%Da": "\xDA", + "%dA": "\xDA", + "%DA": "\xDA", + "%db": "\xDB", + "%Db": "\xDB", + "%dB": "\xDB", + "%DB": "\xDB", + "%dc": "\xDC", + "%Dc": "\xDC", + "%dC": "\xDC", + "%DC": "\xDC", + "%dd": "\xDD", + "%Dd": "\xDD", + "%dD": "\xDD", + "%DD": "\xDD", + "%de": "\xDE", + "%De": "\xDE", + "%dE": "\xDE", + "%DE": "\xDE", + "%df": "\xDF", + "%Df": "\xDF", + "%dF": "\xDF", + "%DF": "\xDF", + "%e0": "\xE0", + "%E0": "\xE0", + "%e1": "\xE1", + "%E1": "\xE1", + "%e2": "\xE2", + "%E2": "\xE2", + "%e3": "\xE3", + "%E3": "\xE3", + "%e4": "\xE4", + "%E4": "\xE4", + "%e5": "\xE5", + "%E5": "\xE5", + "%e6": "\xE6", + "%E6": "\xE6", + "%e7": "\xE7", + "%E7": "\xE7", + "%e8": "\xE8", + "%E8": "\xE8", + "%e9": "\xE9", + "%E9": "\xE9", + "%ea": "\xEA", + "%Ea": "\xEA", + "%eA": "\xEA", + "%EA": "\xEA", + "%eb": "\xEB", + "%Eb": "\xEB", + "%eB": "\xEB", + "%EB": "\xEB", + "%ec": "\xEC", + "%Ec": "\xEC", + "%eC": "\xEC", + "%EC": "\xEC", + "%ed": "\xED", + "%Ed": "\xED", + "%eD": "\xED", + "%ED": "\xED", + "%ee": "\xEE", + "%Ee": "\xEE", + "%eE": "\xEE", + "%EE": "\xEE", + "%ef": "\xEF", + "%Ef": "\xEF", + "%eF": "\xEF", + "%EF": "\xEF", + "%f0": "\xF0", + "%F0": "\xF0", + "%f1": "\xF1", + "%F1": "\xF1", + "%f2": "\xF2", + "%F2": "\xF2", + "%f3": "\xF3", + "%F3": "\xF3", + "%f4": "\xF4", + "%F4": "\xF4", + "%f5": "\xF5", + "%F5": "\xF5", + "%f6": "\xF6", + "%F6": "\xF6", + "%f7": "\xF7", + "%F7": "\xF7", + "%f8": "\xF8", + "%F8": "\xF8", + "%f9": "\xF9", + "%F9": "\xF9", + "%fa": "\xFA", + "%Fa": "\xFA", + "%fA": "\xFA", + "%FA": "\xFA", + "%fb": "\xFB", + "%Fb": "\xFB", + "%fB": "\xFB", + "%FB": "\xFB", + "%fc": "\xFC", + "%Fc": "\xFC", + "%fC": "\xFC", + "%FC": "\xFC", + "%fd": "\xFD", + "%Fd": "\xFD", + "%fD": "\xFD", + "%FD": "\xFD", + "%fe": "\xFE", + "%Fe": "\xFE", + "%fE": "\xFE", + "%FE": "\xFE", + "%ff": "\xFF", + "%Ff": "\xFF", + "%fF": "\xFF", + "%FF": "\xFF" + }; + function encodedReplacer(match) { + return EncodedLookup[match]; + } + var STATE_KEY = 0; + var STATE_VALUE = 1; + var STATE_CHARSET = 2; + var STATE_LANG = 3; + function parseParams(str) { + const res = []; + let state = STATE_KEY; + let charset = ""; + let inquote = false; + let escaping = false; + let p = 0; + let tmp = ""; + const len = str.length; + for (var i = 0; i < len; ++i) { + const char = str[i]; + if (char === "\\" && inquote) { + if (escaping) { + escaping = false; + } else { + escaping = true; + continue; + } + } else if (char === '"') { + if (!escaping) { + if (inquote) { + inquote = false; + state = STATE_KEY; + } else { + inquote = true; + } + continue; + } else { + escaping = false; + } + } else { + if (escaping && inquote) { + tmp += "\\"; + } + escaping = false; + if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") { + if (state === STATE_CHARSET) { + state = STATE_LANG; + charset = tmp.substring(1); + } else { + state = STATE_VALUE; + } + tmp = ""; + continue; + } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) { + state = char === "*" ? STATE_CHARSET : STATE_VALUE; + res[p] = [tmp, void 0]; + tmp = ""; + continue; + } else if (!inquote && char === ";") { + state = STATE_KEY; + if (charset) { + if (tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } + charset = ""; + } else if (tmp.length) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + res[p] = tmp; + } else { + res[p][1] = tmp; + } + tmp = ""; + ++p; + continue; + } else if (!inquote && (char === " " || char === " ")) { + continue; + } + } + tmp += char; + } + if (charset && tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } else if (tmp) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + if (tmp) { + res[p] = tmp; + } + } else { + res[p][1] = tmp; + } + return res; + } + module2.exports = parseParams; + } +}); + +// node_modules/@fastify/busboy/lib/utils/basename.js +var require_basename = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) { + "use strict"; + module2.exports = function basename(path3) { + if (typeof path3 !== "string") { + return ""; + } + for (var i = path3.length - 1; i >= 0; --i) { + switch (path3.charCodeAt(i)) { + case 47: + // '/' + case 92: + path3 = path3.slice(i + 1); + return path3 === ".." || path3 === "." ? "" : path3; + } + } + return path3 === ".." || path3 === "." ? "" : path3; + }; + } +}); + +// node_modules/@fastify/busboy/lib/types/multipart.js +var require_multipart = __commonJS({ + "node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) { + "use strict"; + var { Readable } = require("node:stream"); + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var parseParams = require_parseParams(); + var decodeText = require_decodeText(); + var basename = require_basename(); + var getLimit = require_getLimit(); + var RE_BOUNDARY = /^boundary$/i; + var RE_FIELD = /^form-data$/i; + var RE_CHARSET = /^charset$/i; + var RE_FILENAME = /^filename$/i; + var RE_NAME = /^name$/i; + Multipart.detect = /^multipart\/form-data/i; + function Multipart(boy, cfg) { + let i; + let len; + const self2 = this; + let boundary; + const limits = cfg.limits; + const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0); + const parsedConType = cfg.parsedConType || []; + const defCharset = cfg.defCharset || "utf8"; + const preservePath = cfg.preservePath; + const fileOpts = { highWaterMark: cfg.fileHwm }; + for (i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) { + boundary = parsedConType[i][1]; + break; + } + } + function checkFinished() { + if (nends === 0 && finished && !boy._done) { + finished = false; + self2.end(); + } + } + if (typeof boundary !== "string") { + throw new Error("Multipart: Boundary not found"); + } + const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + const fileSizeLimit = getLimit(limits, "fileSize", Infinity); + const filesLimit = getLimit(limits, "files", Infinity); + const fieldsLimit = getLimit(limits, "fields", Infinity); + const partsLimit = getLimit(limits, "parts", Infinity); + const headerPairsLimit = getLimit(limits, "headerPairs", 2e3); + const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024); + let nfiles = 0; + let nfields = 0; + let nends = 0; + let curFile; + let curField; + let finished = false; + this._needDrain = false; + this._pause = false; + this._cb = void 0; + this._nparts = 0; + this._boy = boy; + const parserCfg = { + boundary, + maxHeaderPairs: headerPairsLimit, + maxHeaderSize: headerSizeLimit, + partHwm: fileOpts.highWaterMark, + highWaterMark: cfg.highWaterMark + }; + this.parser = new Dicer(parserCfg); + this.parser.on("drain", function() { + self2._needDrain = false; + if (self2._cb && !self2._pause) { + const cb = self2._cb; + self2._cb = void 0; + cb(); + } + }).on("part", function onPart(part) { + if (++self2._nparts > partsLimit) { + self2.parser.removeListener("part", onPart); + self2.parser.on("part", skipPart); + boy.hitPartsLimit = true; + boy.emit("partsLimit"); + return skipPart(part); + } + if (curField) { + const field = curField; + field.emit("end"); + field.removeAllListeners("end"); + } + part.on("header", function(header) { + let contype; + let fieldname; + let parsed; + let charset; + let encoding; + let filename; + let nsize = 0; + if (header["content-type"]) { + parsed = parseParams(header["content-type"][0]); + if (parsed[0]) { + contype = parsed[0].toLowerCase(); + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_CHARSET.test(parsed[i][0])) { + charset = parsed[i][1].toLowerCase(); + break; + } + } + } + } + if (contype === void 0) { + contype = "text/plain"; + } + if (charset === void 0) { + charset = defCharset; + } + if (header["content-disposition"]) { + parsed = parseParams(header["content-disposition"][0]); + if (!RE_FIELD.test(parsed[0])) { + return skipPart(part); + } + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_NAME.test(parsed[i][0])) { + fieldname = parsed[i][1]; + } else if (RE_FILENAME.test(parsed[i][0])) { + filename = parsed[i][1]; + if (!preservePath) { + filename = basename(filename); + } + } + } + } else { + return skipPart(part); + } + if (header["content-transfer-encoding"]) { + encoding = header["content-transfer-encoding"][0].toLowerCase(); + } else { + encoding = "7bit"; + } + let onData, onEnd; + if (isPartAFile(fieldname, contype, filename)) { + if (nfiles === filesLimit) { + if (!boy.hitFilesLimit) { + boy.hitFilesLimit = true; + boy.emit("filesLimit"); + } + return skipPart(part); + } + ++nfiles; + if (boy.listenerCount("file") === 0) { + self2.parser._ignore(); + return; + } + ++nends; + const file = new FileStream(fileOpts); + curFile = file; + file.on("end", function() { + --nends; + self2._pause = false; + checkFinished(); + if (self2._cb && !self2._needDrain) { + const cb = self2._cb; + self2._cb = void 0; + cb(); + } + }); + file._read = function(n) { + if (!self2._pause) { + return; + } + self2._pause = false; + if (self2._cb && !self2._needDrain) { + const cb = self2._cb; + self2._cb = void 0; + cb(); + } + }; + boy.emit("file", fieldname, file, filename, encoding, contype); + onData = function(data) { + if ((nsize += data.length) > fileSizeLimit) { + const extralen = fileSizeLimit - nsize + data.length; + if (extralen > 0) { + file.push(data.slice(0, extralen)); + } + file.truncated = true; + file.bytesRead = fileSizeLimit; + part.removeAllListeners("data"); + file.emit("limit"); + return; + } else if (!file.push(data)) { + self2._pause = true; + } + file.bytesRead = nsize; + }; + onEnd = function() { + curFile = void 0; + file.push(null); + }; + } else { + if (nfields === fieldsLimit) { + if (!boy.hitFieldsLimit) { + boy.hitFieldsLimit = true; + boy.emit("fieldsLimit"); + } + return skipPart(part); + } + ++nfields; + ++nends; + let buffer = ""; + let truncated = false; + curField = part; + onData = function(data) { + if ((nsize += data.length) > fieldSizeLimit) { + const extralen = fieldSizeLimit - (nsize - data.length); + buffer += data.toString("binary", 0, extralen); + truncated = true; + part.removeAllListeners("data"); + } else { + buffer += data.toString("binary"); + } + }; + onEnd = function() { + curField = void 0; + if (buffer.length) { + buffer = decodeText(buffer, "binary", charset); + } + boy.emit("field", fieldname, buffer, false, truncated, encoding, contype); + --nends; + checkFinished(); + }; + } + part._readableState.sync = false; + part.on("data", onData); + part.on("end", onEnd); + }).on("error", function(err) { + if (curFile) { + curFile.emit("error", err); + } + }); + }).on("error", function(err) { + boy.emit("error", err); + }).on("finish", function() { + finished = true; + checkFinished(); + }); + } + Multipart.prototype.write = function(chunk, cb) { + const r = this.parser.write(chunk); + if (r && !this._pause) { + cb(); + } else { + this._needDrain = !r; + this._cb = cb; + } + }; + Multipart.prototype.end = function() { + const self2 = this; + if (self2.parser.writable) { + self2.parser.end(); + } else if (!self2._boy._done) { + process.nextTick(function() { + self2._boy._done = true; + self2._boy.emit("finish"); + }); + } + }; + function skipPart(part) { + part.resume(); + } + function FileStream(opts) { + Readable.call(this, opts); + this.bytesRead = 0; + this.truncated = false; + } + inherits(FileStream, Readable); + FileStream.prototype._read = function(n) { + }; + module2.exports = Multipart; + } +}); + +// node_modules/@fastify/busboy/lib/utils/Decoder.js +var require_Decoder = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) { + "use strict"; + var RE_PLUS = /\+/g; + var HEX = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ]; + function Decoder() { + this.buffer = void 0; + } + Decoder.prototype.write = function(str) { + str = str.replace(RE_PLUS, " "); + let res = ""; + let i = 0; + let p = 0; + const len = str.length; + for (; i < len; ++i) { + if (this.buffer !== void 0) { + if (!HEX[str.charCodeAt(i)]) { + res += "%" + this.buffer; + this.buffer = void 0; + --i; + } else { + this.buffer += str[i]; + ++p; + if (this.buffer.length === 2) { + res += String.fromCharCode(parseInt(this.buffer, 16)); + this.buffer = void 0; + } + } + } else if (str[i] === "%") { + if (i > p) { + res += str.substring(p, i); + p = i; + } + this.buffer = ""; + ++p; + } + } + if (p < len && this.buffer === void 0) { + res += str.substring(p); + } + return res; + }; + Decoder.prototype.reset = function() { + this.buffer = void 0; + }; + module2.exports = Decoder; + } +}); + +// node_modules/@fastify/busboy/lib/types/urlencoded.js +var require_urlencoded = __commonJS({ + "node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) { + "use strict"; + var Decoder = require_Decoder(); + var decodeText = require_decodeText(); + var getLimit = require_getLimit(); + var RE_CHARSET = /^charset$/i; + UrlEncoded.detect = /^application\/x-www-form-urlencoded/i; + function UrlEncoded(boy, cfg) { + const limits = cfg.limits; + const parsedConType = cfg.parsedConType; + this.boy = boy; + this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100); + this.fieldsLimit = getLimit(limits, "fields", Infinity); + let charset; + for (var i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) { + charset = parsedConType[i][1].toLowerCase(); + break; + } + } + if (charset === void 0) { + charset = cfg.defCharset || "utf8"; + } + this.decoder = new Decoder(); + this.charset = charset; + this._fields = 0; + this._state = "key"; + this._checkingBytes = true; + this._bytesKey = 0; + this._bytesVal = 0; + this._key = ""; + this._val = ""; + this._keyTrunc = false; + this._valTrunc = false; + this._hitLimit = false; + } + UrlEncoded.prototype.write = function(data, cb) { + if (this._fields === this.fieldsLimit) { + if (!this.boy.hitFieldsLimit) { + this.boy.hitFieldsLimit = true; + this.boy.emit("fieldsLimit"); + } + return cb(); + } + let idxeq; + let idxamp; + let i; + let p = 0; + const len = data.length; + while (p < len) { + if (this._state === "key") { + idxeq = idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 61) { + idxeq = i; + break; + } else if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesKey; + } + } + if (idxeq !== void 0) { + if (idxeq > p) { + this._key += this.decoder.write(data.toString("binary", p, idxeq)); + } + this._state = "val"; + this._hitLimit = false; + this._checkingBytes = true; + this._val = ""; + this._bytesVal = 0; + this._valTrunc = false; + this.decoder.reset(); + p = idxeq + 1; + } else if (idxamp !== void 0) { + ++this._fields; + let key; + const keyTrunc = this._keyTrunc; + if (idxamp > p) { + key = this._key += this.decoder.write(data.toString("binary", p, idxamp)); + } else { + key = this._key; + } + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + if (key.length) { + this.boy.emit( + "field", + decodeText(key, "binary", this.charset), + "", + keyTrunc, + false + ); + } + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._key += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) { + this._checkingBytes = false; + this._keyTrunc = true; + } + } else { + if (p < len) { + this._key += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } else { + idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesVal; + } + } + if (idxamp !== void 0) { + ++this._fields; + if (idxamp > p) { + this._val += this.decoder.write(data.toString("binary", p, idxamp)); + } + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + this._state = "key"; + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._val += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) { + this._checkingBytes = false; + this._valTrunc = true; + } + } else { + if (p < len) { + this._val += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } + } + cb(); + }; + UrlEncoded.prototype.end = function() { + if (this.boy._done) { + return; + } + if (this._state === "key" && this._key.length > 0) { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + "", + this._keyTrunc, + false + ); + } else if (this._state === "val") { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + } + this.boy._done = true; + this.boy.emit("finish"); + }; + module2.exports = UrlEncoded; + } +}); + +// node_modules/@fastify/busboy/lib/main.js +var require_main = __commonJS({ + "node_modules/@fastify/busboy/lib/main.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var MultipartParser = require_multipart(); + var UrlencodedParser = require_urlencoded(); + var parseParams = require_parseParams(); + function Busboy(opts) { + if (!(this instanceof Busboy)) { + return new Busboy(opts); + } + if (typeof opts !== "object") { + throw new TypeError("Busboy expected an options-Object."); + } + if (typeof opts.headers !== "object") { + throw new TypeError("Busboy expected an options-Object with headers-attribute."); + } + if (typeof opts.headers["content-type"] !== "string") { + throw new TypeError("Missing Content-Type-header."); + } + const { + headers, + ...streamOptions + } = opts; + this.opts = { + autoDestroy: false, + ...streamOptions + }; + WritableStream.call(this, this.opts); + this._done = false; + this._parser = this.getParserByHeaders(headers); + this._finished = false; + } + inherits(Busboy, WritableStream); + Busboy.prototype.emit = function(ev) { + if (ev === "finish") { + if (!this._done) { + this._parser?.end(); + return; + } else if (this._finished) { + return; + } + this._finished = true; + } + WritableStream.prototype.emit.apply(this, arguments); + }; + Busboy.prototype.getParserByHeaders = function(headers) { + const parsed = parseParams(headers["content-type"]); + const cfg = { + defCharset: this.opts.defCharset, + fileHwm: this.opts.fileHwm, + headers, + highWaterMark: this.opts.highWaterMark, + isPartAFile: this.opts.isPartAFile, + limits: this.opts.limits, + parsedConType: parsed, + preservePath: this.opts.preservePath + }; + if (MultipartParser.detect.test(parsed[0])) { + return new MultipartParser(this, cfg); + } + if (UrlencodedParser.detect.test(parsed[0])) { + return new UrlencodedParser(this, cfg); + } + throw new Error("Unsupported Content-Type."); + }; + Busboy.prototype._write = function(chunk, encoding, cb) { + this._parser.write(chunk, cb); + }; + module2.exports = Busboy; + module2.exports.default = Busboy; + module2.exports.Busboy = Busboy; + module2.exports.Dicer = Dicer; + } +}); + +// node_modules/undici/lib/fetch/constants.js +var require_constants2 = __commonJS({ + "node_modules/undici/lib/fetch/constants.js"(exports2, module2) { + "use strict"; + var { MessageChannel, receiveMessageOnPort } = require("worker_threads"); + var corsSafeListedMethods = ["GET", "HEAD", "POST"]; + var corsSafeListedMethodsSet = new Set(corsSafeListedMethods); + var nullBodyStatus = [101, 204, 205, 304]; + var redirectStatus = [301, 302, 303, 307, 308]; + var redirectStatusSet = new Set(redirectStatus); + var badPorts = [ + "1", + "7", + "9", + "11", + "13", + "15", + "17", + "19", + "20", + "21", + "22", + "23", + "25", + "37", + "42", + "43", + "53", + "69", + "77", + "79", + "87", + "95", + "101", + "102", + "103", + "104", + "109", + "110", + "111", + "113", + "115", + "117", + "119", + "123", + "135", + "137", + "139", + "143", + "161", + "179", + "389", + "427", + "465", + "512", + "513", + "514", + "515", + "526", + "530", + "531", + "532", + "540", + "548", + "554", + "556", + "563", + "587", + "601", + "636", + "989", + "990", + "993", + "995", + "1719", + "1720", + "1723", + "2049", + "3659", + "4045", + "5060", + "5061", + "6000", + "6566", + "6665", + "6666", + "6667", + "6668", + "6669", + "6697", + "10080" + ]; + var badPortsSet = new Set(badPorts); + var referrerPolicy = [ + "", + "no-referrer", + "no-referrer-when-downgrade", + "same-origin", + "origin", + "strict-origin", + "origin-when-cross-origin", + "strict-origin-when-cross-origin", + "unsafe-url" + ]; + var referrerPolicySet = new Set(referrerPolicy); + var requestRedirect = ["follow", "manual", "error"]; + var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"]; + var safeMethodsSet = new Set(safeMethods); + var requestMode = ["navigate", "same-origin", "no-cors", "cors"]; + var requestCredentials = ["omit", "same-origin", "include"]; + var requestCache = [ + "default", + "no-store", + "reload", + "no-cache", + "force-cache", + "only-if-cached" + ]; + var requestBodyHeader = [ + "content-encoding", + "content-language", + "content-location", + "content-type", + // See https://github.com/nodejs/undici/issues/2021 + // 'Content-Length' is a forbidden header name, which is typically + // removed in the Headers implementation. However, undici doesn't + // filter out headers, so we add it here. + "content-length" + ]; + var requestDuplex = [ + "half" + ]; + var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"]; + var forbiddenMethodsSet = new Set(forbiddenMethods); + var subresource = [ + "audio", + "audioworklet", + "font", + "image", + "manifest", + "paintworklet", + "script", + "style", + "track", + "video", + "xslt", + "" + ]; + var subresourceSet = new Set(subresource); + var DOMException2 = globalThis.DOMException ?? (() => { + try { + atob("~"); + } catch (err) { + return Object.getPrototypeOf(err).constructor; + } + })(); + var channel; + var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js + // structuredClone was added in v17.0.0, but fetch supports v16.8 + function structuredClone2(value, options = void 0) { + if (arguments.length === 0) { + throw new TypeError("missing argument"); + } + if (!channel) { + channel = new MessageChannel(); + } + channel.port1.unref(); + channel.port2.unref(); + channel.port1.postMessage(value, options?.transfer); + return receiveMessageOnPort(channel.port2).message; + }; + module2.exports = { + DOMException: DOMException2, + structuredClone, + subresource, + forbiddenMethods, + requestBodyHeader, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + redirectStatus, + corsSafeListedMethods, + nullBodyStatus, + safeMethods, + badPorts, + requestDuplex, + subresourceSet, + badPortsSet, + redirectStatusSet, + corsSafeListedMethodsSet, + safeMethodsSet, + forbiddenMethodsSet, + referrerPolicySet + }; + } +}); + +// node_modules/undici/lib/fetch/global.js +var require_global = __commonJS({ + "node_modules/undici/lib/fetch/global.js"(exports2, module2) { + "use strict"; + var globalOrigin = Symbol.for("undici.globalOrigin.1"); + function getGlobalOrigin() { + return globalThis[globalOrigin]; + } + function setGlobalOrigin(newOrigin) { + if (newOrigin === void 0) { + Object.defineProperty(globalThis, globalOrigin, { + value: void 0, + writable: true, + enumerable: false, + configurable: false + }); + return; + } + const parsedURL = new URL(newOrigin); + if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") { + throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`); + } + Object.defineProperty(globalThis, globalOrigin, { + value: parsedURL, + writable: true, + enumerable: false, + configurable: false + }); + } + module2.exports = { + getGlobalOrigin, + setGlobalOrigin + }; + } +}); + +// node_modules/undici/lib/fetch/util.js +var require_util2 = __commonJS({ + "node_modules/undici/lib/fetch/util.js"(exports2, module2) { + "use strict"; + var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2(); + var { getGlobalOrigin } = require_global(); + var { performance: performance2 } = require("perf_hooks"); + var { isBlobLike: isBlobLike2, toUSVString, ReadableStreamFrom: ReadableStreamFrom3 } = require_util(); + var assert = require("assert"); + var { isUint8Array } = require("util/types"); + var supportedHashes = []; + var crypto; + try { + crypto = require("crypto"); + const possibleRelevantHashes = ["sha256", "sha384", "sha512"]; + supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)); + } catch { + } + function responseURL(response) { + const urlList = response.urlList; + const length = urlList.length; + return length === 0 ? null : urlList[length - 1].toString(); + } + function responseLocationURL(response, requestFragment) { + if (!redirectStatusSet.has(response.status)) { + return null; + } + let location = response.headersList.get("location"); + if (location !== null && isValidHeaderValue(location)) { + location = new URL(location, responseURL(response)); + } + if (location && !location.hash) { + location.hash = requestFragment; + } + return location; + } + function requestCurrentURL(request) { + return request.urlList[request.urlList.length - 1]; + } + function requestBadPort(request) { + const url = requestCurrentURL(request); + if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) { + return "blocked"; + } + return "allowed"; + } + function isErrorLike(object) { + return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException"); + } + function isValidReasonPhrase(statusText) { + for (let i = 0; i < statusText.length; ++i) { + const c = statusText.charCodeAt(i); + if (!(c === 9 || // HTAB + c >= 32 && c <= 126 || // SP / VCHAR + c >= 128 && c <= 255)) { + return false; + } + } + return true; + } + function isTokenCharCode(c) { + switch (c) { + case 34: + case 40: + case 41: + case 44: + case 47: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 91: + case 92: + case 93: + case 123: + case 125: + return false; + default: + return c >= 33 && c <= 126; + } + } + function isValidHTTPToken(characters) { + if (characters.length === 0) { + return false; + } + for (let i = 0; i < characters.length; ++i) { + if (!isTokenCharCode(characters.charCodeAt(i))) { + return false; + } + } + return true; + } + function isValidHeaderName(potentialValue) { + return isValidHTTPToken(potentialValue); + } + function isValidHeaderValue(potentialValue) { + if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) { + return false; + } + if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) { + return false; + } + return true; + } + function setRequestReferrerPolicyOnRedirect(request, actualResponse) { + const { headersList } = actualResponse; + const policyHeader = (headersList.get("referrer-policy") ?? "").split(","); + let policy = ""; + if (policyHeader.length > 0) { + for (let i = policyHeader.length; i !== 0; i--) { + const token = policyHeader[i - 1].trim(); + if (referrerPolicyTokens.has(token)) { + policy = token; + break; + } + } + } + if (policy !== "") { + request.referrerPolicy = policy; + } + } + function crossOriginResourcePolicyCheck() { + return "allowed"; + } + function corsCheck() { + return "success"; + } + function TAOCheck() { + return "success"; + } + function appendFetchMetadata(httpRequest) { + let header = null; + header = httpRequest.mode; + httpRequest.headersList.set("sec-fetch-mode", header); + } + function appendRequestOriginHeader(request) { + let serializedOrigin = request.origin; + if (request.responseTainting === "cors" || request.mode === "websocket") { + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } else if (request.method !== "GET" && request.method !== "HEAD") { + switch (request.referrerPolicy) { + case "no-referrer": + serializedOrigin = null; + break; + case "no-referrer-when-downgrade": + case "strict-origin": + case "strict-origin-when-cross-origin": + if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + case "same-origin": + if (!sameOrigin(request, requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + default: + } + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } + } + function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) { + return performance2.now(); + } + function createOpaqueTimingInfo(timingInfo) { + return { + startTime: timingInfo.startTime ?? 0, + redirectStartTime: 0, + redirectEndTime: 0, + postRedirectStartTime: timingInfo.startTime ?? 0, + finalServiceWorkerStartTime: 0, + finalNetworkResponseStartTime: 0, + finalNetworkRequestStartTime: 0, + endTime: 0, + encodedBodySize: 0, + decodedBodySize: 0, + finalConnectionTimingInfo: null + }; + } + function makePolicyContainer() { + return { + referrerPolicy: "strict-origin-when-cross-origin" + }; + } + function clonePolicyContainer(policyContainer) { + return { + referrerPolicy: policyContainer.referrerPolicy + }; + } + function determineRequestsReferrer(request) { + const policy = request.referrerPolicy; + assert(policy); + let referrerSource = null; + if (request.referrer === "client") { + const globalOrigin = getGlobalOrigin(); + if (!globalOrigin || globalOrigin.origin === "null") { + return "no-referrer"; + } + referrerSource = new URL(globalOrigin); + } else if (request.referrer instanceof URL) { + referrerSource = request.referrer; + } + let referrerURL = stripURLForReferrer(referrerSource); + const referrerOrigin = stripURLForReferrer(referrerSource, true); + if (referrerURL.toString().length > 4096) { + referrerURL = referrerOrigin; + } + const areSameOrigin = sameOrigin(request, referrerURL); + const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url); + switch (policy) { + case "origin": + return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true); + case "unsafe-url": + return referrerURL; + case "same-origin": + return areSameOrigin ? referrerOrigin : "no-referrer"; + case "origin-when-cross-origin": + return areSameOrigin ? referrerURL : referrerOrigin; + case "strict-origin-when-cross-origin": { + const currentURL = requestCurrentURL(request); + if (sameOrigin(referrerURL, currentURL)) { + return referrerURL; + } + if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) { + return "no-referrer"; + } + return referrerOrigin; + } + case "strict-origin": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + case "no-referrer-when-downgrade": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + default: + return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin; + } + } + function stripURLForReferrer(url, originOnly) { + assert(url instanceof URL); + if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") { + return "no-referrer"; + } + url.username = ""; + url.password = ""; + url.hash = ""; + if (originOnly) { + url.pathname = ""; + url.search = ""; + } + return url; + } + function isURLPotentiallyTrustworthy(url) { + if (!(url instanceof URL)) { + return false; + } + if (url.href === "about:blank" || url.href === "about:srcdoc") { + return true; + } + if (url.protocol === "data:") return true; + if (url.protocol === "file:") return true; + return isOriginPotentiallyTrustworthy(url.origin); + function isOriginPotentiallyTrustworthy(origin) { + if (origin == null || origin === "null") return false; + const originAsURL = new URL(origin); + if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") { + return true; + } + if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) { + return true; + } + return false; + } + } + function bytesMatch(bytes, metadataList) { + if (crypto === void 0) { + return true; + } + const parsedMetadata = parseMetadata(metadataList); + if (parsedMetadata === "no metadata") { + return true; + } + if (parsedMetadata.length === 0) { + return true; + } + const strongest = getStrongestMetadata(parsedMetadata); + const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest); + for (const item of metadata) { + const algorithm = item.algo; + const expectedValue = item.hash; + let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64"); + if (actualValue[actualValue.length - 1] === "=") { + if (actualValue[actualValue.length - 2] === "=") { + actualValue = actualValue.slice(0, -2); + } else { + actualValue = actualValue.slice(0, -1); + } + } + if (compareBase64Mixed(actualValue, expectedValue)) { + return true; + } + } + return false; + } + var parseHashWithOptions = /(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i; + function parseMetadata(metadata) { + const result = []; + let empty = true; + for (const token of metadata.split(" ")) { + empty = false; + const parsedToken = parseHashWithOptions.exec(token); + if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) { + continue; + } + const algorithm = parsedToken.groups.algo.toLowerCase(); + if (supportedHashes.includes(algorithm)) { + result.push(parsedToken.groups); + } + } + if (empty === true) { + return "no metadata"; + } + return result; + } + function getStrongestMetadata(metadataList) { + let algorithm = metadataList[0].algo; + if (algorithm[3] === "5") { + return algorithm; + } + for (let i = 1; i < metadataList.length; ++i) { + const metadata = metadataList[i]; + if (metadata.algo[3] === "5") { + algorithm = "sha512"; + break; + } else if (algorithm[3] === "3") { + continue; + } else if (metadata.algo[3] === "3") { + algorithm = "sha384"; + } + } + return algorithm; + } + function filterMetadataListByAlgorithm(metadataList, algorithm) { + if (metadataList.length === 1) { + return metadataList; + } + let pos = 0; + for (let i = 0; i < metadataList.length; ++i) { + if (metadataList[i].algo === algorithm) { + metadataList[pos++] = metadataList[i]; + } + } + metadataList.length = pos; + return metadataList; + } + function compareBase64Mixed(actualValue, expectedValue) { + if (actualValue.length !== expectedValue.length) { + return false; + } + for (let i = 0; i < actualValue.length; ++i) { + if (actualValue[i] !== expectedValue[i]) { + if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") { + continue; + } + return false; + } + } + return true; + } + function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) { + } + function sameOrigin(A, B) { + if (A.origin === B.origin && A.origin === "null") { + return true; + } + if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) { + return true; + } + return false; + } + function createDeferredPromise() { + let res; + let rej; + const promise = new Promise((resolve, reject) => { + res = resolve; + rej = reject; + }); + return { promise, resolve: res, reject: rej }; + } + function isAborted(fetchParams) { + return fetchParams.controller.state === "aborted"; + } + function isCancelled(fetchParams) { + return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated"; + } + var normalizeMethodRecord = { + delete: "DELETE", + DELETE: "DELETE", + get: "GET", + GET: "GET", + head: "HEAD", + HEAD: "HEAD", + options: "OPTIONS", + OPTIONS: "OPTIONS", + post: "POST", + POST: "POST", + put: "PUT", + PUT: "PUT" + }; + Object.setPrototypeOf(normalizeMethodRecord, null); + function normalizeMethod(method) { + return normalizeMethodRecord[method.toLowerCase()] ?? method; + } + function serializeJavascriptValueToJSONString(value) { + const result = JSON.stringify(value); + if (result === void 0) { + throw new TypeError("Value is not JSON serializable"); + } + assert(typeof result === "string"); + return result; + } + var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); + function makeIterator(iterator, name, kind) { + const object = { + index: 0, + kind, + target: iterator + }; + const i = { + next() { + if (Object.getPrototypeOf(this) !== i) { + throw new TypeError( + `'next' called on an object that does not implement interface ${name} Iterator.` + ); + } + const { index, kind: kind2, target } = object; + const values = target(); + const len = values.length; + if (index >= len) { + return { value: void 0, done: true }; + } + const pair = values[index]; + object.index = index + 1; + return iteratorResult(pair, kind2); + }, + // The class string of an iterator prototype object for a given interface is the + // result of concatenating the identifier of the interface and the string " Iterator". + [Symbol.toStringTag]: `${name} Iterator` + }; + Object.setPrototypeOf(i, esIteratorPrototype); + return Object.setPrototypeOf({}, i); + } + function iteratorResult(pair, kind) { + let result; + switch (kind) { + case "key": { + result = pair[0]; + break; + } + case "value": { + result = pair[1]; + break; + } + case "key+value": { + result = pair; + break; + } + } + return { value: result, done: false }; + } + async function fullyReadBody(body, processBody, processBodyError) { + const successSteps = processBody; + const errorSteps = processBodyError; + let reader; + try { + reader = body.stream.getReader(); + } catch (e) { + errorSteps(e); + return; + } + try { + const result = await readAllBytes(reader); + successSteps(result); + } catch (e) { + errorSteps(e); + } + } + var ReadableStream = globalThis.ReadableStream; + function isReadableStreamLike(stream) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function"; + } + var MAXIMUM_ARGUMENT_LENGTH = 65535; + function isomorphicDecode(input) { + if (input.length < MAXIMUM_ARGUMENT_LENGTH) { + return String.fromCharCode(...input); + } + return input.reduce((previous, current) => previous + String.fromCharCode(current), ""); + } + function readableStreamClose(controller) { + try { + controller.close(); + } catch (err) { + if (!err.message.includes("Controller is already closed")) { + throw err; + } + } + } + function isomorphicEncode(input) { + for (let i = 0; i < input.length; i++) { + assert(input.charCodeAt(i) <= 255); + } + return input; + } + async function readAllBytes(reader) { + const bytes = []; + let byteLength = 0; + while (true) { + const { done, value: chunk } = await reader.read(); + if (done) { + return Buffer.concat(bytes, byteLength); + } + if (!isUint8Array(chunk)) { + throw new TypeError("Received non-Uint8Array chunk"); + } + bytes.push(chunk); + byteLength += chunk.length; + } + } + function urlIsLocal(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "about:" || protocol === "blob:" || protocol === "data:"; + } + function urlHasHttpsScheme(url) { + if (typeof url === "string") { + return url.startsWith("https:"); + } + return url.protocol === "https:"; + } + function urlIsHttpHttpsScheme(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "http:" || protocol === "https:"; + } + var hasOwn3 = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key)); + module2.exports = { + isAborted, + isCancelled, + createDeferredPromise, + ReadableStreamFrom: ReadableStreamFrom3, + toUSVString, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + coarsenedSharedCurrentTime, + determineRequestsReferrer, + makePolicyContainer, + clonePolicyContainer, + appendFetchMetadata, + appendRequestOriginHeader, + TAOCheck, + corsCheck, + crossOriginResourcePolicyCheck, + createOpaqueTimingInfo, + setRequestReferrerPolicyOnRedirect, + isValidHTTPToken, + requestBadPort, + requestCurrentURL, + responseURL, + responseLocationURL, + isBlobLike: isBlobLike2, + isURLPotentiallyTrustworthy, + isValidReasonPhrase, + sameOrigin, + normalizeMethod, + serializeJavascriptValueToJSONString, + makeIterator, + isValidHeaderName, + isValidHeaderValue, + hasOwn: hasOwn3, + isErrorLike, + fullyReadBody, + bytesMatch, + isReadableStreamLike, + readableStreamClose, + isomorphicEncode, + isomorphicDecode, + urlIsLocal, + urlHasHttpsScheme, + urlIsHttpHttpsScheme, + readAllBytes, + normalizeMethodRecord, + parseMetadata + }; + } +}); + +// node_modules/undici/lib/fetch/symbols.js +var require_symbols2 = __commonJS({ + "node_modules/undici/lib/fetch/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kUrl: Symbol("url"), + kHeaders: Symbol("headers"), + kSignal: Symbol("signal"), + kState: Symbol("state"), + kGuard: Symbol("guard"), + kRealm: Symbol("realm") + }; + } +}); + +// node_modules/undici/lib/fetch/webidl.js +var require_webidl = __commonJS({ + "node_modules/undici/lib/fetch/webidl.js"(exports2, module2) { + "use strict"; + var { types } = require("util"); + var { hasOwn: hasOwn3, toUSVString } = require_util2(); + var webidl = {}; + webidl.converters = {}; + webidl.util = {}; + webidl.errors = {}; + webidl.errors.exception = function(message) { + return new TypeError(`${message.header}: ${message.message}`); + }; + webidl.errors.conversionFailed = function(context2) { + const plural = context2.types.length === 1 ? "" : " one of"; + const message = `${context2.argument} could not be converted to${plural}: ${context2.types.join(", ")}.`; + return webidl.errors.exception({ + header: context2.prefix, + message + }); + }; + webidl.errors.invalidArgument = function(context2) { + return webidl.errors.exception({ + header: context2.prefix, + message: `"${context2.value}" is an invalid ${context2.type}.` + }); + }; + webidl.brandCheck = function(V, I, opts = void 0) { + if (opts?.strict !== false && !(V instanceof I)) { + throw new TypeError("Illegal invocation"); + } else { + return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag]; + } + }; + webidl.argumentLengthCheck = function({ length }, min, ctx) { + if (length < min) { + throw webidl.errors.exception({ + message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`, + ...ctx + }); + } + }; + webidl.illegalConstructor = function() { + throw webidl.errors.exception({ + header: "TypeError", + message: "Illegal constructor" + }); + }; + webidl.util.Type = function(V) { + switch (typeof V) { + case "undefined": + return "Undefined"; + case "boolean": + return "Boolean"; + case "string": + return "String"; + case "symbol": + return "Symbol"; + case "number": + return "Number"; + case "bigint": + return "BigInt"; + case "function": + case "object": { + if (V === null) { + return "Null"; + } + return "Object"; + } + } + }; + webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) { + let upperBound; + let lowerBound; + if (bitLength === 64) { + upperBound = Math.pow(2, 53) - 1; + if (signedness === "unsigned") { + lowerBound = 0; + } else { + lowerBound = Math.pow(-2, 53) + 1; + } + } else if (signedness === "unsigned") { + lowerBound = 0; + upperBound = Math.pow(2, bitLength) - 1; + } else { + lowerBound = Math.pow(-2, bitLength) - 1; + upperBound = Math.pow(2, bitLength - 1) - 1; + } + let x = Number(V); + if (x === 0) { + x = 0; + } + if (opts.enforceRange === true) { + if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Could not convert ${V} to an integer.` + }); + } + x = webidl.util.IntegerPart(x); + if (x < lowerBound || x > upperBound) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` + }); + } + return x; + } + if (!Number.isNaN(x) && opts.clamp === true) { + x = Math.min(Math.max(x, lowerBound), upperBound); + if (Math.floor(x) % 2 === 0) { + x = Math.floor(x); + } else { + x = Math.ceil(x); + } + return x; + } + if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + return 0; + } + x = webidl.util.IntegerPart(x); + x = x % Math.pow(2, bitLength); + if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) { + return x - Math.pow(2, bitLength); + } + return x; + }; + webidl.util.IntegerPart = function(n) { + const r = Math.floor(Math.abs(n)); + if (n < 0) { + return -1 * r; + } + return r; + }; + webidl.sequenceConverter = function(converter) { + return (V) => { + if (webidl.util.Type(V) !== "Object") { + throw webidl.errors.exception({ + header: "Sequence", + message: `Value of type ${webidl.util.Type(V)} is not an Object.` + }); + } + const method = V?.[Symbol.iterator]?.(); + const seq = []; + if (method === void 0 || typeof method.next !== "function") { + throw webidl.errors.exception({ + header: "Sequence", + message: "Object is not an iterator." + }); + } + while (true) { + const { done, value } = method.next(); + if (done) { + break; + } + seq.push(converter(value)); + } + return seq; + }; + }; + webidl.recordConverter = function(keyConverter, valueConverter) { + return (O) => { + if (webidl.util.Type(O) !== "Object") { + throw webidl.errors.exception({ + header: "Record", + message: `Value of type ${webidl.util.Type(O)} is not an Object.` + }); + } + const result = {}; + if (!types.isProxy(O)) { + const keys2 = Object.keys(O); + for (const key of keys2) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + return result; + } + const keys = Reflect.ownKeys(O); + for (const key of keys) { + const desc = Reflect.getOwnPropertyDescriptor(O, key); + if (desc?.enumerable) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + } + return result; + }; + }; + webidl.interfaceConverter = function(i) { + return (V, opts = {}) => { + if (opts.strict !== false && !(V instanceof i)) { + throw webidl.errors.exception({ + header: i.name, + message: `Expected ${V} to be an instance of ${i.name}.` + }); + } + return V; + }; + }; + webidl.dictionaryConverter = function(converters) { + return (dictionary) => { + const type = webidl.util.Type(dictionary); + const dict = {}; + if (type === "Null" || type === "Undefined") { + return dict; + } else if (type !== "Object") { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` + }); + } + for (const options of converters) { + const { key, defaultValue, required, converter } = options; + if (required === true) { + if (!hasOwn3(dictionary, key)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Missing required key "${key}".` + }); + } + } + let value = dictionary[key]; + const hasDefault = hasOwn3(options, "defaultValue"); + if (hasDefault && value !== null) { + value = value ?? defaultValue; + } + if (required || hasDefault || value !== void 0) { + value = converter(value); + if (options.allowedValues && !options.allowedValues.includes(value)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.` + }); + } + dict[key] = value; + } + } + return dict; + }; + }; + webidl.nullableConverter = function(converter) { + return (V) => { + if (V === null) { + return V; + } + return converter(V); + }; + }; + webidl.converters.DOMString = function(V, opts = {}) { + if (V === null && opts.legacyNullToEmptyString) { + return ""; + } + if (typeof V === "symbol") { + throw new TypeError("Could not convert argument of type symbol to string."); + } + return String(V); + }; + webidl.converters.ByteString = function(V) { + const x = webidl.converters.DOMString(V); + for (let index = 0; index < x.length; index++) { + if (x.charCodeAt(index) > 255) { + throw new TypeError( + `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.` + ); + } + } + return x; + }; + webidl.converters.USVString = toUSVString; + webidl.converters.boolean = function(V) { + const x = Boolean(V); + return x; + }; + webidl.converters.any = function(V) { + return V; + }; + webidl.converters["long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "signed"); + return x; + }; + webidl.converters["unsigned long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "unsigned"); + return x; + }; + webidl.converters["unsigned long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 32, "unsigned"); + return x; + }; + webidl.converters["unsigned short"] = function(V, opts) { + const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts); + return x; + }; + webidl.converters.ArrayBuffer = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) { + throw webidl.errors.conversionFailed({ + prefix: `${V}`, + argument: `${V}`, + types: ["ArrayBuffer"] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.TypedArray = function(V, T, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) { + throw webidl.errors.conversionFailed({ + prefix: `${T.name}`, + argument: `${V}`, + types: [T.name] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.DataView = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) { + throw webidl.errors.exception({ + header: "DataView", + message: "Object is not a DataView." + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.BufferSource = function(V, opts = {}) { + if (types.isAnyArrayBuffer(V)) { + return webidl.converters.ArrayBuffer(V, opts); + } + if (types.isTypedArray(V)) { + return webidl.converters.TypedArray(V, V.constructor); + } + if (types.isDataView(V)) { + return webidl.converters.DataView(V, opts); + } + throw new TypeError(`Could not convert ${V} to a BufferSource.`); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.ByteString + ); + webidl.converters["sequence>"] = webidl.sequenceConverter( + webidl.converters["sequence"] + ); + webidl.converters["record"] = webidl.recordConverter( + webidl.converters.ByteString, + webidl.converters.ByteString + ); + module2.exports = { + webidl + }; + } +}); + +// node_modules/undici/lib/fetch/dataURL.js +var require_dataURL = __commonJS({ + "node_modules/undici/lib/fetch/dataURL.js"(exports2, module2) { + var assert = require("assert"); + var { atob: atob2 } = require("buffer"); + var { isomorphicDecode } = require_util2(); + var encoder = new TextEncoder(); + var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/; + var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/; + var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/; + function dataURLProcessor(dataURL) { + assert(dataURL.protocol === "data:"); + let input = URLSerializer(dataURL, true); + input = input.slice(5); + const position = { position: 0 }; + let mimeType = collectASequenceOfCodePointsFast( + ",", + input, + position + ); + const mimeTypeLength = mimeType.length; + mimeType = removeASCIIWhitespace(mimeType, true, true); + if (position.position >= input.length) { + return "failure"; + } + position.position++; + const encodedBody = input.slice(mimeTypeLength + 1); + let body = stringPercentDecode(encodedBody); + if (/;(\u0020){0,}base64$/i.test(mimeType)) { + const stringBody = isomorphicDecode(body); + body = forgivingBase64(stringBody); + if (body === "failure") { + return "failure"; + } + mimeType = mimeType.slice(0, -6); + mimeType = mimeType.replace(/(\u0020)+$/, ""); + mimeType = mimeType.slice(0, -1); + } + if (mimeType.startsWith(";")) { + mimeType = "text/plain" + mimeType; + } + let mimeTypeRecord = parseMIMEType(mimeType); + if (mimeTypeRecord === "failure") { + mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII"); + } + return { mimeType: mimeTypeRecord, body }; + } + function URLSerializer(url, excludeFragment = false) { + if (!excludeFragment) { + return url.href; + } + const href = url.href; + const hashLength = url.hash.length; + return hashLength === 0 ? href : href.substring(0, href.length - hashLength); + } + function collectASequenceOfCodePoints(condition, input, position) { + let result = ""; + while (position.position < input.length && condition(input[position.position])) { + result += input[position.position]; + position.position++; + } + return result; + } + function collectASequenceOfCodePointsFast(char, input, position) { + const idx = input.indexOf(char, position.position); + const start = position.position; + if (idx === -1) { + position.position = input.length; + return input.slice(start); + } + position.position = idx; + return input.slice(start, position.position); + } + function stringPercentDecode(input) { + const bytes = encoder.encode(input); + return percentDecode(bytes); + } + function percentDecode(input) { + const output = []; + for (let i = 0; i < input.length; i++) { + const byte = input[i]; + if (byte !== 37) { + output.push(byte); + } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) { + output.push(37); + } else { + const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]); + const bytePoint = Number.parseInt(nextTwoBytes, 16); + output.push(bytePoint); + i += 2; + } + } + return Uint8Array.from(output); + } + function parseMIMEType(input) { + input = removeHTTPWhitespace(input, true, true); + const position = { position: 0 }; + const type = collectASequenceOfCodePointsFast( + "/", + input, + position + ); + if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) { + return "failure"; + } + if (position.position > input.length) { + return "failure"; + } + position.position++; + let subtype = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + subtype = removeHTTPWhitespace(subtype, false, true); + if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) { + return "failure"; + } + const typeLowercase = type.toLowerCase(); + const subtypeLowercase = subtype.toLowerCase(); + const mimeType = { + type: typeLowercase, + subtype: subtypeLowercase, + /** @type {Map} */ + parameters: /* @__PURE__ */ new Map(), + // https://mimesniff.spec.whatwg.org/#mime-type-essence + essence: `${typeLowercase}/${subtypeLowercase}` + }; + while (position.position < input.length) { + position.position++; + collectASequenceOfCodePoints( + // https://fetch.spec.whatwg.org/#http-whitespace + (char) => HTTP_WHITESPACE_REGEX.test(char), + input, + position + ); + let parameterName = collectASequenceOfCodePoints( + (char) => char !== ";" && char !== "=", + input, + position + ); + parameterName = parameterName.toLowerCase(); + if (position.position < input.length) { + if (input[position.position] === ";") { + continue; + } + position.position++; + } + if (position.position > input.length) { + break; + } + let parameterValue = null; + if (input[position.position] === '"') { + parameterValue = collectAnHTTPQuotedString(input, position, true); + collectASequenceOfCodePointsFast( + ";", + input, + position + ); + } else { + parameterValue = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + parameterValue = removeHTTPWhitespace(parameterValue, false, true); + if (parameterValue.length === 0) { + continue; + } + } + if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) { + mimeType.parameters.set(parameterName, parameterValue); + } + } + return mimeType; + } + function forgivingBase64(data) { + data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, ""); + if (data.length % 4 === 0) { + data = data.replace(/=?=$/, ""); + } + if (data.length % 4 === 1) { + return "failure"; + } + if (/[^+/0-9A-Za-z]/.test(data)) { + return "failure"; + } + const binary = atob2(data); + const bytes = new Uint8Array(binary.length); + for (let byte = 0; byte < binary.length; byte++) { + bytes[byte] = binary.charCodeAt(byte); + } + return bytes; + } + function collectAnHTTPQuotedString(input, position, extractValue) { + const positionStart = position.position; + let value = ""; + assert(input[position.position] === '"'); + position.position++; + while (true) { + value += collectASequenceOfCodePoints( + (char) => char !== '"' && char !== "\\", + input, + position + ); + if (position.position >= input.length) { + break; + } + const quoteOrBackslash = input[position.position]; + position.position++; + if (quoteOrBackslash === "\\") { + if (position.position >= input.length) { + value += "\\"; + break; + } + value += input[position.position]; + position.position++; + } else { + assert(quoteOrBackslash === '"'); + break; + } + } + if (extractValue) { + return value; + } + return input.slice(positionStart, position.position); + } + function serializeAMimeType(mimeType) { + assert(mimeType !== "failure"); + const { parameters, essence } = mimeType; + let serialization = essence; + for (let [name, value] of parameters.entries()) { + serialization += ";"; + serialization += name; + serialization += "="; + if (!HTTP_TOKEN_CODEPOINTS.test(value)) { + value = value.replace(/(\\|")/g, "\\$1"); + value = '"' + value; + value += '"'; + } + serialization += value; + } + return serialization; + } + function isHTTPWhiteSpace(char) { + return char === "\r" || char === "\n" || char === " " || char === " "; + } + function removeHTTPWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + function isASCIIWhitespace(char) { + return char === "\r" || char === "\n" || char === " " || char === "\f" || char === " "; + } + function removeASCIIWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + module2.exports = { + dataURLProcessor, + URLSerializer, + collectASequenceOfCodePoints, + collectASequenceOfCodePointsFast, + stringPercentDecode, + parseMIMEType, + collectAnHTTPQuotedString, + serializeAMimeType + }; + } +}); + +// node_modules/undici/lib/fetch/file.js +var require_file = __commonJS({ + "node_modules/undici/lib/fetch/file.js"(exports2, module2) { + "use strict"; + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { types } = require("util"); + var { kState } = require_symbols2(); + var { isBlobLike: isBlobLike2 } = require_util2(); + var { webidl } = require_webidl(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var { kEnumerableProperty } = require_util(); + var encoder = new TextEncoder(); + var File2 = class _File extends Blob2 { + constructor(fileBits, fileName, options = {}) { + webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" }); + fileBits = webidl.converters["sequence"](fileBits); + fileName = webidl.converters.USVString(fileName); + options = webidl.converters.FilePropertyBag(options); + const n = fileName; + let t = options.type; + let d; + substep: { + if (t) { + t = parseMIMEType(t); + if (t === "failure") { + t = ""; + break substep; + } + t = serializeAMimeType(t).toLowerCase(); + } + d = options.lastModified; + } + super(processBlobParts(fileBits, options), { type: t }); + this[kState] = { + name: n, + lastModified: d, + type: t + }; + } + get name() { + webidl.brandCheck(this, _File); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _File); + return this[kState].lastModified; + } + get type() { + webidl.brandCheck(this, _File); + return this[kState].type; + } + }; + var FileLike = class _FileLike { + constructor(blobLike, fileName, options = {}) { + const n = fileName; + const t = options.type; + const d = options.lastModified ?? Date.now(); + this[kState] = { + blobLike, + name: n, + type: t, + lastModified: d + }; + } + stream(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.stream(...args); + } + arrayBuffer(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.arrayBuffer(...args); + } + slice(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.slice(...args); + } + text(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.text(...args); + } + get size() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.size; + } + get type() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.type; + } + get name() { + webidl.brandCheck(this, _FileLike); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _FileLike); + return this[kState].lastModified; + } + get [Symbol.toStringTag]() { + return "File"; + } + }; + Object.defineProperties(File2.prototype, { + [Symbol.toStringTag]: { + value: "File", + configurable: true + }, + name: kEnumerableProperty, + lastModified: kEnumerableProperty + }); + webidl.converters.Blob = webidl.interfaceConverter(Blob2); + webidl.converters.BlobPart = function(V, opts) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V, opts); + } + } + return webidl.converters.USVString(V, opts); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.BlobPart + ); + webidl.converters.FilePropertyBag = webidl.dictionaryConverter([ + { + key: "lastModified", + converter: webidl.converters["long long"], + get defaultValue() { + return Date.now(); + } + }, + { + key: "type", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "endings", + converter: (value) => { + value = webidl.converters.DOMString(value); + value = value.toLowerCase(); + if (value !== "native") { + value = "transparent"; + } + return value; + }, + defaultValue: "transparent" + } + ]); + function processBlobParts(parts, options) { + const bytes = []; + for (const element of parts) { + if (typeof element === "string") { + let s = element; + if (options.endings === "native") { + s = convertLineEndingsNative(s); + } + bytes.push(encoder.encode(s)); + } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) { + if (!element.buffer) { + bytes.push(new Uint8Array(element)); + } else { + bytes.push( + new Uint8Array(element.buffer, element.byteOffset, element.byteLength) + ); + } + } else if (isBlobLike2(element)) { + bytes.push(element); + } + } + return bytes; + } + function convertLineEndingsNative(s) { + let nativeLineEnding = "\n"; + if (process.platform === "win32") { + nativeLineEnding = "\r\n"; + } + return s.replace(/\r?\n/g, nativeLineEnding); + } + function isFileLike2(object) { + return NativeFile && object instanceof NativeFile || object instanceof File2 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File"; + } + module2.exports = { File: File2, FileLike, isFileLike: isFileLike2 }; + } +}); + +// node_modules/undici/lib/fetch/formdata.js +var require_formdata = __commonJS({ + "node_modules/undici/lib/fetch/formdata.js"(exports2, module2) { + "use strict"; + var { isBlobLike: isBlobLike2, toUSVString, makeIterator } = require_util2(); + var { kState } = require_symbols2(); + var { File: UndiciFile, FileLike, isFileLike: isFileLike2 } = require_file(); + var { webidl } = require_webidl(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var File2 = NativeFile ?? UndiciFile; + var FormData2 = class _FormData { + constructor(form) { + if (form !== void 0) { + throw webidl.errors.conversionFailed({ + prefix: "FormData constructor", + argument: "Argument 1", + types: ["undefined"] + }); + } + this[kState] = []; + } + append(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + this[kState].push(entry); + } + delete(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" }); + name = webidl.converters.USVString(name); + this[kState] = this[kState].filter((entry) => entry.name !== name); + } + get(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" }); + name = webidl.converters.USVString(name); + const idx = this[kState].findIndex((entry) => entry.name === name); + if (idx === -1) { + return null; + } + return this[kState][idx].value; + } + getAll(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" }); + name = webidl.converters.USVString(name); + return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); + } + has(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" }); + name = webidl.converters.USVString(name); + return this[kState].findIndex((entry) => entry.name === name) !== -1; + } + set(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? toUSVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + const idx = this[kState].findIndex((entry2) => entry2.name === name); + if (idx !== -1) { + this[kState] = [ + ...this[kState].slice(0, idx), + entry, + ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name) + ]; + } else { + this[kState].push(entry); + } + } + entries() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key+value" + ); + } + keys() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key" + ); + } + values() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "value" + ); + } + /** + * @param {(value: string, key: string, self: FormData) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'." + ); + } + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); + } + } + }; + FormData2.prototype[Symbol.iterator] = FormData2.prototype.entries; + Object.defineProperties(FormData2.prototype, { + [Symbol.toStringTag]: { + value: "FormData", + configurable: true + } + }); + function makeEntry(name, value, filename) { + name = Buffer.from(name).toString("utf8"); + if (typeof value === "string") { + value = Buffer.from(value).toString("utf8"); + } else { + if (!isFileLike2(value)) { + value = value instanceof Blob2 ? new File2([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type }); + } + if (filename !== void 0) { + const options = { + type: value.type, + lastModified: value.lastModified + }; + value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File2([value], filename, options) : new FileLike(value, filename, options); + } + } + return { name, value }; + } + module2.exports = { FormData: FormData2 }; + } +}); + +// node_modules/undici/lib/fetch/body.js +var require_body = __commonJS({ + "node_modules/undici/lib/fetch/body.js"(exports2, module2) { + "use strict"; + var Busboy = require_main(); + var util = require_util(); + var { + ReadableStreamFrom: ReadableStreamFrom3, + isBlobLike: isBlobLike2, + isReadableStreamLike, + readableStreamClose, + createDeferredPromise, + fullyReadBody + } = require_util2(); + var { FormData: FormData2 } = require_formdata(); + var { kState } = require_symbols2(); + var { webidl } = require_webidl(); + var { DOMException: DOMException2, structuredClone } = require_constants2(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { isErrored } = require_util(); + var { isUint8Array, isArrayBuffer } = require("util/types"); + var { File: UndiciFile } = require_file(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var random; + try { + const crypto = require("node:crypto"); + random = (max) => crypto.randomInt(0, max); + } catch { + random = (max) => Math.floor(Math.random(max)); + } + var ReadableStream = globalThis.ReadableStream; + var File2 = NativeFile ?? UndiciFile; + var textEncoder = new TextEncoder(); + var textDecoder = new TextDecoder(); + function extractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + let stream = null; + if (object instanceof ReadableStream) { + stream = object; + } else if (isBlobLike2(object)) { + stream = object.stream(); + } else { + stream = new ReadableStream({ + async pull(controller) { + controller.enqueue( + typeof source === "string" ? textEncoder.encode(source) : source + ); + queueMicrotask(() => readableStreamClose(controller)); + }, + start() { + }, + type: void 0 + }); + } + assert(isReadableStreamLike(stream)); + let action = null; + let source = null; + let length = null; + let type = null; + if (typeof object === "string") { + source = object; + type = "text/plain;charset=UTF-8"; + } else if (object instanceof URLSearchParams) { + source = object.toString(); + type = "application/x-www-form-urlencoded;charset=UTF-8"; + } else if (isArrayBuffer(object)) { + source = new Uint8Array(object.slice()); + } else if (ArrayBuffer.isView(object)) { + source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)); + } else if (util.isFormDataLike(object)) { + const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`; + const prefix = `--${boundary}\r +Content-Disposition: form-data`; + const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); + const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n"); + const blobParts = []; + const rn = new Uint8Array([13, 10]); + length = 0; + let hasUnknownSizeValue = false; + for (const [name, value] of object) { + if (typeof value === "string") { + const chunk2 = textEncoder.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r +\r +${normalizeLinefeeds(value)}\r +`); + blobParts.push(chunk2); + length += chunk2.byteLength; + } else { + const chunk2 = textEncoder.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r +Content-Type: ${value.type || "application/octet-stream"}\r +\r +`); + blobParts.push(chunk2, value, rn); + if (typeof value.size === "number") { + length += chunk2.byteLength + value.size + rn.byteLength; + } else { + hasUnknownSizeValue = true; + } + } + } + const chunk = textEncoder.encode(`--${boundary}--`); + blobParts.push(chunk); + length += chunk.byteLength; + if (hasUnknownSizeValue) { + length = null; + } + source = object; + action = async function* () { + for (const part of blobParts) { + if (part.stream) { + yield* part.stream(); + } else { + yield part; + } + } + }; + type = "multipart/form-data; boundary=" + boundary; + } else if (isBlobLike2(object)) { + source = object; + length = object.size; + if (object.type) { + type = object.type; + } + } else if (typeof object[Symbol.asyncIterator] === "function") { + if (keepalive) { + throw new TypeError("keepalive"); + } + if (util.isDisturbed(object) || object.locked) { + throw new TypeError( + "Response body object should not be disturbed or locked" + ); + } + stream = object instanceof ReadableStream ? object : ReadableStreamFrom3(object); + } + if (typeof source === "string" || util.isBuffer(source)) { + length = Buffer.byteLength(source); + } + if (action != null) { + let iterator; + stream = new ReadableStream({ + async start() { + iterator = action(object)[Symbol.asyncIterator](); + }, + async pull(controller) { + const { value, done } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + if (!isErrored(stream)) { + controller.enqueue(new Uint8Array(value)); + } + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: void 0 + }); + } + const body = { stream, source, length }; + return [body, type]; + } + function safelyExtractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (object instanceof ReadableStream) { + assert(!util.isDisturbed(object), "The body has already been consumed."); + assert(!object.locked, "The stream is locked."); + } + return extractBody(object, keepalive); + } + function cloneBody(body) { + const [out1, out2] = body.stream.tee(); + const out2Clone = structuredClone(out2, { transfer: [out2] }); + const [, finalClone] = out2Clone.tee(); + body.stream = out1; + return { + stream: finalClone, + length: body.length, + source: body.source + }; + } + async function* consumeBody(body) { + if (body) { + if (isUint8Array(body)) { + yield body; + } else { + const stream = body.stream; + if (util.isDisturbed(stream)) { + throw new TypeError("The body has already been consumed."); + } + if (stream.locked) { + throw new TypeError("The stream is locked."); + } + stream[kBodyUsed] = true; + yield* stream; + } + } + } + function throwIfAborted(state) { + if (state.aborted) { + throw new DOMException2("The operation was aborted.", "AbortError"); + } + } + function bodyMixinMethods(instance) { + const methods = { + blob() { + return specConsumeBody(this, (bytes) => { + let mimeType = bodyMimeType(this); + if (mimeType === "failure") { + mimeType = ""; + } else if (mimeType) { + mimeType = serializeAMimeType(mimeType); + } + return new Blob2([bytes], { type: mimeType }); + }, instance); + }, + arrayBuffer() { + return specConsumeBody(this, (bytes) => { + return new Uint8Array(bytes).buffer; + }, instance); + }, + text() { + return specConsumeBody(this, utf8DecodeBytes, instance); + }, + json() { + return specConsumeBody(this, parseJSONFromBytes, instance); + }, + async formData() { + webidl.brandCheck(this, instance); + throwIfAborted(this[kState]); + const contentType = this.headers.get("Content-Type"); + if (/multipart\/form-data/.test(contentType)) { + const headers = {}; + for (const [key, value] of this.headers) headers[key.toLowerCase()] = value; + const responseFormData = new FormData2(); + let busboy; + try { + busboy = new Busboy({ + headers, + preservePath: true + }); + } catch (err) { + throw new DOMException2(`${err}`, "AbortError"); + } + busboy.on("field", (name, value) => { + responseFormData.append(name, value); + }); + busboy.on("file", (name, value, filename, encoding, mimeType) => { + const chunks = []; + if (encoding === "base64" || encoding.toLowerCase() === "base64") { + let base64chunk = ""; + value.on("data", (chunk) => { + base64chunk += chunk.toString().replace(/[\r\n]/gm, ""); + const end = base64chunk.length - base64chunk.length % 4; + chunks.push(Buffer.from(base64chunk.slice(0, end), "base64")); + base64chunk = base64chunk.slice(end); + }); + value.on("end", () => { + chunks.push(Buffer.from(base64chunk, "base64")); + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } else { + value.on("data", (chunk) => { + chunks.push(chunk); + }); + value.on("end", () => { + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } + }); + const busboyResolve = new Promise((resolve, reject) => { + busboy.on("finish", resolve); + busboy.on("error", (err) => reject(new TypeError(err))); + }); + if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk); + busboy.end(); + await busboyResolve; + return responseFormData; + } else if (/application\/x-www-form-urlencoded/.test(contentType)) { + let entries; + try { + let text = ""; + const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true }); + for await (const chunk of consumeBody(this[kState].body)) { + if (!isUint8Array(chunk)) { + throw new TypeError("Expected Uint8Array chunk"); + } + text += streamingDecoder.decode(chunk, { stream: true }); + } + text += streamingDecoder.decode(); + entries = new URLSearchParams(text); + } catch (err) { + throw Object.assign(new TypeError(), { cause: err }); + } + const formData = new FormData2(); + for (const [name, value] of entries) { + formData.append(name, value); + } + return formData; + } else { + await Promise.resolve(); + throwIfAborted(this[kState]); + throw webidl.errors.exception({ + header: `${instance.name}.formData`, + message: "Could not parse content as FormData." + }); + } + } + }; + return methods; + } + function mixinBody(prototype) { + Object.assign(prototype.prototype, bodyMixinMethods(prototype)); + } + async function specConsumeBody(object, convertBytesToJSValue, instance) { + webidl.brandCheck(object, instance); + throwIfAborted(object[kState]); + if (bodyUnusable(object[kState].body)) { + throw new TypeError("Body is unusable"); + } + const promise = createDeferredPromise(); + const errorSteps = (error) => promise.reject(error); + const successSteps = (data) => { + try { + promise.resolve(convertBytesToJSValue(data)); + } catch (e) { + errorSteps(e); + } + }; + if (object[kState].body == null) { + successSteps(new Uint8Array()); + return promise.promise; + } + await fullyReadBody(object[kState].body, successSteps, errorSteps); + return promise.promise; + } + function bodyUnusable(body) { + return body != null && (body.stream.locked || util.isDisturbed(body.stream)); + } + function utf8DecodeBytes(buffer) { + if (buffer.length === 0) { + return ""; + } + if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) { + buffer = buffer.subarray(3); + } + const output = textDecoder.decode(buffer); + return output; + } + function parseJSONFromBytes(bytes) { + return JSON.parse(utf8DecodeBytes(bytes)); + } + function bodyMimeType(object) { + const { headersList } = object[kState]; + const contentType = headersList.get("content-type"); + if (contentType === null) { + return "failure"; + } + return parseMIMEType(contentType); + } + module2.exports = { + extractBody, + safelyExtractBody, + cloneBody, + mixinBody + }; + } +}); + +// node_modules/undici/lib/core/request.js +var require_request = __commonJS({ + "node_modules/undici/lib/core/request.js"(exports2, module2) { + "use strict"; + var { + InvalidArgumentError, + NotSupportedError + } = require_errors(); + var assert = require("assert"); + var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols(); + var util = require_util(); + var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/; + var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; + var invalidPathRegex = /[^\u0021-\u00ff]/; + var kHandler = Symbol("handler"); + var channels = {}; + var extractBody; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.create = diagnosticsChannel.channel("undici:request:create"); + channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent"); + channels.headers = diagnosticsChannel.channel("undici:request:headers"); + channels.trailers = diagnosticsChannel.channel("undici:request:trailers"); + channels.error = diagnosticsChannel.channel("undici:request:error"); + } catch { + channels.create = { hasSubscribers: false }; + channels.bodySent = { hasSubscribers: false }; + channels.headers = { hasSubscribers: false }; + channels.trailers = { hasSubscribers: false }; + channels.error = { hasSubscribers: false }; + } + var Request = class _Request { + constructor(origin, { + path: path3, + method, + body, + headers, + query, + idempotent, + blocking, + upgrade, + headersTimeout, + bodyTimeout, + reset, + throwOnError, + expectContinue + }, handler) { + if (typeof path3 !== "string") { + throw new InvalidArgumentError("path must be a string"); + } else if (path3[0] !== "/" && !(path3.startsWith("http://") || path3.startsWith("https://")) && method !== "CONNECT") { + throw new InvalidArgumentError("path must be an absolute URL or start with a slash"); + } else if (invalidPathRegex.exec(path3) !== null) { + throw new InvalidArgumentError("invalid request path"); + } + if (typeof method !== "string") { + throw new InvalidArgumentError("method must be a string"); + } else if (tokenRegExp.exec(method) === null) { + throw new InvalidArgumentError("invalid request method"); + } + if (upgrade && typeof upgrade !== "string") { + throw new InvalidArgumentError("upgrade must be a string"); + } + if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("invalid headersTimeout"); + } + if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("invalid bodyTimeout"); + } + if (reset != null && typeof reset !== "boolean") { + throw new InvalidArgumentError("invalid reset"); + } + if (expectContinue != null && typeof expectContinue !== "boolean") { + throw new InvalidArgumentError("invalid expectContinue"); + } + this.headersTimeout = headersTimeout; + this.bodyTimeout = bodyTimeout; + this.throwOnError = throwOnError === true; + this.method = method; + this.abort = null; + if (body == null) { + this.body = null; + } else if (util.isStream(body)) { + this.body = body; + const rState = this.body._readableState; + if (!rState || !rState.autoDestroy) { + this.endHandler = function autoDestroy() { + util.destroy(this); + }; + this.body.on("end", this.endHandler); + } + this.errorHandler = (err) => { + if (this.abort) { + this.abort(err); + } else { + this.error = err; + } + }; + this.body.on("error", this.errorHandler); + } else if (util.isBuffer(body)) { + this.body = body.byteLength ? body : null; + } else if (ArrayBuffer.isView(body)) { + this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null; + } else if (body instanceof ArrayBuffer) { + this.body = body.byteLength ? Buffer.from(body) : null; + } else if (typeof body === "string") { + this.body = body.length ? Buffer.from(body) : null; + } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) { + this.body = body; + } else { + throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable"); + } + this.completed = false; + this.aborted = false; + this.upgrade = upgrade || null; + this.path = query ? util.buildURL(path3, query) : path3; + this.origin = origin; + this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; + this.blocking = blocking == null ? false : blocking; + this.reset = reset == null ? null : reset; + this.host = null; + this.contentLength = null; + this.contentType = null; + this.headers = ""; + this.expectContinue = expectContinue != null ? expectContinue : false; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(this, headers[i], headers[i + 1]); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(this, key, headers[key]); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + if (util.isFormDataLike(this.body)) { + if (util.nodeMajor < 16 || util.nodeMajor === 16 && util.nodeMinor < 8) { + throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer."); + } + if (!extractBody) { + extractBody = require_body().extractBody; + } + const [bodyStream, contentType] = extractBody(body); + if (this.contentType == null) { + this.contentType = contentType; + this.headers += `content-type: ${contentType}\r +`; + } + this.body = bodyStream.stream; + this.contentLength = bodyStream.length; + } else if (util.isBlobLike(body) && this.contentType == null && body.type) { + this.contentType = body.type; + this.headers += `content-type: ${body.type}\r +`; + } + util.validateHandler(handler, method, upgrade); + this.servername = util.getServerName(this.host); + this[kHandler] = handler; + if (channels.create.hasSubscribers) { + channels.create.publish({ request: this }); + } + } + onBodySent(chunk) { + if (this[kHandler].onBodySent) { + try { + return this[kHandler].onBodySent(chunk); + } catch (err) { + this.abort(err); + } + } + } + onRequestSent() { + if (channels.bodySent.hasSubscribers) { + channels.bodySent.publish({ request: this }); + } + if (this[kHandler].onRequestSent) { + try { + return this[kHandler].onRequestSent(); + } catch (err) { + this.abort(err); + } + } + } + onConnect(abort) { + assert(!this.aborted); + assert(!this.completed); + if (this.error) { + abort(this.error); + } else { + this.abort = abort; + return this[kHandler].onConnect(abort); + } + } + onHeaders(statusCode, headers, resume, statusText) { + assert(!this.aborted); + assert(!this.completed); + if (channels.headers.hasSubscribers) { + channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }); + } + try { + return this[kHandler].onHeaders(statusCode, headers, resume, statusText); + } catch (err) { + this.abort(err); + } + } + onData(chunk) { + assert(!this.aborted); + assert(!this.completed); + try { + return this[kHandler].onData(chunk); + } catch (err) { + this.abort(err); + return false; + } + } + onUpgrade(statusCode, headers, socket) { + assert(!this.aborted); + assert(!this.completed); + return this[kHandler].onUpgrade(statusCode, headers, socket); + } + onComplete(trailers) { + this.onFinally(); + assert(!this.aborted); + this.completed = true; + if (channels.trailers.hasSubscribers) { + channels.trailers.publish({ request: this, trailers }); + } + try { + return this[kHandler].onComplete(trailers); + } catch (err) { + this.onError(err); + } + } + onError(error) { + this.onFinally(); + if (channels.error.hasSubscribers) { + channels.error.publish({ request: this, error }); + } + if (this.aborted) { + return; + } + this.aborted = true; + return this[kHandler].onError(error); + } + onFinally() { + if (this.errorHandler) { + this.body.off("error", this.errorHandler); + this.errorHandler = null; + } + if (this.endHandler) { + this.body.off("end", this.endHandler); + this.endHandler = null; + } + } + // TODO: adjust to support H2 + addHeader(key, value) { + processHeader(this, key, value); + return this; + } + static [kHTTP1BuildRequest](origin, opts, handler) { + return new _Request(origin, opts, handler); + } + static [kHTTP2BuildRequest](origin, opts, handler) { + const headers = opts.headers; + opts = { ...opts, headers: null }; + const request = new _Request(origin, opts, handler); + request.headers = {}; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(request, headers[i], headers[i + 1], true); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(request, key, headers[key], true); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + return request; + } + static [kHTTP2CopyHeaders](raw) { + const rawHeaders = raw.split("\r\n"); + const headers = {}; + for (const header of rawHeaders) { + const [key, value] = header.split(": "); + if (value == null || value.length === 0) continue; + if (headers[key]) headers[key] += `,${value}`; + else headers[key] = value; + } + return headers; + } + }; + function processHeaderValue(key, val, skipAppend) { + if (val && typeof val === "object") { + throw new InvalidArgumentError(`invalid ${key} header`); + } + val = val != null ? `${val}` : ""; + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + return skipAppend ? val : `${key}: ${val}\r +`; + } + function processHeader(request, key, val, skipAppend = false) { + if (val && (typeof val === "object" && !Array.isArray(val))) { + throw new InvalidArgumentError(`invalid ${key} header`); + } else if (val === void 0) { + return; + } + if (request.host === null && key.length === 4 && key.toLowerCase() === "host") { + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + request.host = val; + } else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") { + request.contentLength = parseInt(val, 10); + if (!Number.isFinite(request.contentLength)) { + throw new InvalidArgumentError("invalid content-length header"); + } + } else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") { + request.contentType = val; + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); + } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") { + throw new InvalidArgumentError("invalid transfer-encoding header"); + } else if (key.length === 10 && key.toLowerCase() === "connection") { + const value = typeof val === "string" ? val.toLowerCase() : null; + if (value !== "close" && value !== "keep-alive") { + throw new InvalidArgumentError("invalid connection header"); + } else if (value === "close") { + request.reset = true; + } + } else if (key.length === 10 && key.toLowerCase() === "keep-alive") { + throw new InvalidArgumentError("invalid keep-alive header"); + } else if (key.length === 7 && key.toLowerCase() === "upgrade") { + throw new InvalidArgumentError("invalid upgrade header"); + } else if (key.length === 6 && key.toLowerCase() === "expect") { + throw new NotSupportedError("expect header not supported"); + } else if (tokenRegExp.exec(key) === null) { + throw new InvalidArgumentError("invalid header key"); + } else { + if (Array.isArray(val)) { + for (let i = 0; i < val.length; i++) { + if (skipAppend) { + if (request.headers[key]) request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`; + else request.headers[key] = processHeaderValue(key, val[i], skipAppend); + } else { + request.headers += processHeaderValue(key, val[i]); + } + } + } else { + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); + } + } + } + module2.exports = Request; + } +}); + +// node_modules/undici/lib/dispatcher.js +var require_dispatcher = __commonJS({ + "node_modules/undici/lib/dispatcher.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events"); + var Dispatcher = class extends EventEmitter { + dispatch() { + throw new Error("not implemented"); + } + close() { + throw new Error("not implemented"); + } + destroy() { + throw new Error("not implemented"); + } + }; + module2.exports = Dispatcher; + } +}); + +// node_modules/undici/lib/dispatcher-base.js +var require_dispatcher_base = __commonJS({ + "node_modules/undici/lib/dispatcher-base.js"(exports2, module2) { + "use strict"; + var Dispatcher = require_dispatcher(); + var { + ClientDestroyedError, + ClientClosedError, + InvalidArgumentError + } = require_errors(); + var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols(); + var kDestroyed = Symbol("destroyed"); + var kClosed = Symbol("closed"); + var kOnDestroyed = Symbol("onDestroyed"); + var kOnClosed = Symbol("onClosed"); + var kInterceptedDispatch = Symbol("Intercepted Dispatch"); + var DispatcherBase = class extends Dispatcher { + constructor() { + super(); + this[kDestroyed] = false; + this[kOnDestroyed] = null; + this[kClosed] = false; + this[kOnClosed] = []; + } + get destroyed() { + return this[kDestroyed]; + } + get closed() { + return this[kClosed]; + } + get interceptors() { + return this[kInterceptors]; + } + set interceptors(newInterceptors) { + if (newInterceptors) { + for (let i = newInterceptors.length - 1; i >= 0; i--) { + const interceptor = this[kInterceptors][i]; + if (typeof interceptor !== "function") { + throw new InvalidArgumentError("interceptor must be an function"); + } + } + } + this[kInterceptors] = newInterceptors; + } + close(callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.close((err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + queueMicrotask(() => callback(new ClientDestroyedError(), null)); + return; + } + if (this[kClosed]) { + if (this[kOnClosed]) { + this[kOnClosed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + this[kClosed] = true; + this[kOnClosed].push(callback); + const onClosed = () => { + const callbacks = this[kOnClosed]; + this[kOnClosed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kClose]().then(() => this.destroy()).then(() => { + queueMicrotask(onClosed); + }); + } + destroy(err, callback) { + if (typeof err === "function") { + callback = err; + err = null; + } + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.destroy(err, (err2, data) => { + return err2 ? ( + /* istanbul ignore next: should never error */ + reject(err2) + ) : resolve(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + if (this[kOnDestroyed]) { + this[kOnDestroyed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + if (!err) { + err = new ClientDestroyedError(); + } + this[kDestroyed] = true; + this[kOnDestroyed] = this[kOnDestroyed] || []; + this[kOnDestroyed].push(callback); + const onDestroyed = () => { + const callbacks = this[kOnDestroyed]; + this[kOnDestroyed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kDestroy](err).then(() => { + queueMicrotask(onDestroyed); + }); + } + [kInterceptedDispatch](opts, handler) { + if (!this[kInterceptors] || this[kInterceptors].length === 0) { + this[kInterceptedDispatch] = this[kDispatch]; + return this[kDispatch](opts, handler); + } + let dispatch = this[kDispatch].bind(this); + for (let i = this[kInterceptors].length - 1; i >= 0; i--) { + dispatch = this[kInterceptors][i](dispatch); + } + this[kInterceptedDispatch] = dispatch; + return dispatch(opts, handler); + } + dispatch(opts, handler) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + try { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object."); + } + if (this[kDestroyed] || this[kOnDestroyed]) { + throw new ClientDestroyedError(); + } + if (this[kClosed]) { + throw new ClientClosedError(); + } + return this[kInterceptedDispatch](opts, handler); + } catch (err) { + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + handler.onError(err); + return false; + } + } + }; + module2.exports = DispatcherBase; + } +}); + +// node_modules/undici/lib/core/connect.js +var require_connect = __commonJS({ + "node_modules/undici/lib/core/connect.js"(exports2, module2) { + "use strict"; + var net = require("net"); + var assert = require("assert"); + var util = require_util(); + var { InvalidArgumentError, ConnectTimeoutError } = require_errors(); + var tls; + var SessionCache; + if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) { + SessionCache = class WeakSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + this._sessionRegistry = new global.FinalizationRegistry((key) => { + if (this._sessionCache.size < this._maxCachedSessions) { + return; + } + const ref = this._sessionCache.get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this._sessionCache.delete(key); + } + }); + } + get(sessionKey) { + const ref = this._sessionCache.get(sessionKey); + return ref ? ref.deref() : null; + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + this._sessionCache.set(sessionKey, new WeakRef(session)); + this._sessionRegistry.register(session, sessionKey); + } + }; + } else { + SessionCache = class SimpleSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + } + get(sessionKey) { + return this._sessionCache.get(sessionKey); + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + if (this._sessionCache.size >= this._maxCachedSessions) { + const { value: oldestKey } = this._sessionCache.keys().next(); + this._sessionCache.delete(oldestKey); + } + this._sessionCache.set(sessionKey, session); + } + }; + } + function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) { + if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { + throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero"); + } + const options = { path: socketPath, ...opts }; + const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions); + timeout = timeout == null ? 1e4 : timeout; + allowH2 = allowH2 != null ? allowH2 : false; + return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { + let socket; + if (protocol === "https:") { + if (!tls) { + tls = require("tls"); + } + servername = servername || options.servername || util.getServerName(host) || null; + const sessionKey = servername || hostname; + const session = sessionCache.get(sessionKey) || null; + assert(sessionKey); + socket = tls.connect({ + highWaterMark: 16384, + // TLS in node can't have bigger HWM anyway... + ...options, + servername, + session, + localAddress, + // TODO(HTTP/2): Add support for h2c + ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"], + socket: httpSocket, + // upgrade socket connection + port: port || 443, + host: hostname + }); + socket.on("session", function(session2) { + sessionCache.set(sessionKey, session2); + }); + } else { + assert(!httpSocket, "httpSocket can only be sent on TLS update"); + socket = net.connect({ + highWaterMark: 64 * 1024, + // Same as nodejs fs streams. + ...options, + localAddress, + port: port || 80, + host: hostname + }); + } + if (options.keepAlive == null || options.keepAlive) { + const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay; + socket.setKeepAlive(true, keepAliveInitialDelay); + } + const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout); + socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(null, this); + } + }).on("error", function(err) { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(err); + } + }); + return socket; + }; + } + function setupTimeout(onConnectTimeout2, timeout) { + if (!timeout) { + return () => { + }; + } + let s1 = null; + let s2 = null; + const timeoutId = setTimeout(() => { + s1 = setImmediate(() => { + if (process.platform === "win32") { + s2 = setImmediate(() => onConnectTimeout2()); + } else { + onConnectTimeout2(); + } + }); + }, timeout); + return () => { + clearTimeout(timeoutId); + clearImmediate(s1); + clearImmediate(s2); + }; + } + function onConnectTimeout(socket) { + util.destroy(socket, new ConnectTimeoutError()); + } + module2.exports = buildConnector; + } +}); + +// node_modules/undici/lib/llhttp/utils.js +var require_utils2 = __commonJS({ + "node_modules/undici/lib/llhttp/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.enumToMap = void 0; + function enumToMap(obj) { + const res = {}; + Object.keys(obj).forEach((key) => { + const value = obj[key]; + if (typeof value === "number") { + res[key] = value; + } + }); + return res; + } + exports2.enumToMap = enumToMap; + } +}); + +// node_modules/undici/lib/llhttp/constants.js +var require_constants3 = __commonJS({ + "node_modules/undici/lib/llhttp/constants.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0; + var utils_1 = require_utils2(); + var ERROR; + (function(ERROR2) { + ERROR2[ERROR2["OK"] = 0] = "OK"; + ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL"; + ERROR2[ERROR2["STRICT"] = 2] = "STRICT"; + ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED"; + ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; + ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; + ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD"; + ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL"; + ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; + ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION"; + ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; + ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; + ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; + ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS"; + ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; + ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; + ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; + ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; + ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; + ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; + ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; + ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED"; + ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; + ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; + ERROR2[ERROR2["USER"] = 24] = "USER"; + })(ERROR = exports2.ERROR || (exports2.ERROR = {})); + var TYPE; + (function(TYPE2) { + TYPE2[TYPE2["BOTH"] = 0] = "BOTH"; + TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST"; + TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE"; + })(TYPE = exports2.TYPE || (exports2.TYPE = {})); + var FLAGS; + (function(FLAGS2) { + FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; + FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; + FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; + FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED"; + FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE"; + FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; + FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY"; + FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING"; + FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; + })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {})); + var LENIENT_FLAGS; + (function(LENIENT_FLAGS2) { + LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS"; + LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; + LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; + })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {})); + var METHODS; + (function(METHODS2) { + METHODS2[METHODS2["DELETE"] = 0] = "DELETE"; + METHODS2[METHODS2["GET"] = 1] = "GET"; + METHODS2[METHODS2["HEAD"] = 2] = "HEAD"; + METHODS2[METHODS2["POST"] = 3] = "POST"; + METHODS2[METHODS2["PUT"] = 4] = "PUT"; + METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT"; + METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS"; + METHODS2[METHODS2["TRACE"] = 7] = "TRACE"; + METHODS2[METHODS2["COPY"] = 8] = "COPY"; + METHODS2[METHODS2["LOCK"] = 9] = "LOCK"; + METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL"; + METHODS2[METHODS2["MOVE"] = 11] = "MOVE"; + METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND"; + METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH"; + METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH"; + METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK"; + METHODS2[METHODS2["BIND"] = 16] = "BIND"; + METHODS2[METHODS2["REBIND"] = 17] = "REBIND"; + METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND"; + METHODS2[METHODS2["ACL"] = 19] = "ACL"; + METHODS2[METHODS2["REPORT"] = 20] = "REPORT"; + METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY"; + METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT"; + METHODS2[METHODS2["MERGE"] = 23] = "MERGE"; + METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH"; + METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY"; + METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE"; + METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; + METHODS2[METHODS2["PATCH"] = 28] = "PATCH"; + METHODS2[METHODS2["PURGE"] = 29] = "PURGE"; + METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR"; + METHODS2[METHODS2["LINK"] = 31] = "LINK"; + METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK"; + METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE"; + METHODS2[METHODS2["PRI"] = 34] = "PRI"; + METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE"; + METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE"; + METHODS2[METHODS2["SETUP"] = 37] = "SETUP"; + METHODS2[METHODS2["PLAY"] = 38] = "PLAY"; + METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE"; + METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN"; + METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER"; + METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER"; + METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT"; + METHODS2[METHODS2["RECORD"] = 44] = "RECORD"; + METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH"; + })(METHODS = exports2.METHODS || (exports2.METHODS = {})); + exports2.METHODS_HTTP = [ + METHODS.DELETE, + METHODS.GET, + METHODS.HEAD, + METHODS.POST, + METHODS.PUT, + METHODS.CONNECT, + METHODS.OPTIONS, + METHODS.TRACE, + METHODS.COPY, + METHODS.LOCK, + METHODS.MKCOL, + METHODS.MOVE, + METHODS.PROPFIND, + METHODS.PROPPATCH, + METHODS.SEARCH, + METHODS.UNLOCK, + METHODS.BIND, + METHODS.REBIND, + METHODS.UNBIND, + METHODS.ACL, + METHODS.REPORT, + METHODS.MKACTIVITY, + METHODS.CHECKOUT, + METHODS.MERGE, + METHODS["M-SEARCH"], + METHODS.NOTIFY, + METHODS.SUBSCRIBE, + METHODS.UNSUBSCRIBE, + METHODS.PATCH, + METHODS.PURGE, + METHODS.MKCALENDAR, + METHODS.LINK, + METHODS.UNLINK, + METHODS.PRI, + // TODO(indutny): should we allow it with HTTP? + METHODS.SOURCE + ]; + exports2.METHODS_ICE = [ + METHODS.SOURCE + ]; + exports2.METHODS_RTSP = [ + METHODS.OPTIONS, + METHODS.DESCRIBE, + METHODS.ANNOUNCE, + METHODS.SETUP, + METHODS.PLAY, + METHODS.PAUSE, + METHODS.TEARDOWN, + METHODS.GET_PARAMETER, + METHODS.SET_PARAMETER, + METHODS.REDIRECT, + METHODS.RECORD, + METHODS.FLUSH, + // For AirPlay + METHODS.GET, + METHODS.POST + ]; + exports2.METHOD_MAP = utils_1.enumToMap(METHODS); + exports2.H_METHOD_MAP = {}; + Object.keys(exports2.METHOD_MAP).forEach((key) => { + if (/^H/.test(key)) { + exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key]; + } + }); + var FINISH; + (function(FINISH2) { + FINISH2[FINISH2["SAFE"] = 0] = "SAFE"; + FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; + FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE"; + })(FINISH = exports2.FINISH || (exports2.FINISH = {})); + exports2.ALPHA = []; + for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) { + exports2.ALPHA.push(String.fromCharCode(i)); + exports2.ALPHA.push(String.fromCharCode(i + 32)); + } + exports2.NUM_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9 + }; + exports2.HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15 + }; + exports2.NUM = [ + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9" + ]; + exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM); + exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"]; + exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]); + exports2.STRICT_URL_CHAR = [ + "!", + '"', + "$", + "%", + "&", + "'", + "(", + ")", + "*", + "+", + ",", + "-", + ".", + "/", + ":", + ";", + "<", + "=", + ">", + "@", + "[", + "\\", + "]", + "^", + "_", + "`", + "{", + "|", + "}", + "~" + ].concat(exports2.ALPHANUM); + exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]); + for (let i = 128; i <= 255; i++) { + exports2.URL_CHAR.push(i); + } + exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]); + exports2.STRICT_TOKEN = [ + "!", + "#", + "$", + "%", + "&", + "'", + "*", + "+", + "-", + ".", + "^", + "_", + "`", + "|", + "~" + ].concat(exports2.ALPHANUM); + exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]); + exports2.HEADER_CHARS = [" "]; + for (let i = 32; i <= 255; i++) { + if (i !== 127) { + exports2.HEADER_CHARS.push(i); + } + } + exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44); + exports2.MAJOR = exports2.NUM_MAP; + exports2.MINOR = exports2.MAJOR; + var HEADER_STATE; + (function(HEADER_STATE2) { + HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL"; + HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION"; + HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; + HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; + })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {})); + exports2.SPECIAL_HEADERS = { + "connection": HEADER_STATE.CONNECTION, + "content-length": HEADER_STATE.CONTENT_LENGTH, + "proxy-connection": HEADER_STATE.CONNECTION, + "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING, + "upgrade": HEADER_STATE.UPGRADE + }; + } +}); + +// node_modules/undici/lib/handler/RedirectHandler.js +var require_RedirectHandler = __commonJS({ + "node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) { + "use strict"; + var util = require_util(); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { InvalidArgumentError } = require_errors(); + var EE = require("events"); + var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; + var kBody = Symbol("body"); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + var RedirectHandler = class { + constructor(dispatch, maxRedirections, opts, handler) { + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + util.validateHandler(handler, opts.method, opts.upgrade); + this.dispatch = dispatch; + this.location = null; + this.abort = null; + this.opts = { ...opts, maxRedirections: 0 }; + this.maxRedirections = maxRedirections; + this.handler = handler; + this.history = []; + if (util.isStream(this.opts.body)) { + if (util.bodyLength(this.opts.body) === 0) { + this.opts.body.on("data", function() { + assert(false); + }); + } + if (typeof this.opts.body.readableDidRead !== "boolean") { + this.opts.body[kBodyUsed] = false; + EE.prototype.on.call(this.opts.body, "data", function() { + this[kBodyUsed] = true; + }); + } + } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } + } + onConnect(abort) { + this.abort = abort; + this.handler.onConnect(abort, { history: this.history }); + } + onUpgrade(statusCode, headers, socket) { + this.handler.onUpgrade(statusCode, headers, socket); + } + onError(error) { + this.handler.onError(error); + } + onHeaders(statusCode, headers, resume, statusText) { + this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers); + if (this.opts.origin) { + this.history.push(new URL(this.opts.path, this.opts.origin)); + } + if (!this.location) { + return this.handler.onHeaders(statusCode, headers, resume, statusText); + } + const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); + const path3 = search ? `${pathname}${search}` : pathname; + this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); + this.opts.path = path3; + this.opts.origin = origin; + this.opts.maxRedirections = 0; + this.opts.query = null; + if (statusCode === 303 && this.opts.method !== "HEAD") { + this.opts.method = "GET"; + this.opts.body = null; + } + } + onData(chunk) { + if (this.location) { + } else { + return this.handler.onData(chunk); + } + } + onComplete(trailers) { + if (this.location) { + this.location = null; + this.abort = null; + this.dispatch(this.opts, this); + } else { + this.handler.onComplete(trailers); + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) { + this.handler.onBodySent(chunk); + } + } + }; + function parseLocation(statusCode, headers) { + if (redirectableStatusCodes.indexOf(statusCode) === -1) { + return null; + } + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toString().toLowerCase() === "location") { + return headers[i + 1]; + } + } + } + function shouldRemoveHeader(header, removeContent, unknownOrigin) { + if (header.length === 4) { + return util.headerNameToString(header) === "host"; + } + if (removeContent && util.headerNameToString(header).startsWith("content-")) { + return true; + } + if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { + const name = util.headerNameToString(header); + return name === "authorization" || name === "cookie" || name === "proxy-authorization"; + } + return false; + } + function cleanRequestHeaders(headers, removeContent, unknownOrigin) { + const ret = []; + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) { + ret.push(headers[i], headers[i + 1]); + } + } + } else if (headers && typeof headers === "object") { + for (const key of Object.keys(headers)) { + if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) { + ret.push(key, headers[key]); + } + } + } else { + assert(headers == null, "headers must be an object or an array"); + } + return ret; + } + module2.exports = RedirectHandler; + } +}); + +// node_modules/undici/lib/interceptor/redirectInterceptor.js +var require_redirectInterceptor = __commonJS({ + "node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) { + "use strict"; + var RedirectHandler = require_RedirectHandler(); + function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { maxRedirections = defaultMaxRedirections } = opts; + if (!maxRedirections) { + return dispatch(opts, handler); + } + const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler); + opts = { ...opts, maxRedirections: 0 }; + return dispatch(opts, redirectHandler); + }; + }; + } + module2.exports = createRedirectInterceptor; + } +}); + +// node_modules/undici/lib/llhttp/llhttp-wasm.js +var require_llhttp_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { + module2.exports = "AGFzbQEAAAABMAhgAX8Bf2ADf39/AX9gBH9/f38Bf2AAAGADf39/AGABfwBgAn9/AGAGf39/f39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQACA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAA0ZFAwMEAAAFAAAAAAAABQEFAAUFBQAABgAAAAAGBgYGAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAAABAQcAAAUFAwABBAUBcAESEgUDAQACBggBfwFBgNQECwfRBSIGbWVtb3J5AgALX2luaXRpYWxpemUACRlfX2luZGlyZWN0X2Z1bmN0aW9uX3RhYmxlAQALbGxodHRwX2luaXQAChhsbGh0dHBfc2hvdWxkX2tlZXBfYWxpdmUAQQxsbGh0dHBfYWxsb2MADAZtYWxsb2MARgtsbGh0dHBfZnJlZQANBGZyZWUASA9sbGh0dHBfZ2V0X3R5cGUADhVsbGh0dHBfZ2V0X2h0dHBfbWFqb3IADxVsbGh0dHBfZ2V0X2h0dHBfbWlub3IAEBFsbGh0dHBfZ2V0X21ldGhvZAARFmxsaHR0cF9nZXRfc3RhdHVzX2NvZGUAEhJsbGh0dHBfZ2V0X3VwZ3JhZGUAEwxsbGh0dHBfcmVzZXQAFA5sbGh0dHBfZXhlY3V0ZQAVFGxsaHR0cF9zZXR0aW5nc19pbml0ABYNbGxodHRwX2ZpbmlzaAAXDGxsaHR0cF9wYXVzZQAYDWxsaHR0cF9yZXN1bWUAGRtsbGh0dHBfcmVzdW1lX2FmdGVyX3VwZ3JhZGUAGhBsbGh0dHBfZ2V0X2Vycm5vABsXbGxodHRwX2dldF9lcnJvcl9yZWFzb24AHBdsbGh0dHBfc2V0X2Vycm9yX3JlYXNvbgAdFGxsaHR0cF9nZXRfZXJyb3JfcG9zAB4RbGxodHRwX2Vycm5vX25hbWUAHxJsbGh0dHBfbWV0aG9kX25hbWUAIBJsbGh0dHBfc3RhdHVzX25hbWUAIRpsbGh0dHBfc2V0X2xlbmllbnRfaGVhZGVycwAiIWxsaHR0cF9zZXRfbGVuaWVudF9jaHVua2VkX2xlbmd0aAAjHWxsaHR0cF9zZXRfbGVuaWVudF9rZWVwX2FsaXZlACQkbGxodHRwX3NldF9sZW5pZW50X3RyYW5zZmVyX2VuY29kaW5nACUYbGxodHRwX21lc3NhZ2VfbmVlZHNfZW9mAD8JFwEAQQELEQECAwQFCwYHNTk3MS8tJyspCsLgAkUCAAsIABCIgICAAAsZACAAEMKAgIAAGiAAIAI2AjggACABOgAoCxwAIAAgAC8BMiAALQAuIAAQwYCAgAAQgICAgAALKgEBf0HAABDGgICAACIBEMKAgIAAGiABQYCIgIAANgI4IAEgADoAKCABCwoAIAAQyICAgAALBwAgAC0AKAsHACAALQAqCwcAIAAtACsLBwAgAC0AKQsHACAALwEyCwcAIAAtAC4LRQEEfyAAKAIYIQEgAC0ALSECIAAtACghAyAAKAI4IQQgABDCgICAABogACAENgI4IAAgAzoAKCAAIAI6AC0gACABNgIYCxEAIAAgASABIAJqEMOAgIAACxAAIABBAEHcABDMgICAABoLZwEBf0EAIQECQCAAKAIMDQACQAJAAkACQCAALQAvDgMBAAMCCyAAKAI4IgFFDQAgASgCLCIBRQ0AIAAgARGAgICAAAAiAQ0DC0EADwsQyoCAgAAACyAAQcOWgIAANgIQQQ4hAQsgAQseAAJAIAAoAgwNACAAQdGbgIAANgIQIABBFTYCDAsLFgACQCAAKAIMQRVHDQAgAEEANgIMCwsWAAJAIAAoAgxBFkcNACAAQQA2AgwLCwcAIAAoAgwLBwAgACgCEAsJACAAIAE2AhALBwAgACgCFAsiAAJAIABBJEkNABDKgICAAAALIABBAnRBoLOAgABqKAIACyIAAkAgAEEuSQ0AEMqAgIAAAAsgAEECdEGwtICAAGooAgAL7gsBAX9B66iAgAAhAQJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABBnH9qDvQDY2IAAWFhYWFhYQIDBAVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhBgcICQoLDA0OD2FhYWFhEGFhYWFhYWFhYWFhEWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRITFBUWFxgZGhthYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2YTc4OTphYWFhYWFhYTthYWE8YWFhYT0+P2FhYWFhYWFhQGFhQWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYUJDREVGR0hJSktMTU5PUFFSU2FhYWFhYWFhVFVWV1hZWlthXF1hYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFeYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhX2BhC0Hhp4CAAA8LQaShgIAADwtBy6yAgAAPC0H+sYCAAA8LQcCkgIAADwtBq6SAgAAPC0GNqICAAA8LQeKmgIAADwtBgLCAgAAPC0G5r4CAAA8LQdekgIAADwtB75+AgAAPC0Hhn4CAAA8LQfqfgIAADwtB8qCAgAAPC0Gor4CAAA8LQa6ygIAADwtBiLCAgAAPC0Hsp4CAAA8LQYKigIAADwtBjp2AgAAPC0HQroCAAA8LQcqjgIAADwtBxbKAgAAPC0HfnICAAA8LQdKcgIAADwtBxKCAgAAPC0HXoICAAA8LQaKfgIAADwtB7a6AgAAPC0GrsICAAA8LQdSlgIAADwtBzK6AgAAPC0H6roCAAA8LQfyrgIAADwtB0rCAgAAPC0HxnYCAAA8LQbuggIAADwtB96uAgAAPC0GQsYCAAA8LQdexgIAADwtBoq2AgAAPC0HUp4CAAA8LQeCrgIAADwtBn6yAgAAPC0HrsYCAAA8LQdWfgIAADwtByrGAgAAPC0HepYCAAA8LQdSegIAADwtB9JyAgAAPC0GnsoCAAA8LQbGdgIAADwtBoJ2AgAAPC0G5sYCAAA8LQbywgIAADwtBkqGAgAAPC0GzpoCAAA8LQemsgIAADwtBrJ6AgAAPC0HUq4CAAA8LQfemgIAADwtBgKaAgAAPC0GwoYCAAA8LQf6egIAADwtBjaOAgAAPC0GJrYCAAA8LQfeigIAADwtBoLGAgAAPC0Gun4CAAA8LQcalgIAADwtB6J6AgAAPC0GTooCAAA8LQcKvgIAADwtBw52AgAAPC0GLrICAAA8LQeGdgIAADwtBja+AgAAPC0HqoYCAAA8LQbStgIAADwtB0q+AgAAPC0HfsoCAAA8LQdKygIAADwtB8LCAgAAPC0GpooCAAA8LQfmjgIAADwtBmZ6AgAAPC0G1rICAAA8LQZuwgIAADwtBkrKAgAAPC0G2q4CAAA8LQcKigIAADwtB+LKAgAAPC0GepYCAAA8LQdCigIAADwtBup6AgAAPC0GBnoCAAA8LEMqAgIAAAAtB1qGAgAAhAQsgAQsWACAAIAAtAC1B/gFxIAFBAEdyOgAtCxkAIAAgAC0ALUH9AXEgAUEAR0EBdHI6AC0LGQAgACAALQAtQfsBcSABQQBHQQJ0cjoALQsZACAAIAAtAC1B9wFxIAFBAEdBA3RyOgAtCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAgAiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCBCIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQcaRgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIwIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAggiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2ioCAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCNCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIMIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZqAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAjgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCECIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZWQgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAI8IgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAhQiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEGqm4CAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCQCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIYIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABB7ZOAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCJCIERQ0AIAAgBBGAgICAAAAhAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIsIgRFDQAgACAEEYCAgIAAACEDCyADC0kBAn9BACEDAkAgACgCOCIERQ0AIAQoAigiBEUNACAAIAEgAiABayAEEYGAgIAAACIDQX9HDQAgAEH2iICAADYCEEEYIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCUCIERQ0AIAAgBBGAgICAAAAhAwsgAwtJAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAIcIgRFDQAgACABIAIgAWsgBBGBgICAAAAiA0F/Rw0AIABBwpmAgAA2AhBBGCEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAkgiBEUNACAAIAQRgICAgAAAIQMLIAMLSQECf0EAIQMCQCAAKAI4IgRFDQAgBCgCICIERQ0AIAAgASACIAFrIAQRgYCAgAAAIgNBf0cNACAAQZSUgIAANgIQQRghAwsgAwsuAQJ/QQAhAwJAIAAoAjgiBEUNACAEKAJMIgRFDQAgACAEEYCAgIAAACEDCyADCy4BAn9BACEDAkAgACgCOCIERQ0AIAQoAlQiBEUNACAAIAQRgICAgAAAIQMLIAMLLgECf0EAIQMCQCAAKAI4IgRFDQAgBCgCWCIERQ0AIAAgBBGAgICAAAAhAwsgAwtFAQF/AkACQCAALwEwQRRxQRRHDQBBASEDIAAtAChBAUYNASAALwEyQeUARiEDDAELIAAtAClBBUYhAwsgACADOgAuQQAL/gEBA39BASEDAkAgAC8BMCIEQQhxDQAgACkDIEIAUiEDCwJAAkAgAC0ALkUNAEEBIQUgAC0AKUEFRg0BQQEhBSAEQcAAcUUgA3FBAUcNAQtBACEFIARBwABxDQBBAiEFIARB//8DcSIDQQhxDQACQCADQYAEcUUNAAJAIAAtAChBAUcNACAALQAtQQpxDQBBBQ8LQQQPCwJAIANBIHENAAJAIAAtAChBAUYNACAALwEyQf//A3EiAEGcf2pB5ABJDQAgAEHMAUYNACAAQbACRg0AQQQhBSAEQShxRQ0CIANBiARxQYAERg0CC0EADwtBAEEDIAApAyBQGyEFCyAFC2IBAn9BACEBAkAgAC0AKEEBRg0AIAAvATJB//8DcSICQZx/akHkAEkNACACQcwBRg0AIAJBsAJGDQAgAC8BMCIAQcAAcQ0AQQEhASAAQYgEcUGABEYNACAAQShxRSEBCyABC6cBAQN/AkACQAJAIAAtACpFDQAgAC0AK0UNAEEAIQMgAC8BMCIEQQJxRQ0BDAILQQAhAyAALwEwIgRBAXFFDQELQQEhAyAALQAoQQFGDQAgAC8BMkH//wNxIgVBnH9qQeQASQ0AIAVBzAFGDQAgBUGwAkYNACAEQcAAcQ0AQQAhAyAEQYgEcUGABEYNACAEQShxQQBHIQMLIABBADsBMCAAQQA6AC8gAwuZAQECfwJAAkACQCAALQAqRQ0AIAAtACtFDQBBACEBIAAvATAiAkECcUUNAQwCC0EAIQEgAC8BMCICQQFxRQ0BC0EBIQEgAC0AKEEBRg0AIAAvATJB//8DcSIAQZx/akHkAEkNACAAQcwBRg0AIABBsAJGDQAgAkHAAHENAEEAIQEgAkGIBHFBgARGDQAgAkEocUEARyEBCyABC1kAIABBGGpCADcDACAAQgA3AwAgAEE4akIANwMAIABBMGpCADcDACAAQShqQgA3AwAgAEEgakIANwMAIABBEGpCADcDACAAQQhqQgA3AwAgAEHdATYCHEEAC3sBAX8CQCAAKAIMIgMNAAJAIAAoAgRFDQAgACABNgIECwJAIAAgASACEMSAgIAAIgMNACAAKAIMDwsgACADNgIcQQAhAyAAKAIEIgFFDQAgACABIAIgACgCCBGBgICAAAAiAUUNACAAIAI2AhQgACABNgIMIAEhAwsgAwvk8wEDDn8DfgR/I4CAgIAAQRBrIgMkgICAgAAgASEEIAEhBSABIQYgASEHIAEhCCABIQkgASEKIAEhCyABIQwgASENIAEhDiABIQ8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgACgCHCIQQX9qDt0B2gEB2QECAwQFBgcICQoLDA0O2AEPENcBERLWARMUFRYXGBkaG+AB3wEcHR7VAR8gISIjJCXUASYnKCkqKyzTAdIBLS7RAdABLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVG2wFHSElKzwHOAUvNAUzMAU1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1+f4ABgQGCAYMBhAGFAYYBhwGIAYkBigGLAYwBjQGOAY8BkAGRAZIBkwGUAZUBlgGXAZgBmQGaAZsBnAGdAZ4BnwGgAaEBogGjAaQBpQGmAacBqAGpAaoBqwGsAa0BrgGvAbABsQGyAbMBtAG1AbYBtwHLAcoBuAHJAbkByAG6AbsBvAG9Ab4BvwHAAcEBwgHDAcQBxQHGAQDcAQtBACEQDMYBC0EOIRAMxQELQQ0hEAzEAQtBDyEQDMMBC0EQIRAMwgELQRMhEAzBAQtBFCEQDMABC0EVIRAMvwELQRYhEAy+AQtBFyEQDL0BC0EYIRAMvAELQRkhEAy7AQtBGiEQDLoBC0EbIRAMuQELQRwhEAy4AQtBCCEQDLcBC0EdIRAMtgELQSAhEAy1AQtBHyEQDLQBC0EHIRAMswELQSEhEAyyAQtBIiEQDLEBC0EeIRAMsAELQSMhEAyvAQtBEiEQDK4BC0ERIRAMrQELQSQhEAysAQtBJSEQDKsBC0EmIRAMqgELQSchEAypAQtBwwEhEAyoAQtBKSEQDKcBC0ErIRAMpgELQSwhEAylAQtBLSEQDKQBC0EuIRAMowELQS8hEAyiAQtBxAEhEAyhAQtBMCEQDKABC0E0IRAMnwELQQwhEAyeAQtBMSEQDJ0BC0EyIRAMnAELQTMhEAybAQtBOSEQDJoBC0E1IRAMmQELQcUBIRAMmAELQQshEAyXAQtBOiEQDJYBC0E2IRAMlQELQQohEAyUAQtBNyEQDJMBC0E4IRAMkgELQTwhEAyRAQtBOyEQDJABC0E9IRAMjwELQQkhEAyOAQtBKCEQDI0BC0E+IRAMjAELQT8hEAyLAQtBwAAhEAyKAQtBwQAhEAyJAQtBwgAhEAyIAQtBwwAhEAyHAQtBxAAhEAyGAQtBxQAhEAyFAQtBxgAhEAyEAQtBKiEQDIMBC0HHACEQDIIBC0HIACEQDIEBC0HJACEQDIABC0HKACEQDH8LQcsAIRAMfgtBzQAhEAx9C0HMACEQDHwLQc4AIRAMewtBzwAhEAx6C0HQACEQDHkLQdEAIRAMeAtB0gAhEAx3C0HTACEQDHYLQdQAIRAMdQtB1gAhEAx0C0HVACEQDHMLQQYhEAxyC0HXACEQDHELQQUhEAxwC0HYACEQDG8LQQQhEAxuC0HZACEQDG0LQdoAIRAMbAtB2wAhEAxrC0HcACEQDGoLQQMhEAxpC0HdACEQDGgLQd4AIRAMZwtB3wAhEAxmC0HhACEQDGULQeAAIRAMZAtB4gAhEAxjC0HjACEQDGILQQIhEAxhC0HkACEQDGALQeUAIRAMXwtB5gAhEAxeC0HnACEQDF0LQegAIRAMXAtB6QAhEAxbC0HqACEQDFoLQesAIRAMWQtB7AAhEAxYC0HtACEQDFcLQe4AIRAMVgtB7wAhEAxVC0HwACEQDFQLQfEAIRAMUwtB8gAhEAxSC0HzACEQDFELQfQAIRAMUAtB9QAhEAxPC0H2ACEQDE4LQfcAIRAMTQtB+AAhEAxMC0H5ACEQDEsLQfoAIRAMSgtB+wAhEAxJC0H8ACEQDEgLQf0AIRAMRwtB/gAhEAxGC0H/ACEQDEULQYABIRAMRAtBgQEhEAxDC0GCASEQDEILQYMBIRAMQQtBhAEhEAxAC0GFASEQDD8LQYYBIRAMPgtBhwEhEAw9C0GIASEQDDwLQYkBIRAMOwtBigEhEAw6C0GLASEQDDkLQYwBIRAMOAtBjQEhEAw3C0GOASEQDDYLQY8BIRAMNQtBkAEhEAw0C0GRASEQDDMLQZIBIRAMMgtBkwEhEAwxC0GUASEQDDALQZUBIRAMLwtBlgEhEAwuC0GXASEQDC0LQZgBIRAMLAtBmQEhEAwrC0GaASEQDCoLQZsBIRAMKQtBnAEhEAwoC0GdASEQDCcLQZ4BIRAMJgtBnwEhEAwlC0GgASEQDCQLQaEBIRAMIwtBogEhEAwiC0GjASEQDCELQaQBIRAMIAtBpQEhEAwfC0GmASEQDB4LQacBIRAMHQtBqAEhEAwcC0GpASEQDBsLQaoBIRAMGgtBqwEhEAwZC0GsASEQDBgLQa0BIRAMFwtBrgEhEAwWC0EBIRAMFQtBrwEhEAwUC0GwASEQDBMLQbEBIRAMEgtBswEhEAwRC0GyASEQDBALQbQBIRAMDwtBtQEhEAwOC0G2ASEQDA0LQbcBIRAMDAtBuAEhEAwLC0G5ASEQDAoLQboBIRAMCQtBuwEhEAwIC0HGASEQDAcLQbwBIRAMBgtBvQEhEAwFC0G+ASEQDAQLQb8BIRAMAwtBwAEhEAwCC0HCASEQDAELQcEBIRALA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAQDscBAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxweHyAhIyUoP0BBREVGR0hJSktMTU9QUVJT3gNXWVtcXWBiZWZnaGlqa2xtb3BxcnN0dXZ3eHl6e3x9foABggGFAYYBhwGJAYsBjAGNAY4BjwGQAZEBlAGVAZYBlwGYAZkBmgGbAZwBnQGeAZ8BoAGhAaIBowGkAaUBpgGnAagBqQGqAasBrAGtAa4BrwGwAbEBsgGzAbQBtQG2AbcBuAG5AboBuwG8Ab0BvgG/AcABwQHCAcMBxAHFAcYBxwHIAckBygHLAcwBzQHOAc8B0AHRAdIB0wHUAdUB1gHXAdgB2QHaAdsB3AHdAd4B4AHhAeIB4wHkAeUB5gHnAegB6QHqAesB7AHtAe4B7wHwAfEB8gHzAZkCpAKwAv4C/gILIAEiBCACRw3zAUHdASEQDP8DCyABIhAgAkcN3QFBwwEhEAz+AwsgASIBIAJHDZABQfcAIRAM/QMLIAEiASACRw2GAUHvACEQDPwDCyABIgEgAkcNf0HqACEQDPsDCyABIgEgAkcNe0HoACEQDPoDCyABIgEgAkcNeEHmACEQDPkDCyABIgEgAkcNGkEYIRAM+AMLIAEiASACRw0UQRIhEAz3AwsgASIBIAJHDVlBxQAhEAz2AwsgASIBIAJHDUpBPyEQDPUDCyABIgEgAkcNSEE8IRAM9AMLIAEiASACRw1BQTEhEAzzAwsgAC0ALkEBRg3rAwyHAgsgACABIgEgAhDAgICAAEEBRw3mASAAQgA3AyAM5wELIAAgASIBIAIQtICAgAAiEA3nASABIQEM9QILAkAgASIBIAJHDQBBBiEQDPADCyAAIAFBAWoiASACELuAgIAAIhAN6AEgASEBDDELIABCADcDIEESIRAM1QMLIAEiECACRw0rQR0hEAztAwsCQCABIgEgAkYNACABQQFqIQFBECEQDNQDC0EHIRAM7AMLIABCACAAKQMgIhEgAiABIhBrrSISfSITIBMgEVYbNwMgIBEgElYiFEUN5QFBCCEQDOsDCwJAIAEiASACRg0AIABBiYCAgAA2AgggACABNgIEIAEhAUEUIRAM0gMLQQkhEAzqAwsgASEBIAApAyBQDeQBIAEhAQzyAgsCQCABIgEgAkcNAEELIRAM6QMLIAAgAUEBaiIBIAIQtoCAgAAiEA3lASABIQEM8gILIAAgASIBIAIQuICAgAAiEA3lASABIQEM8gILIAAgASIBIAIQuICAgAAiEA3mASABIQEMDQsgACABIgEgAhC6gICAACIQDecBIAEhAQzwAgsCQCABIgEgAkcNAEEPIRAM5QMLIAEtAAAiEEE7Rg0IIBBBDUcN6AEgAUEBaiEBDO8CCyAAIAEiASACELqAgIAAIhAN6AEgASEBDPICCwNAAkAgAS0AAEHwtYCAAGotAAAiEEEBRg0AIBBBAkcN6wEgACgCBCEQIABBADYCBCAAIBAgAUEBaiIBELmAgIAAIhAN6gEgASEBDPQCCyABQQFqIgEgAkcNAAtBEiEQDOIDCyAAIAEiASACELqAgIAAIhAN6QEgASEBDAoLIAEiASACRw0GQRshEAzgAwsCQCABIgEgAkcNAEEWIRAM4AMLIABBioCAgAA2AgggACABNgIEIAAgASACELiAgIAAIhAN6gEgASEBQSAhEAzGAwsCQCABIgEgAkYNAANAAkAgAS0AAEHwt4CAAGotAAAiEEECRg0AAkAgEEF/ag4E5QHsAQDrAewBCyABQQFqIQFBCCEQDMgDCyABQQFqIgEgAkcNAAtBFSEQDN8DC0EVIRAM3gMLA0ACQCABLQAAQfC5gIAAai0AACIQQQJGDQAgEEF/ag4E3gHsAeAB6wHsAQsgAUEBaiIBIAJHDQALQRghEAzdAwsCQCABIgEgAkYNACAAQYuAgIAANgIIIAAgATYCBCABIQFBByEQDMQDC0EZIRAM3AMLIAFBAWohAQwCCwJAIAEiFCACRw0AQRohEAzbAwsgFCEBAkAgFC0AAEFzag4U3QLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gLuAu4C7gIA7gILQQAhECAAQQA2AhwgAEGvi4CAADYCECAAQQI2AgwgACAUQQFqNgIUDNoDCwJAIAEtAAAiEEE7Rg0AIBBBDUcN6AEgAUEBaiEBDOUCCyABQQFqIQELQSIhEAy/AwsCQCABIhAgAkcNAEEcIRAM2AMLQgAhESAQIQEgEC0AAEFQag435wHmAQECAwQFBgcIAAAAAAAAAAkKCwwNDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADxAREhMUAAtBHiEQDL0DC0ICIREM5QELQgMhEQzkAQtCBCERDOMBC0IFIREM4gELQgYhEQzhAQtCByERDOABC0IIIREM3wELQgkhEQzeAQtCCiERDN0BC0ILIREM3AELQgwhEQzbAQtCDSERDNoBC0IOIREM2QELQg8hEQzYAQtCCiERDNcBC0ILIREM1gELQgwhEQzVAQtCDSERDNQBC0IOIREM0wELQg8hEQzSAQtCACERAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAQLQAAQVBqDjflAeQBAAECAwQFBgfmAeYB5gHmAeYB5gHmAQgJCgsMDeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gHmAeYB5gEODxAREhPmAQtCAiERDOQBC0IDIREM4wELQgQhEQziAQtCBSERDOEBC0IGIREM4AELQgchEQzfAQtCCCERDN4BC0IJIREM3QELQgohEQzcAQtCCyERDNsBC0IMIREM2gELQg0hEQzZAQtCDiERDNgBC0IPIREM1wELQgohEQzWAQtCCyERDNUBC0IMIREM1AELQg0hEQzTAQtCDiERDNIBC0IPIREM0QELIABCACAAKQMgIhEgAiABIhBrrSISfSITIBMgEVYbNwMgIBEgElYiFEUN0gFBHyEQDMADCwJAIAEiASACRg0AIABBiYCAgAA2AgggACABNgIEIAEhAUEkIRAMpwMLQSAhEAy/AwsgACABIhAgAhC+gICAAEF/ag4FtgEAxQIB0QHSAQtBESEQDKQDCyAAQQE6AC8gECEBDLsDCyABIgEgAkcN0gFBJCEQDLsDCyABIg0gAkcNHkHGACEQDLoDCyAAIAEiASACELKAgIAAIhAN1AEgASEBDLUBCyABIhAgAkcNJkHQACEQDLgDCwJAIAEiASACRw0AQSghEAy4AwsgAEEANgIEIABBjICAgAA2AgggACABIAEQsYCAgAAiEA3TASABIQEM2AELAkAgASIQIAJHDQBBKSEQDLcDCyAQLQAAIgFBIEYNFCABQQlHDdMBIBBBAWohAQwVCwJAIAEiASACRg0AIAFBAWohAQwXC0EqIRAMtQMLAkAgASIQIAJHDQBBKyEQDLUDCwJAIBAtAAAiAUEJRg0AIAFBIEcN1QELIAAtACxBCEYN0wEgECEBDJEDCwJAIAEiASACRw0AQSwhEAy0AwsgAS0AAEEKRw3VASABQQFqIQEMyQILIAEiDiACRw3VAUEvIRAMsgMLA0ACQCABLQAAIhBBIEYNAAJAIBBBdmoOBADcAdwBANoBCyABIQEM4AELIAFBAWoiASACRw0AC0ExIRAMsQMLQTIhECABIhQgAkYNsAMgAiAUayAAKAIAIgFqIRUgFCABa0EDaiEWAkADQCAULQAAIhdBIHIgFyAXQb9/akH/AXFBGkkbQf8BcSABQfC7gIAAai0AAEcNAQJAIAFBA0cNAEEGIQEMlgMLIAFBAWohASAUQQFqIhQgAkcNAAsgACAVNgIADLEDCyAAQQA2AgAgFCEBDNkBC0EzIRAgASIUIAJGDa8DIAIgFGsgACgCACIBaiEVIBQgAWtBCGohFgJAA0AgFC0AACIXQSByIBcgF0G/f2pB/wFxQRpJG0H/AXEgAUH0u4CAAGotAABHDQECQCABQQhHDQBBBSEBDJUDCyABQQFqIQEgFEEBaiIUIAJHDQALIAAgFTYCAAywAwsgAEEANgIAIBQhAQzYAQtBNCEQIAEiFCACRg2uAyACIBRrIAAoAgAiAWohFSAUIAFrQQVqIRYCQANAIBQtAAAiF0EgciAXIBdBv39qQf8BcUEaSRtB/wFxIAFB0MKAgABqLQAARw0BAkAgAUEFRw0AQQchAQyUAwsgAUEBaiEBIBRBAWoiFCACRw0ACyAAIBU2AgAMrwMLIABBADYCACAUIQEM1wELAkAgASIBIAJGDQADQAJAIAEtAABBgL6AgABqLQAAIhBBAUYNACAQQQJGDQogASEBDN0BCyABQQFqIgEgAkcNAAtBMCEQDK4DC0EwIRAMrQMLAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgRg0AIBBBdmoOBNkB2gHaAdkB2gELIAFBAWoiASACRw0AC0E4IRAMrQMLQTghEAysAwsDQAJAIAEtAAAiEEEgRg0AIBBBCUcNAwsgAUEBaiIBIAJHDQALQTwhEAyrAwsDQAJAIAEtAAAiEEEgRg0AAkACQCAQQXZqDgTaAQEB2gEACyAQQSxGDdsBCyABIQEMBAsgAUEBaiIBIAJHDQALQT8hEAyqAwsgASEBDNsBC0HAACEQIAEiFCACRg2oAyACIBRrIAAoAgAiAWohFiAUIAFrQQZqIRcCQANAIBQtAABBIHIgAUGAwICAAGotAABHDQEgAUEGRg2OAyABQQFqIQEgFEEBaiIUIAJHDQALIAAgFjYCAAypAwsgAEEANgIAIBQhAQtBNiEQDI4DCwJAIAEiDyACRw0AQcEAIRAMpwMLIABBjICAgAA2AgggACAPNgIEIA8hASAALQAsQX9qDgTNAdUB1wHZAYcDCyABQQFqIQEMzAELAkAgASIBIAJGDQADQAJAIAEtAAAiEEEgciAQIBBBv39qQf8BcUEaSRtB/wFxIhBBCUYNACAQQSBGDQACQAJAAkACQCAQQZ1/ag4TAAMDAwMDAwMBAwMDAwMDAwMDAgMLIAFBAWohAUExIRAMkQMLIAFBAWohAUEyIRAMkAMLIAFBAWohAUEzIRAMjwMLIAEhAQzQAQsgAUEBaiIBIAJHDQALQTUhEAylAwtBNSEQDKQDCwJAIAEiASACRg0AA0ACQCABLQAAQYC8gIAAai0AAEEBRg0AIAEhAQzTAQsgAUEBaiIBIAJHDQALQT0hEAykAwtBPSEQDKMDCyAAIAEiASACELCAgIAAIhAN1gEgASEBDAELIBBBAWohAQtBPCEQDIcDCwJAIAEiASACRw0AQcIAIRAMoAMLAkADQAJAIAEtAABBd2oOGAAC/gL+AoQD/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4C/gL+Av4CAP4CCyABQQFqIgEgAkcNAAtBwgAhEAygAwsgAUEBaiEBIAAtAC1BAXFFDb0BIAEhAQtBLCEQDIUDCyABIgEgAkcN0wFBxAAhEAydAwsDQAJAIAEtAABBkMCAgABqLQAAQQFGDQAgASEBDLcCCyABQQFqIgEgAkcNAAtBxQAhEAycAwsgDS0AACIQQSBGDbMBIBBBOkcNgQMgACgCBCEBIABBADYCBCAAIAEgDRCvgICAACIBDdABIA1BAWohAQyzAgtBxwAhECABIg0gAkYNmgMgAiANayAAKAIAIgFqIRYgDSABa0EFaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUGQwoCAAGotAABHDYADIAFBBUYN9AIgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMmgMLQcgAIRAgASINIAJGDZkDIAIgDWsgACgCACIBaiEWIA0gAWtBCWohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFBlsKAgABqLQAARw3/AgJAIAFBCUcNAEECIQEM9QILIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJkDCwJAIAEiDSACRw0AQckAIRAMmQMLAkACQCANLQAAIgFBIHIgASABQb9/akH/AXFBGkkbQf8BcUGSf2oOBwCAA4ADgAOAA4ADAYADCyANQQFqIQFBPiEQDIADCyANQQFqIQFBPyEQDP8CC0HKACEQIAEiDSACRg2XAyACIA1rIAAoAgAiAWohFiANIAFrQQFqIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQaDCgIAAai0AAEcN/QIgAUEBRg3wAiABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyXAwtBywAhECABIg0gAkYNlgMgAiANayAAKAIAIgFqIRYgDSABa0EOaiEXA0AgDS0AACIUQSByIBQgFEG/f2pB/wFxQRpJG0H/AXEgAUGiwoCAAGotAABHDfwCIAFBDkYN8AIgAUEBaiEBIA1BAWoiDSACRw0ACyAAIBY2AgAMlgMLQcwAIRAgASINIAJGDZUDIAIgDWsgACgCACIBaiEWIA0gAWtBD2ohFwNAIA0tAAAiFEEgciAUIBRBv39qQf8BcUEaSRtB/wFxIAFBwMKAgABqLQAARw37AgJAIAFBD0cNAEEDIQEM8QILIAFBAWohASANQQFqIg0gAkcNAAsgACAWNgIADJUDC0HNACEQIAEiDSACRg2UAyACIA1rIAAoAgAiAWohFiANIAFrQQVqIRcDQCANLQAAIhRBIHIgFCAUQb9/akH/AXFBGkkbQf8BcSABQdDCgIAAai0AAEcN+gICQCABQQVHDQBBBCEBDPACCyABQQFqIQEgDUEBaiINIAJHDQALIAAgFjYCAAyUAwsCQCABIg0gAkcNAEHOACEQDJQDCwJAAkACQAJAIA0tAAAiAUEgciABIAFBv39qQf8BcUEaSRtB/wFxQZ1/ag4TAP0C/QL9Av0C/QL9Av0C/QL9Av0C/QL9AgH9Av0C/QICA/0CCyANQQFqIQFBwQAhEAz9AgsgDUEBaiEBQcIAIRAM/AILIA1BAWohAUHDACEQDPsCCyANQQFqIQFBxAAhEAz6AgsCQCABIgEgAkYNACAAQY2AgIAANgIIIAAgATYCBCABIQFBxQAhEAz6AgtBzwAhEAySAwsgECEBAkACQCAQLQAAQXZqDgQBqAKoAgCoAgsgEEEBaiEBC0EnIRAM+AILAkAgASIBIAJHDQBB0QAhEAyRAwsCQCABLQAAQSBGDQAgASEBDI0BCyABQQFqIQEgAC0ALUEBcUUNxwEgASEBDIwBCyABIhcgAkcNyAFB0gAhEAyPAwtB0wAhECABIhQgAkYNjgMgAiAUayAAKAIAIgFqIRYgFCABa0EBaiEXA0AgFC0AACABQdbCgIAAai0AAEcNzAEgAUEBRg3HASABQQFqIQEgFEEBaiIUIAJHDQALIAAgFjYCAAyOAwsCQCABIgEgAkcNAEHVACEQDI4DCyABLQAAQQpHDcwBIAFBAWohAQzHAQsCQCABIgEgAkcNAEHWACEQDI0DCwJAAkAgAS0AAEF2ag4EAM0BzQEBzQELIAFBAWohAQzHAQsgAUEBaiEBQcoAIRAM8wILIAAgASIBIAIQroCAgAAiEA3LASABIQFBzQAhEAzyAgsgAC0AKUEiRg2FAwymAgsCQCABIgEgAkcNAEHbACEQDIoDC0EAIRRBASEXQQEhFkEAIRACQAJAAkACQAJAAkACQAJAAkAgAS0AAEFQag4K1AHTAQABAgMEBQYI1QELQQIhEAwGC0EDIRAMBQtBBCEQDAQLQQUhEAwDC0EGIRAMAgtBByEQDAELQQghEAtBACEXQQAhFkEAIRQMzAELQQkhEEEBIRRBACEXQQAhFgzLAQsCQCABIgEgAkcNAEHdACEQDIkDCyABLQAAQS5HDcwBIAFBAWohAQymAgsgASIBIAJHDcwBQd8AIRAMhwMLAkAgASIBIAJGDQAgAEGOgICAADYCCCAAIAE2AgQgASEBQdAAIRAM7gILQeAAIRAMhgMLQeEAIRAgASIBIAJGDYUDIAIgAWsgACgCACIUaiEWIAEgFGtBA2ohFwNAIAEtAAAgFEHiwoCAAGotAABHDc0BIBRBA0YNzAEgFEEBaiEUIAFBAWoiASACRw0ACyAAIBY2AgAMhQMLQeIAIRAgASIBIAJGDYQDIAIgAWsgACgCACIUaiEWIAEgFGtBAmohFwNAIAEtAAAgFEHmwoCAAGotAABHDcwBIBRBAkYNzgEgFEEBaiEUIAFBAWoiASACRw0ACyAAIBY2AgAMhAMLQeMAIRAgASIBIAJGDYMDIAIgAWsgACgCACIUaiEWIAEgFGtBA2ohFwNAIAEtAAAgFEHpwoCAAGotAABHDcsBIBRBA0YNzgEgFEEBaiEUIAFBAWoiASACRw0ACyAAIBY2AgAMgwMLAkAgASIBIAJHDQBB5QAhEAyDAwsgACABQQFqIgEgAhCogICAACIQDc0BIAEhAUHWACEQDOkCCwJAIAEiASACRg0AA0ACQCABLQAAIhBBIEYNAAJAAkACQCAQQbh/ag4LAAHPAc8BzwHPAc8BzwHPAc8BAs8BCyABQQFqIQFB0gAhEAztAgsgAUEBaiEBQdMAIRAM7AILIAFBAWohAUHUACEQDOsCCyABQQFqIgEgAkcNAAtB5AAhEAyCAwtB5AAhEAyBAwsDQAJAIAEtAABB8MKAgABqLQAAIhBBAUYNACAQQX5qDgPPAdAB0QHSAQsgAUEBaiIBIAJHDQALQeYAIRAMgAMLAkAgASIBIAJGDQAgAUEBaiEBDAMLQecAIRAM/wILA0ACQCABLQAAQfDEgIAAai0AACIQQQFGDQACQCAQQX5qDgTSAdMB1AEA1QELIAEhAUHXACEQDOcCCyABQQFqIgEgAkcNAAtB6AAhEAz+AgsCQCABIgEgAkcNAEHpACEQDP4CCwJAIAEtAAAiEEF2ag4augHVAdUBvAHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHVAdUB1QHKAdUB1QEA0wELIAFBAWohAQtBBiEQDOMCCwNAAkAgAS0AAEHwxoCAAGotAABBAUYNACABIQEMngILIAFBAWoiASACRw0AC0HqACEQDPsCCwJAIAEiASACRg0AIAFBAWohAQwDC0HrACEQDPoCCwJAIAEiASACRw0AQewAIRAM+gILIAFBAWohAQwBCwJAIAEiASACRw0AQe0AIRAM+QILIAFBAWohAQtBBCEQDN4CCwJAIAEiFCACRw0AQe4AIRAM9wILIBQhAQJAAkACQCAULQAAQfDIgIAAai0AAEF/ag4H1AHVAdYBAJwCAQLXAQsgFEEBaiEBDAoLIBRBAWohAQzNAQtBACEQIABBADYCHCAAQZuSgIAANgIQIABBBzYCDCAAIBRBAWo2AhQM9gILAkADQAJAIAEtAABB8MiAgABqLQAAIhBBBEYNAAJAAkAgEEF/ag4H0gHTAdQB2QEABAHZAQsgASEBQdoAIRAM4AILIAFBAWohAUHcACEQDN8CCyABQQFqIgEgAkcNAAtB7wAhEAz2AgsgAUEBaiEBDMsBCwJAIAEiFCACRw0AQfAAIRAM9QILIBQtAABBL0cN1AEgFEEBaiEBDAYLAkAgASIUIAJHDQBB8QAhEAz0AgsCQCAULQAAIgFBL0cNACAUQQFqIQFB3QAhEAzbAgsgAUF2aiIEQRZLDdMBQQEgBHRBiYCAAnFFDdMBDMoCCwJAIAEiASACRg0AIAFBAWohAUHeACEQDNoCC0HyACEQDPICCwJAIAEiFCACRw0AQfQAIRAM8gILIBQhAQJAIBQtAABB8MyAgABqLQAAQX9qDgPJApQCANQBC0HhACEQDNgCCwJAIAEiFCACRg0AA0ACQCAULQAAQfDKgIAAai0AACIBQQNGDQACQCABQX9qDgLLAgDVAQsgFCEBQd8AIRAM2gILIBRBAWoiFCACRw0AC0HzACEQDPECC0HzACEQDPACCwJAIAEiASACRg0AIABBj4CAgAA2AgggACABNgIEIAEhAUHgACEQDNcCC0H1ACEQDO8CCwJAIAEiASACRw0AQfYAIRAM7wILIABBj4CAgAA2AgggACABNgIEIAEhAQtBAyEQDNQCCwNAIAEtAABBIEcNwwIgAUEBaiIBIAJHDQALQfcAIRAM7AILAkAgASIBIAJHDQBB+AAhEAzsAgsgAS0AAEEgRw3OASABQQFqIQEM7wELIAAgASIBIAIQrICAgAAiEA3OASABIQEMjgILAkAgASIEIAJHDQBB+gAhEAzqAgsgBC0AAEHMAEcN0QEgBEEBaiEBQRMhEAzPAQsCQCABIgQgAkcNAEH7ACEQDOkCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRADQCAELQAAIAFB8M6AgABqLQAARw3QASABQQVGDc4BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQfsAIRAM6AILAkAgASIEIAJHDQBB/AAhEAzoAgsCQAJAIAQtAABBvX9qDgwA0QHRAdEB0QHRAdEB0QHRAdEB0QEB0QELIARBAWohAUHmACEQDM8CCyAEQQFqIQFB5wAhEAzOAgsCQCABIgQgAkcNAEH9ACEQDOcCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDc8BIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEH9ACEQDOcCCyAAQQA2AgAgEEEBaiEBQRAhEAzMAQsCQCABIgQgAkcNAEH+ACEQDOYCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUH2zoCAAGotAABHDc4BIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEH+ACEQDOYCCyAAQQA2AgAgEEEBaiEBQRYhEAzLAQsCQCABIgQgAkcNAEH/ACEQDOUCCyACIARrIAAoAgAiAWohFCAEIAFrQQNqIRACQANAIAQtAAAgAUH8zoCAAGotAABHDc0BIAFBA0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEH/ACEQDOUCCyAAQQA2AgAgEEEBaiEBQQUhEAzKAQsCQCABIgQgAkcNAEGAASEQDOQCCyAELQAAQdkARw3LASAEQQFqIQFBCCEQDMkBCwJAIAEiBCACRw0AQYEBIRAM4wILAkACQCAELQAAQbJ/ag4DAMwBAcwBCyAEQQFqIQFB6wAhEAzKAgsgBEEBaiEBQewAIRAMyQILAkAgASIEIAJHDQBBggEhEAziAgsCQAJAIAQtAABBuH9qDggAywHLAcsBywHLAcsBAcsBCyAEQQFqIQFB6gAhEAzJAgsgBEEBaiEBQe0AIRAMyAILAkAgASIEIAJHDQBBgwEhEAzhAgsgAiAEayAAKAIAIgFqIRAgBCABa0ECaiEUAkADQCAELQAAIAFBgM+AgABqLQAARw3JASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBA2AgBBgwEhEAzhAgtBACEQIABBADYCACAUQQFqIQEMxgELAkAgASIEIAJHDQBBhAEhEAzgAgsgAiAEayAAKAIAIgFqIRQgBCABa0EEaiEQAkADQCAELQAAIAFBg8+AgABqLQAARw3IASABQQRGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBhAEhEAzgAgsgAEEANgIAIBBBAWohAUEjIRAMxQELAkAgASIEIAJHDQBBhQEhEAzfAgsCQAJAIAQtAABBtH9qDggAyAHIAcgByAHIAcgBAcgBCyAEQQFqIQFB7wAhEAzGAgsgBEEBaiEBQfAAIRAMxQILAkAgASIEIAJHDQBBhgEhEAzeAgsgBC0AAEHFAEcNxQEgBEEBaiEBDIMCCwJAIAEiBCACRw0AQYcBIRAM3QILIAIgBGsgACgCACIBaiEUIAQgAWtBA2ohEAJAA0AgBC0AACABQYjPgIAAai0AAEcNxQEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYcBIRAM3QILIABBADYCACAQQQFqIQFBLSEQDMIBCwJAIAEiBCACRw0AQYgBIRAM3AILIAIgBGsgACgCACIBaiEUIAQgAWtBCGohEAJAA0AgBC0AACABQdDPgIAAai0AAEcNxAEgAUEIRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYgBIRAM3AILIABBADYCACAQQQFqIQFBKSEQDMEBCwJAIAEiASACRw0AQYkBIRAM2wILQQEhECABLQAAQd8ARw3AASABQQFqIQEMgQILAkAgASIEIAJHDQBBigEhEAzaAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQA0AgBC0AACABQYzPgIAAai0AAEcNwQEgAUEBRg2vAiABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGKASEQDNkCCwJAIAEiBCACRw0AQYsBIRAM2QILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQY7PgIAAai0AAEcNwQEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYsBIRAM2QILIABBADYCACAQQQFqIQFBAiEQDL4BCwJAIAEiBCACRw0AQYwBIRAM2AILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfDPgIAAai0AAEcNwAEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQYwBIRAM2AILIABBADYCACAQQQFqIQFBHyEQDL0BCwJAIAEiBCACRw0AQY0BIRAM1wILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfLPgIAAai0AAEcNvwEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQY0BIRAM1wILIABBADYCACAQQQFqIQFBCSEQDLwBCwJAIAEiBCACRw0AQY4BIRAM1gILAkACQCAELQAAQbd/ag4HAL8BvwG/Ab8BvwEBvwELIARBAWohAUH4ACEQDL0CCyAEQQFqIQFB+QAhEAy8AgsCQCABIgQgAkcNAEGPASEQDNUCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUGRz4CAAGotAABHDb0BIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGPASEQDNUCCyAAQQA2AgAgEEEBaiEBQRghEAy6AQsCQCABIgQgAkcNAEGQASEQDNQCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUGXz4CAAGotAABHDbwBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGQASEQDNQCCyAAQQA2AgAgEEEBaiEBQRchEAy5AQsCQCABIgQgAkcNAEGRASEQDNMCCyACIARrIAAoAgAiAWohFCAEIAFrQQZqIRACQANAIAQtAAAgAUGaz4CAAGotAABHDbsBIAFBBkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGRASEQDNMCCyAAQQA2AgAgEEEBaiEBQRUhEAy4AQsCQCABIgQgAkcNAEGSASEQDNICCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUGhz4CAAGotAABHDboBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGSASEQDNICCyAAQQA2AgAgEEEBaiEBQR4hEAy3AQsCQCABIgQgAkcNAEGTASEQDNECCyAELQAAQcwARw24ASAEQQFqIQFBCiEQDLYBCwJAIAQgAkcNAEGUASEQDNACCwJAAkAgBC0AAEG/f2oODwC5AbkBuQG5AbkBuQG5AbkBuQG5AbkBuQG5AQG5AQsgBEEBaiEBQf4AIRAMtwILIARBAWohAUH/ACEQDLYCCwJAIAQgAkcNAEGVASEQDM8CCwJAAkAgBC0AAEG/f2oOAwC4AQG4AQsgBEEBaiEBQf0AIRAMtgILIARBAWohBEGAASEQDLUCCwJAIAQgAkcNAEGWASEQDM4CCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUGnz4CAAGotAABHDbYBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGWASEQDM4CCyAAQQA2AgAgEEEBaiEBQQshEAyzAQsCQCAEIAJHDQBBlwEhEAzNAgsCQAJAAkACQCAELQAAQVNqDiMAuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AbgBuAG4AQG4AbgBuAG4AbgBArgBuAG4AQO4AQsgBEEBaiEBQfsAIRAMtgILIARBAWohAUH8ACEQDLUCCyAEQQFqIQRBgQEhEAy0AgsgBEEBaiEEQYIBIRAMswILAkAgBCACRw0AQZgBIRAMzAILIAIgBGsgACgCACIBaiEUIAQgAWtBBGohEAJAA0AgBC0AACABQanPgIAAai0AAEcNtAEgAUEERg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZgBIRAMzAILIABBADYCACAQQQFqIQFBGSEQDLEBCwJAIAQgAkcNAEGZASEQDMsCCyACIARrIAAoAgAiAWohFCAEIAFrQQVqIRACQANAIAQtAAAgAUGuz4CAAGotAABHDbMBIAFBBUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGZASEQDMsCCyAAQQA2AgAgEEEBaiEBQQYhEAywAQsCQCAEIAJHDQBBmgEhEAzKAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBtM+AgABqLQAARw2yASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBmgEhEAzKAgsgAEEANgIAIBBBAWohAUEcIRAMrwELAkAgBCACRw0AQZsBIRAMyQILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQbbPgIAAai0AAEcNsQEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZsBIRAMyQILIABBADYCACAQQQFqIQFBJyEQDK4BCwJAIAQgAkcNAEGcASEQDMgCCwJAAkAgBC0AAEGsf2oOAgABsQELIARBAWohBEGGASEQDK8CCyAEQQFqIQRBhwEhEAyuAgsCQCAEIAJHDQBBnQEhEAzHAgsgAiAEayAAKAIAIgFqIRQgBCABa0EBaiEQAkADQCAELQAAIAFBuM+AgABqLQAARw2vASABQQFGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBnQEhEAzHAgsgAEEANgIAIBBBAWohAUEmIRAMrAELAkAgBCACRw0AQZ4BIRAMxgILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQbrPgIAAai0AAEcNrgEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQZ4BIRAMxgILIABBADYCACAQQQFqIQFBAyEQDKsBCwJAIAQgAkcNAEGfASEQDMUCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDa0BIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGfASEQDMUCCyAAQQA2AgAgEEEBaiEBQQwhEAyqAQsCQCAEIAJHDQBBoAEhEAzEAgsgAiAEayAAKAIAIgFqIRQgBCABa0EDaiEQAkADQCAELQAAIAFBvM+AgABqLQAARw2sASABQQNGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBoAEhEAzEAgsgAEEANgIAIBBBAWohAUENIRAMqQELAkAgBCACRw0AQaEBIRAMwwILAkACQCAELQAAQbp/ag4LAKwBrAGsAawBrAGsAawBrAGsAQGsAQsgBEEBaiEEQYsBIRAMqgILIARBAWohBEGMASEQDKkCCwJAIAQgAkcNAEGiASEQDMICCyAELQAAQdAARw2pASAEQQFqIQQM6QELAkAgBCACRw0AQaMBIRAMwQILAkACQCAELQAAQbd/ag4HAaoBqgGqAaoBqgEAqgELIARBAWohBEGOASEQDKgCCyAEQQFqIQFBIiEQDKYBCwJAIAQgAkcNAEGkASEQDMACCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUHAz4CAAGotAABHDagBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGkASEQDMACCyAAQQA2AgAgEEEBaiEBQR0hEAylAQsCQCAEIAJHDQBBpQEhEAy/AgsCQAJAIAQtAABBrn9qDgMAqAEBqAELIARBAWohBEGQASEQDKYCCyAEQQFqIQFBBCEQDKQBCwJAIAQgAkcNAEGmASEQDL4CCwJAAkACQAJAAkAgBC0AAEG/f2oOFQCqAaoBqgGqAaoBqgGqAaoBqgGqAQGqAaoBAqoBqgEDqgGqAQSqAQsgBEEBaiEEQYgBIRAMqAILIARBAWohBEGJASEQDKcCCyAEQQFqIQRBigEhEAymAgsgBEEBaiEEQY8BIRAMpQILIARBAWohBEGRASEQDKQCCwJAIAQgAkcNAEGnASEQDL0CCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHtz4CAAGotAABHDaUBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGnASEQDL0CCyAAQQA2AgAgEEEBaiEBQREhEAyiAQsCQCAEIAJHDQBBqAEhEAy8AgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFBws+AgABqLQAARw2kASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBqAEhEAy8AgsgAEEANgIAIBBBAWohAUEsIRAMoQELAkAgBCACRw0AQakBIRAMuwILIAIgBGsgACgCACIBaiEUIAQgAWtBBGohEAJAA0AgBC0AACABQcXPgIAAai0AAEcNowEgAUEERg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQakBIRAMuwILIABBADYCACAQQQFqIQFBKyEQDKABCwJAIAQgAkcNAEGqASEQDLoCCyACIARrIAAoAgAiAWohFCAEIAFrQQJqIRACQANAIAQtAAAgAUHKz4CAAGotAABHDaIBIAFBAkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGqASEQDLoCCyAAQQA2AgAgEEEBaiEBQRQhEAyfAQsCQCAEIAJHDQBBqwEhEAy5AgsCQAJAAkACQCAELQAAQb5/ag4PAAECpAGkAaQBpAGkAaQBpAGkAaQBpAGkAQOkAQsgBEEBaiEEQZMBIRAMogILIARBAWohBEGUASEQDKECCyAEQQFqIQRBlQEhEAygAgsgBEEBaiEEQZYBIRAMnwILAkAgBCACRw0AQawBIRAMuAILIAQtAABBxQBHDZ8BIARBAWohBAzgAQsCQCAEIAJHDQBBrQEhEAy3AgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFBzc+AgABqLQAARw2fASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBrQEhEAy3AgsgAEEANgIAIBBBAWohAUEOIRAMnAELAkAgBCACRw0AQa4BIRAMtgILIAQtAABB0ABHDZ0BIARBAWohAUElIRAMmwELAkAgBCACRw0AQa8BIRAMtQILIAIgBGsgACgCACIBaiEUIAQgAWtBCGohEAJAA0AgBC0AACABQdDPgIAAai0AAEcNnQEgAUEIRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQa8BIRAMtQILIABBADYCACAQQQFqIQFBKiEQDJoBCwJAIAQgAkcNAEGwASEQDLQCCwJAAkAgBC0AAEGrf2oOCwCdAZ0BnQGdAZ0BnQGdAZ0BnQEBnQELIARBAWohBEGaASEQDJsCCyAEQQFqIQRBmwEhEAyaAgsCQCAEIAJHDQBBsQEhEAyzAgsCQAJAIAQtAABBv39qDhQAnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBnAGcAZwBAZwBCyAEQQFqIQRBmQEhEAyaAgsgBEEBaiEEQZwBIRAMmQILAkAgBCACRw0AQbIBIRAMsgILIAIgBGsgACgCACIBaiEUIAQgAWtBA2ohEAJAA0AgBC0AACABQdnPgIAAai0AAEcNmgEgAUEDRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbIBIRAMsgILIABBADYCACAQQQFqIQFBISEQDJcBCwJAIAQgAkcNAEGzASEQDLECCyACIARrIAAoAgAiAWohFCAEIAFrQQZqIRACQANAIAQtAAAgAUHdz4CAAGotAABHDZkBIAFBBkYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEGzASEQDLECCyAAQQA2AgAgEEEBaiEBQRohEAyWAQsCQCAEIAJHDQBBtAEhEAywAgsCQAJAAkAgBC0AAEG7f2oOEQCaAZoBmgGaAZoBmgGaAZoBmgEBmgGaAZoBmgGaAQKaAQsgBEEBaiEEQZ0BIRAMmAILIARBAWohBEGeASEQDJcCCyAEQQFqIQRBnwEhEAyWAgsCQCAEIAJHDQBBtQEhEAyvAgsgAiAEayAAKAIAIgFqIRQgBCABa0EFaiEQAkADQCAELQAAIAFB5M+AgABqLQAARw2XASABQQVGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBtQEhEAyvAgsgAEEANgIAIBBBAWohAUEoIRAMlAELAkAgBCACRw0AQbYBIRAMrgILIAIgBGsgACgCACIBaiEUIAQgAWtBAmohEAJAA0AgBC0AACABQerPgIAAai0AAEcNlgEgAUECRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbYBIRAMrgILIABBADYCACAQQQFqIQFBByEQDJMBCwJAIAQgAkcNAEG3ASEQDK0CCwJAAkAgBC0AAEG7f2oODgCWAZYBlgGWAZYBlgGWAZYBlgGWAZYBlgEBlgELIARBAWohBEGhASEQDJQCCyAEQQFqIQRBogEhEAyTAgsCQCAEIAJHDQBBuAEhEAysAgsgAiAEayAAKAIAIgFqIRQgBCABa0ECaiEQAkADQCAELQAAIAFB7c+AgABqLQAARw2UASABQQJGDQEgAUEBaiEBIARBAWoiBCACRw0ACyAAIBQ2AgBBuAEhEAysAgsgAEEANgIAIBBBAWohAUESIRAMkQELAkAgBCACRw0AQbkBIRAMqwILIAIgBGsgACgCACIBaiEUIAQgAWtBAWohEAJAA0AgBC0AACABQfDPgIAAai0AAEcNkwEgAUEBRg0BIAFBAWohASAEQQFqIgQgAkcNAAsgACAUNgIAQbkBIRAMqwILIABBADYCACAQQQFqIQFBICEQDJABCwJAIAQgAkcNAEG6ASEQDKoCCyACIARrIAAoAgAiAWohFCAEIAFrQQFqIRACQANAIAQtAAAgAUHyz4CAAGotAABHDZIBIAFBAUYNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG6ASEQDKoCCyAAQQA2AgAgEEEBaiEBQQ8hEAyPAQsCQCAEIAJHDQBBuwEhEAypAgsCQAJAIAQtAABBt39qDgcAkgGSAZIBkgGSAQGSAQsgBEEBaiEEQaUBIRAMkAILIARBAWohBEGmASEQDI8CCwJAIAQgAkcNAEG8ASEQDKgCCyACIARrIAAoAgAiAWohFCAEIAFrQQdqIRACQANAIAQtAAAgAUH0z4CAAGotAABHDZABIAFBB0YNASABQQFqIQEgBEEBaiIEIAJHDQALIAAgFDYCAEG8ASEQDKgCCyAAQQA2AgAgEEEBaiEBQRshEAyNAQsCQCAEIAJHDQBBvQEhEAynAgsCQAJAAkAgBC0AAEG+f2oOEgCRAZEBkQGRAZEBkQGRAZEBkQEBkQGRAZEBkQGRAZEBApEBCyAEQQFqIQRBpAEhEAyPAgsgBEEBaiEEQacBIRAMjgILIARBAWohBEGoASEQDI0CCwJAIAQgAkcNAEG+ASEQDKYCCyAELQAAQc4ARw2NASAEQQFqIQQMzwELAkAgBCACRw0AQb8BIRAMpQILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBC0AAEG/f2oOFQABAgOcAQQFBpwBnAGcAQcICQoLnAEMDQ4PnAELIARBAWohAUHoACEQDJoCCyAEQQFqIQFB6QAhEAyZAgsgBEEBaiEBQe4AIRAMmAILIARBAWohAUHyACEQDJcCCyAEQQFqIQFB8wAhEAyWAgsgBEEBaiEBQfYAIRAMlQILIARBAWohAUH3ACEQDJQCCyAEQQFqIQFB+gAhEAyTAgsgBEEBaiEEQYMBIRAMkgILIARBAWohBEGEASEQDJECCyAEQQFqIQRBhQEhEAyQAgsgBEEBaiEEQZIBIRAMjwILIARBAWohBEGYASEQDI4CCyAEQQFqIQRBoAEhEAyNAgsgBEEBaiEEQaMBIRAMjAILIARBAWohBEGqASEQDIsCCwJAIAQgAkYNACAAQZCAgIAANgIIIAAgBDYCBEGrASEQDIsCC0HAASEQDKMCCyAAIAUgAhCqgICAACIBDYsBIAUhAQxcCwJAIAYgAkYNACAGQQFqIQUMjQELQcIBIRAMoQILA0ACQCAQLQAAQXZqDgSMAQAAjwEACyAQQQFqIhAgAkcNAAtBwwEhEAygAgsCQCAHIAJGDQAgAEGRgICAADYCCCAAIAc2AgQgByEBQQEhEAyHAgtBxAEhEAyfAgsCQCAHIAJHDQBBxQEhEAyfAgsCQAJAIActAABBdmoOBAHOAc4BAM4BCyAHQQFqIQYMjQELIAdBAWohBQyJAQsCQCAHIAJHDQBBxgEhEAyeAgsCQAJAIActAABBdmoOFwGPAY8BAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAQCPAQsgB0EBaiEHC0GwASEQDIQCCwJAIAggAkcNAEHIASEQDJ0CCyAILQAAQSBHDY0BIABBADsBMiAIQQFqIQFBswEhEAyDAgsgASEXAkADQCAXIgcgAkYNASAHLQAAQVBqQf8BcSIQQQpPDcwBAkAgAC8BMiIUQZkzSw0AIAAgFEEKbCIUOwEyIBBB//8DcyAUQf7/A3FJDQAgB0EBaiEXIAAgFCAQaiIQOwEyIBBB//8DcUHoB0kNAQsLQQAhECAAQQA2AhwgAEHBiYCAADYCECAAQQ02AgwgACAHQQFqNgIUDJwCC0HHASEQDJsCCyAAIAggAhCugICAACIQRQ3KASAQQRVHDYwBIABByAE2AhwgACAINgIUIABByZeAgAA2AhAgAEEVNgIMQQAhEAyaAgsCQCAJIAJHDQBBzAEhEAyaAgtBACEUQQEhF0EBIRZBACEQAkACQAJAAkACQAJAAkACQAJAIAktAABBUGoOCpYBlQEAAQIDBAUGCJcBC0ECIRAMBgtBAyEQDAULQQQhEAwEC0EFIRAMAwtBBiEQDAILQQchEAwBC0EIIRALQQAhF0EAIRZBACEUDI4BC0EJIRBBASEUQQAhF0EAIRYMjQELAkAgCiACRw0AQc4BIRAMmQILIAotAABBLkcNjgEgCkEBaiEJDMoBCyALIAJHDY4BQdABIRAMlwILAkAgCyACRg0AIABBjoCAgAA2AgggACALNgIEQbcBIRAM/gELQdEBIRAMlgILAkAgBCACRw0AQdIBIRAMlgILIAIgBGsgACgCACIQaiEUIAQgEGtBBGohCwNAIAQtAAAgEEH8z4CAAGotAABHDY4BIBBBBEYN6QEgEEEBaiEQIARBAWoiBCACRw0ACyAAIBQ2AgBB0gEhEAyVAgsgACAMIAIQrICAgAAiAQ2NASAMIQEMuAELAkAgBCACRw0AQdQBIRAMlAILIAIgBGsgACgCACIQaiEUIAQgEGtBAWohDANAIAQtAAAgEEGB0ICAAGotAABHDY8BIBBBAUYNjgEgEEEBaiEQIARBAWoiBCACRw0ACyAAIBQ2AgBB1AEhEAyTAgsCQCAEIAJHDQBB1gEhEAyTAgsgAiAEayAAKAIAIhBqIRQgBCAQa0ECaiELA0AgBC0AACAQQYPQgIAAai0AAEcNjgEgEEECRg2QASAQQQFqIRAgBEEBaiIEIAJHDQALIAAgFDYCAEHWASEQDJICCwJAIAQgAkcNAEHXASEQDJICCwJAAkAgBC0AAEG7f2oOEACPAY8BjwGPAY8BjwGPAY8BjwGPAY8BjwGPAY8BAY8BCyAEQQFqIQRBuwEhEAz5AQsgBEEBaiEEQbwBIRAM+AELAkAgBCACRw0AQdgBIRAMkQILIAQtAABByABHDYwBIARBAWohBAzEAQsCQCAEIAJGDQAgAEGQgICAADYCCCAAIAQ2AgRBvgEhEAz3AQtB2QEhEAyPAgsCQCAEIAJHDQBB2gEhEAyPAgsgBC0AAEHIAEYNwwEgAEEBOgAoDLkBCyAAQQI6AC8gACAEIAIQpoCAgAAiEA2NAUHCASEQDPQBCyAALQAoQX9qDgK3AbkBuAELA0ACQCAELQAAQXZqDgQAjgGOAQCOAQsgBEEBaiIEIAJHDQALQd0BIRAMiwILIABBADoALyAALQAtQQRxRQ2EAgsgAEEAOgAvIABBAToANCABIQEMjAELIBBBFUYN2gEgAEEANgIcIAAgATYCFCAAQaeOgIAANgIQIABBEjYCDEEAIRAMiAILAkAgACAQIAIQtICAgAAiBA0AIBAhAQyBAgsCQCAEQRVHDQAgAEEDNgIcIAAgEDYCFCAAQbCYgIAANgIQIABBFTYCDEEAIRAMiAILIABBADYCHCAAIBA2AhQgAEGnjoCAADYCECAAQRI2AgxBACEQDIcCCyAQQRVGDdYBIABBADYCHCAAIAE2AhQgAEHajYCAADYCECAAQRQ2AgxBACEQDIYCCyAAKAIEIRcgAEEANgIEIBAgEadqIhYhASAAIBcgECAWIBQbIhAQtYCAgAAiFEUNjQEgAEEHNgIcIAAgEDYCFCAAIBQ2AgxBACEQDIUCCyAAIAAvATBBgAFyOwEwIAEhAQtBKiEQDOoBCyAQQRVGDdEBIABBADYCHCAAIAE2AhQgAEGDjICAADYCECAAQRM2AgxBACEQDIICCyAQQRVGDc8BIABBADYCHCAAIAE2AhQgAEGaj4CAADYCECAAQSI2AgxBACEQDIECCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQt4CAgAAiEA0AIAFBAWohAQyNAQsgAEEMNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDIACCyAQQRVGDcwBIABBADYCHCAAIAE2AhQgAEGaj4CAADYCECAAQSI2AgxBACEQDP8BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQt4CAgAAiEA0AIAFBAWohAQyMAQsgAEENNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDP4BCyAQQRVGDckBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAAQSM2AgxBACEQDP0BCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQuYCAgAAiEA0AIAFBAWohAQyLAQsgAEEONgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDPwBCyAAQQA2AhwgACABNgIUIABBwJWAgAA2AhAgAEECNgIMQQAhEAz7AQsgEEEVRg3FASAAQQA2AhwgACABNgIUIABBxoyAgAA2AhAgAEEjNgIMQQAhEAz6AQsgAEEQNgIcIAAgATYCFCAAIBA2AgxBACEQDPkBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQuYCAgAAiBA0AIAFBAWohAQzxAQsgAEERNgIcIAAgBDYCDCAAIAFBAWo2AhRBACEQDPgBCyAQQRVGDcEBIABBADYCHCAAIAE2AhQgAEHGjICAADYCECAAQSM2AgxBACEQDPcBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQuYCAgAAiEA0AIAFBAWohAQyIAQsgAEETNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDPYBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQuYCAgAAiBA0AIAFBAWohAQztAQsgAEEUNgIcIAAgBDYCDCAAIAFBAWo2AhRBACEQDPUBCyAQQRVGDb0BIABBADYCHCAAIAE2AhQgAEGaj4CAADYCECAAQSI2AgxBACEQDPQBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQt4CAgAAiEA0AIAFBAWohAQyGAQsgAEEWNgIcIAAgEDYCDCAAIAFBAWo2AhRBACEQDPMBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQt4CAgAAiBA0AIAFBAWohAQzpAQsgAEEXNgIcIAAgBDYCDCAAIAFBAWo2AhRBACEQDPIBCyAAQQA2AhwgACABNgIUIABBzZOAgAA2AhAgAEEMNgIMQQAhEAzxAQtCASERCyAQQQFqIQECQCAAKQMgIhJC//////////8PVg0AIAAgEkIEhiARhDcDICABIQEMhAELIABBADYCHCAAIAE2AhQgAEGtiYCAADYCECAAQQw2AgxBACEQDO8BCyAAQQA2AhwgACAQNgIUIABBzZOAgAA2AhAgAEEMNgIMQQAhEAzuAQsgACgCBCEXIABBADYCBCAQIBGnaiIWIQEgACAXIBAgFiAUGyIQELWAgIAAIhRFDXMgAEEFNgIcIAAgEDYCFCAAIBQ2AgxBACEQDO0BCyAAQQA2AhwgACAQNgIUIABBqpyAgAA2AhAgAEEPNgIMQQAhEAzsAQsgACAQIAIQtICAgAAiAQ0BIBAhAQtBDiEQDNEBCwJAIAFBFUcNACAAQQI2AhwgACAQNgIUIABBsJiAgAA2AhAgAEEVNgIMQQAhEAzqAQsgAEEANgIcIAAgEDYCFCAAQaeOgIAANgIQIABBEjYCDEEAIRAM6QELIAFBAWohEAJAIAAvATAiAUGAAXFFDQACQCAAIBAgAhC7gICAACIBDQAgECEBDHALIAFBFUcNugEgAEEFNgIcIAAgEDYCFCAAQfmXgIAANgIQIABBFTYCDEEAIRAM6QELAkAgAUGgBHFBoARHDQAgAC0ALUECcQ0AIABBADYCHCAAIBA2AhQgAEGWk4CAADYCECAAQQQ2AgxBACEQDOkBCyAAIBAgAhC9gICAABogECEBAkACQAJAAkACQCAAIBAgAhCzgICAAA4WAgEABAQEBAQEBAQEBAQEBAQEBAQEAwQLIABBAToALgsgACAALwEwQcAAcjsBMCAQIQELQSYhEAzRAQsgAEEjNgIcIAAgEDYCFCAAQaWWgIAANgIQIABBFTYCDEEAIRAM6QELIABBADYCHCAAIBA2AhQgAEHVi4CAADYCECAAQRE2AgxBACEQDOgBCyAALQAtQQFxRQ0BQcMBIRAMzgELAkAgDSACRg0AA0ACQCANLQAAQSBGDQAgDSEBDMQBCyANQQFqIg0gAkcNAAtBJSEQDOcBC0ElIRAM5gELIAAoAgQhBCAAQQA2AgQgACAEIA0Qr4CAgAAiBEUNrQEgAEEmNgIcIAAgBDYCDCAAIA1BAWo2AhRBACEQDOUBCyAQQRVGDasBIABBADYCHCAAIAE2AhQgAEH9jYCAADYCECAAQR02AgxBACEQDOQBCyAAQSc2AhwgACABNgIUIAAgEDYCDEEAIRAM4wELIBAhAUEBIRQCQAJAAkACQAJAAkACQCAALQAsQX5qDgcGBQUDAQIABQsgACAALwEwQQhyOwEwDAMLQQIhFAwBC0EEIRQLIABBAToALCAAIAAvATAgFHI7ATALIBAhAQtBKyEQDMoBCyAAQQA2AhwgACAQNgIUIABBq5KAgAA2AhAgAEELNgIMQQAhEAziAQsgAEEANgIcIAAgATYCFCAAQeGPgIAANgIQIABBCjYCDEEAIRAM4QELIABBADoALCAQIQEMvQELIBAhAUEBIRQCQAJAAkACQAJAIAAtACxBe2oOBAMBAgAFCyAAIAAvATBBCHI7ATAMAwtBAiEUDAELQQQhFAsgAEEBOgAsIAAgAC8BMCAUcjsBMAsgECEBC0EpIRAMxQELIABBADYCHCAAIAE2AhQgAEHwlICAADYCECAAQQM2AgxBACEQDN0BCwJAIA4tAABBDUcNACAAKAIEIQEgAEEANgIEAkAgACABIA4QsYCAgAAiAQ0AIA5BAWohAQx1CyAAQSw2AhwgACABNgIMIAAgDkEBajYCFEEAIRAM3QELIAAtAC1BAXFFDQFBxAEhEAzDAQsCQCAOIAJHDQBBLSEQDNwBCwJAAkADQAJAIA4tAABBdmoOBAIAAAMACyAOQQFqIg4gAkcNAAtBLSEQDN0BCyAAKAIEIQEgAEEANgIEAkAgACABIA4QsYCAgAAiAQ0AIA4hAQx0CyAAQSw2AhwgACAONgIUIAAgATYCDEEAIRAM3AELIAAoAgQhASAAQQA2AgQCQCAAIAEgDhCxgICAACIBDQAgDkEBaiEBDHMLIABBLDYCHCAAIAE2AgwgACAOQQFqNgIUQQAhEAzbAQsgACgCBCEEIABBADYCBCAAIAQgDhCxgICAACIEDaABIA4hAQzOAQsgEEEsRw0BIAFBAWohEEEBIQECQAJAAkACQAJAIAAtACxBe2oOBAMBAgQACyAQIQEMBAtBAiEBDAELQQQhAQsgAEEBOgAsIAAgAC8BMCABcjsBMCAQIQEMAQsgACAALwEwQQhyOwEwIBAhAQtBOSEQDL8BCyAAQQA6ACwgASEBC0E0IRAMvQELIAAgAC8BMEEgcjsBMCABIQEMAgsgACgCBCEEIABBADYCBAJAIAAgBCABELGAgIAAIgQNACABIQEMxwELIABBNzYCHCAAIAE2AhQgACAENgIMQQAhEAzUAQsgAEEIOgAsIAEhAQtBMCEQDLkBCwJAIAAtAChBAUYNACABIQEMBAsgAC0ALUEIcUUNkwEgASEBDAMLIAAtADBBIHENlAFBxQEhEAy3AQsCQCAPIAJGDQACQANAAkAgDy0AAEFQaiIBQf8BcUEKSQ0AIA8hAUE1IRAMugELIAApAyAiEUKZs+bMmbPmzBlWDQEgACARQgp+IhE3AyAgESABrUL/AYMiEkJ/hVYNASAAIBEgEnw3AyAgD0EBaiIPIAJHDQALQTkhEAzRAQsgACgCBCECIABBADYCBCAAIAIgD0EBaiIEELGAgIAAIgINlQEgBCEBDMMBC0E5IRAMzwELAkAgAC8BMCIBQQhxRQ0AIAAtAChBAUcNACAALQAtQQhxRQ2QAQsgACABQff7A3FBgARyOwEwIA8hAQtBNyEQDLQBCyAAIAAvATBBEHI7ATAMqwELIBBBFUYNiwEgAEEANgIcIAAgATYCFCAAQfCOgIAANgIQIABBHDYCDEEAIRAMywELIABBwwA2AhwgACABNgIMIAAgDUEBajYCFEEAIRAMygELAkAgAS0AAEE6Rw0AIAAoAgQhECAAQQA2AgQCQCAAIBAgARCvgICAACIQDQAgAUEBaiEBDGMLIABBwwA2AhwgACAQNgIMIAAgAUEBajYCFEEAIRAMygELIABBADYCHCAAIAE2AhQgAEGxkYCAADYCECAAQQo2AgxBACEQDMkBCyAAQQA2AhwgACABNgIUIABBoJmAgAA2AhAgAEEeNgIMQQAhEAzIAQsgAEEANgIACyAAQYASOwEqIAAgF0EBaiIBIAIQqICAgAAiEA0BIAEhAQtBxwAhEAysAQsgEEEVRw2DASAAQdEANgIcIAAgATYCFCAAQeOXgIAANgIQIABBFTYCDEEAIRAMxAELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDF4LIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMwwELIABBADYCHCAAIBQ2AhQgAEHBqICAADYCECAAQQc2AgwgAEEANgIAQQAhEAzCAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMXQsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAzBAQtBACEQIABBADYCHCAAIAE2AhQgAEGAkYCAADYCECAAQQk2AgwMwAELIBBBFUYNfSAAQQA2AhwgACABNgIUIABBlI2AgAA2AhAgAEEhNgIMQQAhEAy/AQtBASEWQQAhF0EAIRRBASEQCyAAIBA6ACsgAUEBaiEBAkACQCAALQAtQRBxDQACQAJAAkAgAC0AKg4DAQACBAsgFkUNAwwCCyAUDQEMAgsgF0UNAQsgACgCBCEQIABBADYCBAJAIAAgECABEK2AgIAAIhANACABIQEMXAsgAEHYADYCHCAAIAE2AhQgACAQNgIMQQAhEAy+AQsgACgCBCEEIABBADYCBAJAIAAgBCABEK2AgIAAIgQNACABIQEMrQELIABB2QA2AhwgACABNgIUIAAgBDYCDEEAIRAMvQELIAAoAgQhBCAAQQA2AgQCQCAAIAQgARCtgICAACIEDQAgASEBDKsBCyAAQdoANgIcIAAgATYCFCAAIAQ2AgxBACEQDLwBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQrYCAgAAiBA0AIAEhAQypAQsgAEHcADYCHCAAIAE2AhQgACAENgIMQQAhEAy7AQsCQCABLQAAQVBqIhBB/wFxQQpPDQAgACAQOgAqIAFBAWohAUHPACEQDKIBCyAAKAIEIQQgAEEANgIEAkAgACAEIAEQrYCAgAAiBA0AIAEhAQynAQsgAEHeADYCHCAAIAE2AhQgACAENgIMQQAhEAy6AQsgAEEANgIAIBdBAWohAQJAIAAtAClBI08NACABIQEMWQsgAEEANgIcIAAgATYCFCAAQdOJgIAANgIQIABBCDYCDEEAIRAMuQELIABBADYCAAtBACEQIABBADYCHCAAIAE2AhQgAEGQs4CAADYCECAAQQg2AgwMtwELIABBADYCACAXQQFqIQECQCAALQApQSFHDQAgASEBDFYLIABBADYCHCAAIAE2AhQgAEGbioCAADYCECAAQQg2AgxBACEQDLYBCyAAQQA2AgAgF0EBaiEBAkAgAC0AKSIQQV1qQQtPDQAgASEBDFULAkAgEEEGSw0AQQEgEHRBygBxRQ0AIAEhAQxVC0EAIRAgAEEANgIcIAAgATYCFCAAQfeJgIAANgIQIABBCDYCDAy1AQsgEEEVRg1xIABBADYCHCAAIAE2AhQgAEG5jYCAADYCECAAQRo2AgxBACEQDLQBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxUCyAAQeUANgIcIAAgATYCFCAAIBA2AgxBACEQDLMBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxNCyAAQdIANgIcIAAgATYCFCAAIBA2AgxBACEQDLIBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxNCyAAQdMANgIcIAAgATYCFCAAIBA2AgxBACEQDLEBCyAAKAIEIRAgAEEANgIEAkAgACAQIAEQp4CAgAAiEA0AIAEhAQxRCyAAQeUANgIcIAAgATYCFCAAIBA2AgxBACEQDLABCyAAQQA2AhwgACABNgIUIABBxoqAgAA2AhAgAEEHNgIMQQAhEAyvAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMSQsgAEHSADYCHCAAIAE2AhQgACAQNgIMQQAhEAyuAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMSQsgAEHTADYCHCAAIAE2AhQgACAQNgIMQQAhEAytAQsgACgCBCEQIABBADYCBAJAIAAgECABEKeAgIAAIhANACABIQEMTQsgAEHlADYCHCAAIAE2AhQgACAQNgIMQQAhEAysAQsgAEEANgIcIAAgATYCFCAAQdyIgIAANgIQIABBBzYCDEEAIRAMqwELIBBBP0cNASABQQFqIQELQQUhEAyQAQtBACEQIABBADYCHCAAIAE2AhQgAEH9koCAADYCECAAQQc2AgwMqAELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDEILIABB0gA2AhwgACABNgIUIAAgEDYCDEEAIRAMpwELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDEILIABB0wA2AhwgACABNgIUIAAgEDYCDEEAIRAMpgELIAAoAgQhECAAQQA2AgQCQCAAIBAgARCngICAACIQDQAgASEBDEYLIABB5QA2AhwgACABNgIUIAAgEDYCDEEAIRAMpQELIAAoAgQhASAAQQA2AgQCQCAAIAEgFBCngICAACIBDQAgFCEBDD8LIABB0gA2AhwgACAUNgIUIAAgATYCDEEAIRAMpAELIAAoAgQhASAAQQA2AgQCQCAAIAEgFBCngICAACIBDQAgFCEBDD8LIABB0wA2AhwgACAUNgIUIAAgATYCDEEAIRAMowELIAAoAgQhASAAQQA2AgQCQCAAIAEgFBCngICAACIBDQAgFCEBDEMLIABB5QA2AhwgACAUNgIUIAAgATYCDEEAIRAMogELIABBADYCHCAAIBQ2AhQgAEHDj4CAADYCECAAQQc2AgxBACEQDKEBCyAAQQA2AhwgACABNgIUIABBw4+AgAA2AhAgAEEHNgIMQQAhEAygAQtBACEQIABBADYCHCAAIBQ2AhQgAEGMnICAADYCECAAQQc2AgwMnwELIABBADYCHCAAIBQ2AhQgAEGMnICAADYCECAAQQc2AgxBACEQDJ4BCyAAQQA2AhwgACAUNgIUIABB/pGAgAA2AhAgAEEHNgIMQQAhEAydAQsgAEEANgIcIAAgATYCFCAAQY6bgIAANgIQIABBBjYCDEEAIRAMnAELIBBBFUYNVyAAQQA2AhwgACABNgIUIABBzI6AgAA2AhAgAEEgNgIMQQAhEAybAQsgAEEANgIAIBBBAWohAUEkIRALIAAgEDoAKSAAKAIEIRAgAEEANgIEIAAgECABEKuAgIAAIhANVCABIQEMPgsgAEEANgIAC0EAIRAgAEEANgIcIAAgBDYCFCAAQfGbgIAANgIQIABBBjYCDAyXAQsgAUEVRg1QIABBADYCHCAAIAU2AhQgAEHwjICAADYCECAAQRs2AgxBACEQDJYBCyAAKAIEIQUgAEEANgIEIAAgBSAQEKmAgIAAIgUNASAQQQFqIQULQa0BIRAMewsgAEHBATYCHCAAIAU2AgwgACAQQQFqNgIUQQAhEAyTAQsgACgCBCEGIABBADYCBCAAIAYgEBCpgICAACIGDQEgEEEBaiEGC0GuASEQDHgLIABBwgE2AhwgACAGNgIMIAAgEEEBajYCFEEAIRAMkAELIABBADYCHCAAIAc2AhQgAEGXi4CAADYCECAAQQ02AgxBACEQDI8BCyAAQQA2AhwgACAINgIUIABB45CAgAA2AhAgAEEJNgIMQQAhEAyOAQsgAEEANgIcIAAgCDYCFCAAQZSNgIAANgIQIABBITYCDEEAIRAMjQELQQEhFkEAIRdBACEUQQEhEAsgACAQOgArIAlBAWohCAJAAkAgAC0ALUEQcQ0AAkACQAJAIAAtACoOAwEAAgQLIBZFDQMMAgsgFA0BDAILIBdFDQELIAAoAgQhECAAQQA2AgQgACAQIAgQrYCAgAAiEEUNPSAAQckBNgIcIAAgCDYCFCAAIBA2AgxBACEQDIwBCyAAKAIEIQQgAEEANgIEIAAgBCAIEK2AgIAAIgRFDXYgAEHKATYCHCAAIAg2AhQgACAENgIMQQAhEAyLAQsgACgCBCEEIABBADYCBCAAIAQgCRCtgICAACIERQ10IABBywE2AhwgACAJNgIUIAAgBDYCDEEAIRAMigELIAAoAgQhBCAAQQA2AgQgACAEIAoQrYCAgAAiBEUNciAAQc0BNgIcIAAgCjYCFCAAIAQ2AgxBACEQDIkBCwJAIAstAABBUGoiEEH/AXFBCk8NACAAIBA6ACogC0EBaiEKQbYBIRAMcAsgACgCBCEEIABBADYCBCAAIAQgCxCtgICAACIERQ1wIABBzwE2AhwgACALNgIUIAAgBDYCDEEAIRAMiAELIABBADYCHCAAIAQ2AhQgAEGQs4CAADYCECAAQQg2AgwgAEEANgIAQQAhEAyHAQsgAUEVRg0/IABBADYCHCAAIAw2AhQgAEHMjoCAADYCECAAQSA2AgxBACEQDIYBCyAAQYEEOwEoIAAoAgQhECAAQgA3AwAgACAQIAxBAWoiDBCrgICAACIQRQ04IABB0wE2AhwgACAMNgIUIAAgEDYCDEEAIRAMhQELIABBADYCAAtBACEQIABBADYCHCAAIAQ2AhQgAEHYm4CAADYCECAAQQg2AgwMgwELIAAoAgQhECAAQgA3AwAgACAQIAtBAWoiCxCrgICAACIQDQFBxgEhEAxpCyAAQQI6ACgMVQsgAEHVATYCHCAAIAs2AhQgACAQNgIMQQAhEAyAAQsgEEEVRg03IABBADYCHCAAIAQ2AhQgAEGkjICAADYCECAAQRA2AgxBACEQDH8LIAAtADRBAUcNNCAAIAQgAhC8gICAACIQRQ00IBBBFUcNNSAAQdwBNgIcIAAgBDYCFCAAQdWWgIAANgIQIABBFTYCDEEAIRAMfgtBACEQIABBADYCHCAAQa+LgIAANgIQIABBAjYCDCAAIBRBAWo2AhQMfQtBACEQDGMLQQIhEAxiC0ENIRAMYQtBDyEQDGALQSUhEAxfC0ETIRAMXgtBFSEQDF0LQRYhEAxcC0EXIRAMWwtBGCEQDFoLQRkhEAxZC0EaIRAMWAtBGyEQDFcLQRwhEAxWC0EdIRAMVQtBHyEQDFQLQSEhEAxTC0EjIRAMUgtBxgAhEAxRC0EuIRAMUAtBLyEQDE8LQTshEAxOC0E9IRAMTQtByAAhEAxMC0HJACEQDEsLQcsAIRAMSgtBzAAhEAxJC0HOACEQDEgLQdEAIRAMRwtB1QAhEAxGC0HYACEQDEULQdkAIRAMRAtB2wAhEAxDC0HkACEQDEILQeUAIRAMQQtB8QAhEAxAC0H0ACEQDD8LQY0BIRAMPgtBlwEhEAw9C0GpASEQDDwLQawBIRAMOwtBwAEhEAw6C0G5ASEQDDkLQa8BIRAMOAtBsQEhEAw3C0GyASEQDDYLQbQBIRAMNQtBtQEhEAw0C0G6ASEQDDMLQb0BIRAMMgtBvwEhEAwxC0HBASEQDDALIABBADYCHCAAIAQ2AhQgAEHpi4CAADYCECAAQR82AgxBACEQDEgLIABB2wE2AhwgACAENgIUIABB+paAgAA2AhAgAEEVNgIMQQAhEAxHCyAAQfgANgIcIAAgDDYCFCAAQcqYgIAANgIQIABBFTYCDEEAIRAMRgsgAEHRADYCHCAAIAU2AhQgAEGwl4CAADYCECAAQRU2AgxBACEQDEULIABB+QA2AhwgACABNgIUIAAgEDYCDEEAIRAMRAsgAEH4ADYCHCAAIAE2AhQgAEHKmICAADYCECAAQRU2AgxBACEQDEMLIABB5AA2AhwgACABNgIUIABB45eAgAA2AhAgAEEVNgIMQQAhEAxCCyAAQdcANgIcIAAgATYCFCAAQcmXgIAANgIQIABBFTYCDEEAIRAMQQsgAEEANgIcIAAgATYCFCAAQbmNgIAANgIQIABBGjYCDEEAIRAMQAsgAEHCADYCHCAAIAE2AhQgAEHjmICAADYCECAAQRU2AgxBACEQDD8LIABBADYCBCAAIA8gDxCxgICAACIERQ0BIABBOjYCHCAAIAQ2AgwgACAPQQFqNgIUQQAhEAw+CyAAKAIEIQQgAEEANgIEAkAgACAEIAEQsYCAgAAiBEUNACAAQTs2AhwgACAENgIMIAAgAUEBajYCFEEAIRAMPgsgAUEBaiEBDC0LIA9BAWohAQwtCyAAQQA2AhwgACAPNgIUIABB5JKAgAA2AhAgAEEENgIMQQAhEAw7CyAAQTY2AhwgACAENgIUIAAgAjYCDEEAIRAMOgsgAEEuNgIcIAAgDjYCFCAAIAQ2AgxBACEQDDkLIABB0AA2AhwgACABNgIUIABBkZiAgAA2AhAgAEEVNgIMQQAhEAw4CyANQQFqIQEMLAsgAEEVNgIcIAAgATYCFCAAQYKZgIAANgIQIABBFTYCDEEAIRAMNgsgAEEbNgIcIAAgATYCFCAAQZGXgIAANgIQIABBFTYCDEEAIRAMNQsgAEEPNgIcIAAgATYCFCAAQZGXgIAANgIQIABBFTYCDEEAIRAMNAsgAEELNgIcIAAgATYCFCAAQZGXgIAANgIQIABBFTYCDEEAIRAMMwsgAEEaNgIcIAAgATYCFCAAQYKZgIAANgIQIABBFTYCDEEAIRAMMgsgAEELNgIcIAAgATYCFCAAQYKZgIAANgIQIABBFTYCDEEAIRAMMQsgAEEKNgIcIAAgATYCFCAAQeSWgIAANgIQIABBFTYCDEEAIRAMMAsgAEEeNgIcIAAgATYCFCAAQfmXgIAANgIQIABBFTYCDEEAIRAMLwsgAEEANgIcIAAgEDYCFCAAQdqNgIAANgIQIABBFDYCDEEAIRAMLgsgAEEENgIcIAAgATYCFCAAQbCYgIAANgIQIABBFTYCDEEAIRAMLQsgAEEANgIAIAtBAWohCwtBuAEhEAwSCyAAQQA2AgAgEEEBaiEBQfUAIRAMEQsgASEBAkAgAC0AKUEFRw0AQeMAIRAMEQtB4gAhEAwQC0EAIRAgAEEANgIcIABB5JGAgAA2AhAgAEEHNgIMIAAgFEEBajYCFAwoCyAAQQA2AgAgF0EBaiEBQcAAIRAMDgtBASEBCyAAIAE6ACwgAEEANgIAIBdBAWohAQtBKCEQDAsLIAEhAQtBOCEQDAkLAkAgASIPIAJGDQADQAJAIA8tAABBgL6AgABqLQAAIgFBAUYNACABQQJHDQMgD0EBaiEBDAQLIA9BAWoiDyACRw0AC0E+IRAMIgtBPiEQDCELIABBADoALCAPIQEMAQtBCyEQDAYLQTohEAwFCyABQQFqIQFBLSEQDAQLIAAgAToALCAAQQA2AgAgFkEBaiEBQQwhEAwDCyAAQQA2AgAgF0EBaiEBQQohEAwCCyAAQQA2AgALIABBADoALCANIQFBCSEQDAALC0EAIRAgAEEANgIcIAAgCzYCFCAAQc2QgIAANgIQIABBCTYCDAwXC0EAIRAgAEEANgIcIAAgCjYCFCAAQemKgIAANgIQIABBCTYCDAwWC0EAIRAgAEEANgIcIAAgCTYCFCAAQbeQgIAANgIQIABBCTYCDAwVC0EAIRAgAEEANgIcIAAgCDYCFCAAQZyRgIAANgIQIABBCTYCDAwUC0EAIRAgAEEANgIcIAAgATYCFCAAQc2QgIAANgIQIABBCTYCDAwTC0EAIRAgAEEANgIcIAAgATYCFCAAQemKgIAANgIQIABBCTYCDAwSC0EAIRAgAEEANgIcIAAgATYCFCAAQbeQgIAANgIQIABBCTYCDAwRC0EAIRAgAEEANgIcIAAgATYCFCAAQZyRgIAANgIQIABBCTYCDAwQC0EAIRAgAEEANgIcIAAgATYCFCAAQZeVgIAANgIQIABBDzYCDAwPC0EAIRAgAEEANgIcIAAgATYCFCAAQZeVgIAANgIQIABBDzYCDAwOC0EAIRAgAEEANgIcIAAgATYCFCAAQcCSgIAANgIQIABBCzYCDAwNC0EAIRAgAEEANgIcIAAgATYCFCAAQZWJgIAANgIQIABBCzYCDAwMC0EAIRAgAEEANgIcIAAgATYCFCAAQeGPgIAANgIQIABBCjYCDAwLC0EAIRAgAEEANgIcIAAgATYCFCAAQfuPgIAANgIQIABBCjYCDAwKC0EAIRAgAEEANgIcIAAgATYCFCAAQfGZgIAANgIQIABBAjYCDAwJC0EAIRAgAEEANgIcIAAgATYCFCAAQcSUgIAANgIQIABBAjYCDAwIC0EAIRAgAEEANgIcIAAgATYCFCAAQfKVgIAANgIQIABBAjYCDAwHCyAAQQI2AhwgACABNgIUIABBnJqAgAA2AhAgAEEWNgIMQQAhEAwGC0EBIRAMBQtB1AAhECABIgQgAkYNBCADQQhqIAAgBCACQdjCgIAAQQoQxYCAgAAgAygCDCEEIAMoAggOAwEEAgALEMqAgIAAAAsgAEEANgIcIABBtZqAgAA2AhAgAEEXNgIMIAAgBEEBajYCFEEAIRAMAgsgAEEANgIcIAAgBDYCFCAAQcqagIAANgIQIABBCTYCDEEAIRAMAQsCQCABIgQgAkcNAEEiIRAMAQsgAEGJgICAADYCCCAAIAQ2AgRBISEQCyADQRBqJICAgIAAIBALrwEBAn8gASgCACEGAkACQCACIANGDQAgBCAGaiEEIAYgA2ogAmshByACIAZBf3MgBWoiBmohBQNAAkAgAi0AACAELQAARg0AQQIhBAwDCwJAIAYNAEEAIQQgBSECDAMLIAZBf2ohBiAEQQFqIQQgAkEBaiICIANHDQALIAchBiADIQILIABBATYCACABIAY2AgAgACACNgIEDwsgAUEANgIAIAAgBDYCACAAIAI2AgQLCgAgABDHgICAAAvyNgELfyOAgICAAEEQayIBJICAgIAAAkBBACgCoNCAgAANAEEAEMuAgIAAQYDUhIAAayICQdkASQ0AQQAhAwJAQQAoAuDTgIAAIgQNAEEAQn83AuzTgIAAQQBCgICEgICAwAA3AuTTgIAAQQAgAUEIakFwcUHYqtWqBXMiBDYC4NOAgABBAEEANgL004CAAEEAQQA2AsTTgIAAC0EAIAI2AszTgIAAQQBBgNSEgAA2AsjTgIAAQQBBgNSEgAA2ApjQgIAAQQAgBDYCrNCAgABBAEF/NgKo0ICAAANAIANBxNCAgABqIANBuNCAgABqIgQ2AgAgBCADQbDQgIAAaiIFNgIAIANBvNCAgABqIAU2AgAgA0HM0ICAAGogA0HA0ICAAGoiBTYCACAFIAQ2AgAgA0HU0ICAAGogA0HI0ICAAGoiBDYCACAEIAU2AgAgA0HQ0ICAAGogBDYCACADQSBqIgNBgAJHDQALQYDUhIAAQXhBgNSEgABrQQ9xQQBBgNSEgABBCGpBD3EbIgNqIgRBBGogAkFIaiIFIANrIgNBAXI2AgBBAEEAKALw04CAADYCpNCAgABBACADNgKU0ICAAEEAIAQ2AqDQgIAAQYDUhIAAIAVqQTg2AgQLAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB7AFLDQACQEEAKAKI0ICAACIGQRAgAEETakFwcSAAQQtJGyICQQN2IgR2IgNBA3FFDQACQAJAIANBAXEgBHJBAXMiBUEDdCIEQbDQgIAAaiIDIARBuNCAgABqKAIAIgQoAggiAkcNAEEAIAZBfiAFd3E2AojQgIAADAELIAMgAjYCCCACIAM2AgwLIARBCGohAyAEIAVBA3QiBUEDcjYCBCAEIAVqIgQgBCgCBEEBcjYCBAwMCyACQQAoApDQgIAAIgdNDQECQCADRQ0AAkACQCADIAR0QQIgBHQiA0EAIANrcnEiA0EAIANrcUF/aiIDIANBDHZBEHEiA3YiBEEFdkEIcSIFIANyIAQgBXYiA0ECdkEEcSIEciADIAR2IgNBAXZBAnEiBHIgAyAEdiIDQQF2QQFxIgRyIAMgBHZqIgRBA3QiA0Gw0ICAAGoiBSADQbjQgIAAaigCACIDKAIIIgBHDQBBACAGQX4gBHdxIgY2AojQgIAADAELIAUgADYCCCAAIAU2AgwLIAMgAkEDcjYCBCADIARBA3QiBGogBCACayIFNgIAIAMgAmoiACAFQQFyNgIEAkAgB0UNACAHQXhxQbDQgIAAaiECQQAoApzQgIAAIQQCQAJAIAZBASAHQQN2dCIIcQ0AQQAgBiAIcjYCiNCAgAAgAiEIDAELIAIoAgghCAsgCCAENgIMIAIgBDYCCCAEIAI2AgwgBCAINgIICyADQQhqIQNBACAANgKc0ICAAEEAIAU2ApDQgIAADAwLQQAoAozQgIAAIglFDQEgCUEAIAlrcUF/aiIDIANBDHZBEHEiA3YiBEEFdkEIcSIFIANyIAQgBXYiA0ECdkEEcSIEciADIAR2IgNBAXZBAnEiBHIgAyAEdiIDQQF2QQFxIgRyIAMgBHZqQQJ0QbjSgIAAaigCACIAKAIEQXhxIAJrIQQgACEFAkADQAJAIAUoAhAiAw0AIAVBFGooAgAiA0UNAgsgAygCBEF4cSACayIFIAQgBSAESSIFGyEEIAMgACAFGyEAIAMhBQwACwsgACgCGCEKAkAgACgCDCIIIABGDQAgACgCCCIDQQAoApjQgIAASRogCCADNgIIIAMgCDYCDAwLCwJAIABBFGoiBSgCACIDDQAgACgCECIDRQ0DIABBEGohBQsDQCAFIQsgAyIIQRRqIgUoAgAiAw0AIAhBEGohBSAIKAIQIgMNAAsgC0EANgIADAoLQX8hAiAAQb9/Sw0AIABBE2oiA0FwcSECQQAoAozQgIAAIgdFDQBBACELAkAgAkGAAkkNAEEfIQsgAkH///8HSw0AIANBCHYiAyADQYD+P2pBEHZBCHEiA3QiBCAEQYDgH2pBEHZBBHEiBHQiBSAFQYCAD2pBEHZBAnEiBXRBD3YgAyAEciAFcmsiA0EBdCACIANBFWp2QQFxckEcaiELC0EAIAJrIQQCQAJAAkACQCALQQJ0QbjSgIAAaigCACIFDQBBACEDQQAhCAwBC0EAIQMgAkEAQRkgC0EBdmsgC0EfRht0IQBBACEIA0ACQCAFKAIEQXhxIAJrIgYgBE8NACAGIQQgBSEIIAYNAEEAIQQgBSEIIAUhAwwDCyADIAVBFGooAgAiBiAGIAUgAEEddkEEcWpBEGooAgAiBUYbIAMgBhshAyAAQQF0IQAgBQ0ACwsCQCADIAhyDQBBACEIQQIgC3QiA0EAIANrciAHcSIDRQ0DIANBACADa3FBf2oiAyADQQx2QRBxIgN2IgVBBXZBCHEiACADciAFIAB2IgNBAnZBBHEiBXIgAyAFdiIDQQF2QQJxIgVyIAMgBXYiA0EBdkEBcSIFciADIAV2akECdEG40oCAAGooAgAhAwsgA0UNAQsDQCADKAIEQXhxIAJrIgYgBEkhAAJAIAMoAhAiBQ0AIANBFGooAgAhBQsgBiAEIAAbIQQgAyAIIAAbIQggBSEDIAUNAAsLIAhFDQAgBEEAKAKQ0ICAACACa08NACAIKAIYIQsCQCAIKAIMIgAgCEYNACAIKAIIIgNBACgCmNCAgABJGiAAIAM2AgggAyAANgIMDAkLAkAgCEEUaiIFKAIAIgMNACAIKAIQIgNFDQMgCEEQaiEFCwNAIAUhBiADIgBBFGoiBSgCACIDDQAgAEEQaiEFIAAoAhAiAw0ACyAGQQA2AgAMCAsCQEEAKAKQ0ICAACIDIAJJDQBBACgCnNCAgAAhBAJAAkAgAyACayIFQRBJDQAgBCACaiIAIAVBAXI2AgRBACAFNgKQ0ICAAEEAIAA2ApzQgIAAIAQgA2ogBTYCACAEIAJBA3I2AgQMAQsgBCADQQNyNgIEIAQgA2oiAyADKAIEQQFyNgIEQQBBADYCnNCAgABBAEEANgKQ0ICAAAsgBEEIaiEDDAoLAkBBACgClNCAgAAiACACTQ0AQQAoAqDQgIAAIgMgAmoiBCAAIAJrIgVBAXI2AgRBACAFNgKU0ICAAEEAIAQ2AqDQgIAAIAMgAkEDcjYCBCADQQhqIQMMCgsCQAJAQQAoAuDTgIAARQ0AQQAoAujTgIAAIQQMAQtBAEJ/NwLs04CAAEEAQoCAhICAgMAANwLk04CAAEEAIAFBDGpBcHFB2KrVqgVzNgLg04CAAEEAQQA2AvTTgIAAQQBBADYCxNOAgABBgIAEIQQLQQAhAwJAIAQgAkHHAGoiB2oiBkEAIARrIgtxIgggAksNAEEAQTA2AvjTgIAADAoLAkBBACgCwNOAgAAiA0UNAAJAQQAoArjTgIAAIgQgCGoiBSAETQ0AIAUgA00NAQtBACEDQQBBMDYC+NOAgAAMCgtBAC0AxNOAgABBBHENBAJAAkACQEEAKAKg0ICAACIERQ0AQcjTgIAAIQMDQAJAIAMoAgAiBSAESw0AIAUgAygCBGogBEsNAwsgAygCCCIDDQALC0EAEMuAgIAAIgBBf0YNBSAIIQYCQEEAKALk04CAACIDQX9qIgQgAHFFDQAgCCAAayAEIABqQQAgA2txaiEGCyAGIAJNDQUgBkH+////B0sNBQJAQQAoAsDTgIAAIgNFDQBBACgCuNOAgAAiBCAGaiIFIARNDQYgBSADSw0GCyAGEMuAgIAAIgMgAEcNAQwHCyAGIABrIAtxIgZB/v///wdLDQQgBhDLgICAACIAIAMoAgAgAygCBGpGDQMgACEDCwJAIANBf0YNACACQcgAaiAGTQ0AAkAgByAGa0EAKALo04CAACIEakEAIARrcSIEQf7///8HTQ0AIAMhAAwHCwJAIAQQy4CAgABBf0YNACAEIAZqIQYgAyEADAcLQQAgBmsQy4CAgAAaDAQLIAMhACADQX9HDQUMAwtBACEIDAcLQQAhAAwFCyAAQX9HDQILQQBBACgCxNOAgABBBHI2AsTTgIAACyAIQf7///8HSw0BIAgQy4CAgAAhAEEAEMuAgIAAIQMgAEF/Rg0BIANBf0YNASAAIANPDQEgAyAAayIGIAJBOGpNDQELQQBBACgCuNOAgAAgBmoiAzYCuNOAgAACQCADQQAoArzTgIAATQ0AQQAgAzYCvNOAgAALAkACQAJAAkBBACgCoNCAgAAiBEUNAEHI04CAACEDA0AgACADKAIAIgUgAygCBCIIakYNAiADKAIIIgMNAAwDCwsCQAJAQQAoApjQgIAAIgNFDQAgACADTw0BC0EAIAA2ApjQgIAAC0EAIQNBACAGNgLM04CAAEEAIAA2AsjTgIAAQQBBfzYCqNCAgABBAEEAKALg04CAADYCrNCAgABBAEEANgLU04CAAANAIANBxNCAgABqIANBuNCAgABqIgQ2AgAgBCADQbDQgIAAaiIFNgIAIANBvNCAgABqIAU2AgAgA0HM0ICAAGogA0HA0ICAAGoiBTYCACAFIAQ2AgAgA0HU0ICAAGogA0HI0ICAAGoiBDYCACAEIAU2AgAgA0HQ0ICAAGogBDYCACADQSBqIgNBgAJHDQALIABBeCAAa0EPcUEAIABBCGpBD3EbIgNqIgQgBkFIaiIFIANrIgNBAXI2AgRBAEEAKALw04CAADYCpNCAgABBACADNgKU0ICAAEEAIAQ2AqDQgIAAIAAgBWpBODYCBAwCCyADLQAMQQhxDQAgBCAFSQ0AIAQgAE8NACAEQXggBGtBD3FBACAEQQhqQQ9xGyIFaiIAQQAoApTQgIAAIAZqIgsgBWsiBUEBcjYCBCADIAggBmo2AgRBAEEAKALw04CAADYCpNCAgABBACAFNgKU0ICAAEEAIAA2AqDQgIAAIAQgC2pBODYCBAwBCwJAIABBACgCmNCAgAAiCE8NAEEAIAA2ApjQgIAAIAAhCAsgACAGaiEFQcjTgIAAIQMCQAJAAkACQAJAAkACQANAIAMoAgAgBUYNASADKAIIIgMNAAwCCwsgAy0ADEEIcUUNAQtByNOAgAAhAwNAAkAgAygCACIFIARLDQAgBSADKAIEaiIFIARLDQMLIAMoAgghAwwACwsgAyAANgIAIAMgAygCBCAGajYCBCAAQXggAGtBD3FBACAAQQhqQQ9xG2oiCyACQQNyNgIEIAVBeCAFa0EPcUEAIAVBCGpBD3EbaiIGIAsgAmoiAmshAwJAIAYgBEcNAEEAIAI2AqDQgIAAQQBBACgClNCAgAAgA2oiAzYClNCAgAAgAiADQQFyNgIEDAMLAkAgBkEAKAKc0ICAAEcNAEEAIAI2ApzQgIAAQQBBACgCkNCAgAAgA2oiAzYCkNCAgAAgAiADQQFyNgIEIAIgA2ogAzYCAAwDCwJAIAYoAgQiBEEDcUEBRw0AIARBeHEhBwJAAkAgBEH/AUsNACAGKAIIIgUgBEEDdiIIQQN0QbDQgIAAaiIARhoCQCAGKAIMIgQgBUcNAEEAQQAoAojQgIAAQX4gCHdxNgKI0ICAAAwCCyAEIABGGiAEIAU2AgggBSAENgIMDAELIAYoAhghCQJAAkAgBigCDCIAIAZGDQAgBigCCCIEIAhJGiAAIAQ2AgggBCAANgIMDAELAkAgBkEUaiIEKAIAIgUNACAGQRBqIgQoAgAiBQ0AQQAhAAwBCwNAIAQhCCAFIgBBFGoiBCgCACIFDQAgAEEQaiEEIAAoAhAiBQ0ACyAIQQA2AgALIAlFDQACQAJAIAYgBigCHCIFQQJ0QbjSgIAAaiIEKAIARw0AIAQgADYCACAADQFBAEEAKAKM0ICAAEF+IAV3cTYCjNCAgAAMAgsgCUEQQRQgCSgCECAGRhtqIAA2AgAgAEUNAQsgACAJNgIYAkAgBigCECIERQ0AIAAgBDYCECAEIAA2AhgLIAYoAhQiBEUNACAAQRRqIAQ2AgAgBCAANgIYCyAHIANqIQMgBiAHaiIGKAIEIQQLIAYgBEF+cTYCBCACIANqIAM2AgAgAiADQQFyNgIEAkAgA0H/AUsNACADQXhxQbDQgIAAaiEEAkACQEEAKAKI0ICAACIFQQEgA0EDdnQiA3ENAEEAIAUgA3I2AojQgIAAIAQhAwwBCyAEKAIIIQMLIAMgAjYCDCAEIAI2AgggAiAENgIMIAIgAzYCCAwDC0EfIQQCQCADQf///wdLDQAgA0EIdiIEIARBgP4/akEQdkEIcSIEdCIFIAVBgOAfakEQdkEEcSIFdCIAIABBgIAPakEQdkECcSIAdEEPdiAEIAVyIAByayIEQQF0IAMgBEEVanZBAXFyQRxqIQQLIAIgBDYCHCACQgA3AhAgBEECdEG40oCAAGohBQJAQQAoAozQgIAAIgBBASAEdCIIcQ0AIAUgAjYCAEEAIAAgCHI2AozQgIAAIAIgBTYCGCACIAI2AgggAiACNgIMDAMLIANBAEEZIARBAXZrIARBH0YbdCEEIAUoAgAhAANAIAAiBSgCBEF4cSADRg0CIARBHXYhACAEQQF0IQQgBSAAQQRxakEQaiIIKAIAIgANAAsgCCACNgIAIAIgBTYCGCACIAI2AgwgAiACNgIIDAILIABBeCAAa0EPcUEAIABBCGpBD3EbIgNqIgsgBkFIaiIIIANrIgNBAXI2AgQgACAIakE4NgIEIAQgBUE3IAVrQQ9xQQAgBUFJakEPcRtqQUFqIgggCCAEQRBqSRsiCEEjNgIEQQBBACgC8NOAgAA2AqTQgIAAQQAgAzYClNCAgABBACALNgKg0ICAACAIQRBqQQApAtDTgIAANwIAIAhBACkCyNOAgAA3AghBACAIQQhqNgLQ04CAAEEAIAY2AszTgIAAQQAgADYCyNOAgABBAEEANgLU04CAACAIQSRqIQMDQCADQQc2AgAgA0EEaiIDIAVJDQALIAggBEYNAyAIIAgoAgRBfnE2AgQgCCAIIARrIgA2AgAgBCAAQQFyNgIEAkAgAEH/AUsNACAAQXhxQbDQgIAAaiEDAkACQEEAKAKI0ICAACIFQQEgAEEDdnQiAHENAEEAIAUgAHI2AojQgIAAIAMhBQwBCyADKAIIIQULIAUgBDYCDCADIAQ2AgggBCADNgIMIAQgBTYCCAwEC0EfIQMCQCAAQf///wdLDQAgAEEIdiIDIANBgP4/akEQdkEIcSIDdCIFIAVBgOAfakEQdkEEcSIFdCIIIAhBgIAPakEQdkECcSIIdEEPdiADIAVyIAhyayIDQQF0IAAgA0EVanZBAXFyQRxqIQMLIAQgAzYCHCAEQgA3AhAgA0ECdEG40oCAAGohBQJAQQAoAozQgIAAIghBASADdCIGcQ0AIAUgBDYCAEEAIAggBnI2AozQgIAAIAQgBTYCGCAEIAQ2AgggBCAENgIMDAQLIABBAEEZIANBAXZrIANBH0YbdCEDIAUoAgAhCANAIAgiBSgCBEF4cSAARg0DIANBHXYhCCADQQF0IQMgBSAIQQRxakEQaiIGKAIAIggNAAsgBiAENgIAIAQgBTYCGCAEIAQ2AgwgBCAENgIIDAMLIAUoAggiAyACNgIMIAUgAjYCCCACQQA2AhggAiAFNgIMIAIgAzYCCAsgC0EIaiEDDAULIAUoAggiAyAENgIMIAUgBDYCCCAEQQA2AhggBCAFNgIMIAQgAzYCCAtBACgClNCAgAAiAyACTQ0AQQAoAqDQgIAAIgQgAmoiBSADIAJrIgNBAXI2AgRBACADNgKU0ICAAEEAIAU2AqDQgIAAIAQgAkEDcjYCBCAEQQhqIQMMAwtBACEDQQBBMDYC+NOAgAAMAgsCQCALRQ0AAkACQCAIIAgoAhwiBUECdEG40oCAAGoiAygCAEcNACADIAA2AgAgAA0BQQAgB0F+IAV3cSIHNgKM0ICAAAwCCyALQRBBFCALKAIQIAhGG2ogADYCACAARQ0BCyAAIAs2AhgCQCAIKAIQIgNFDQAgACADNgIQIAMgADYCGAsgCEEUaigCACIDRQ0AIABBFGogAzYCACADIAA2AhgLAkACQCAEQQ9LDQAgCCAEIAJqIgNBA3I2AgQgCCADaiIDIAMoAgRBAXI2AgQMAQsgCCACaiIAIARBAXI2AgQgCCACQQNyNgIEIAAgBGogBDYCAAJAIARB/wFLDQAgBEF4cUGw0ICAAGohAwJAAkBBACgCiNCAgAAiBUEBIARBA3Z0IgRxDQBBACAFIARyNgKI0ICAACADIQQMAQsgAygCCCEECyAEIAA2AgwgAyAANgIIIAAgAzYCDCAAIAQ2AggMAQtBHyEDAkAgBEH///8HSw0AIARBCHYiAyADQYD+P2pBEHZBCHEiA3QiBSAFQYDgH2pBEHZBBHEiBXQiAiACQYCAD2pBEHZBAnEiAnRBD3YgAyAFciACcmsiA0EBdCAEIANBFWp2QQFxckEcaiEDCyAAIAM2AhwgAEIANwIQIANBAnRBuNKAgABqIQUCQCAHQQEgA3QiAnENACAFIAA2AgBBACAHIAJyNgKM0ICAACAAIAU2AhggACAANgIIIAAgADYCDAwBCyAEQQBBGSADQQF2ayADQR9GG3QhAyAFKAIAIQICQANAIAIiBSgCBEF4cSAERg0BIANBHXYhAiADQQF0IQMgBSACQQRxakEQaiIGKAIAIgINAAsgBiAANgIAIAAgBTYCGCAAIAA2AgwgACAANgIIDAELIAUoAggiAyAANgIMIAUgADYCCCAAQQA2AhggACAFNgIMIAAgAzYCCAsgCEEIaiEDDAELAkAgCkUNAAJAAkAgACAAKAIcIgVBAnRBuNKAgABqIgMoAgBHDQAgAyAINgIAIAgNAUEAIAlBfiAFd3E2AozQgIAADAILIApBEEEUIAooAhAgAEYbaiAINgIAIAhFDQELIAggCjYCGAJAIAAoAhAiA0UNACAIIAM2AhAgAyAINgIYCyAAQRRqKAIAIgNFDQAgCEEUaiADNgIAIAMgCDYCGAsCQAJAIARBD0sNACAAIAQgAmoiA0EDcjYCBCAAIANqIgMgAygCBEEBcjYCBAwBCyAAIAJqIgUgBEEBcjYCBCAAIAJBA3I2AgQgBSAEaiAENgIAAkAgB0UNACAHQXhxQbDQgIAAaiECQQAoApzQgIAAIQMCQAJAQQEgB0EDdnQiCCAGcQ0AQQAgCCAGcjYCiNCAgAAgAiEIDAELIAIoAgghCAsgCCADNgIMIAIgAzYCCCADIAI2AgwgAyAINgIIC0EAIAU2ApzQgIAAQQAgBDYCkNCAgAALIABBCGohAwsgAUEQaiSAgICAACADCwoAIAAQyYCAgAAL4g0BB38CQCAARQ0AIABBeGoiASAAQXxqKAIAIgJBeHEiAGohAwJAIAJBAXENACACQQNxRQ0BIAEgASgCACICayIBQQAoApjQgIAAIgRJDQEgAiAAaiEAAkAgAUEAKAKc0ICAAEYNAAJAIAJB/wFLDQAgASgCCCIEIAJBA3YiBUEDdEGw0ICAAGoiBkYaAkAgASgCDCICIARHDQBBAEEAKAKI0ICAAEF+IAV3cTYCiNCAgAAMAwsgAiAGRhogAiAENgIIIAQgAjYCDAwCCyABKAIYIQcCQAJAIAEoAgwiBiABRg0AIAEoAggiAiAESRogBiACNgIIIAIgBjYCDAwBCwJAIAFBFGoiAigCACIEDQAgAUEQaiICKAIAIgQNAEEAIQYMAQsDQCACIQUgBCIGQRRqIgIoAgAiBA0AIAZBEGohAiAGKAIQIgQNAAsgBUEANgIACyAHRQ0BAkACQCABIAEoAhwiBEECdEG40oCAAGoiAigCAEcNACACIAY2AgAgBg0BQQBBACgCjNCAgABBfiAEd3E2AozQgIAADAMLIAdBEEEUIAcoAhAgAUYbaiAGNgIAIAZFDQILIAYgBzYCGAJAIAEoAhAiAkUNACAGIAI2AhAgAiAGNgIYCyABKAIUIgJFDQEgBkEUaiACNgIAIAIgBjYCGAwBCyADKAIEIgJBA3FBA0cNACADIAJBfnE2AgRBACAANgKQ0ICAACABIABqIAA2AgAgASAAQQFyNgIEDwsgASADTw0AIAMoAgQiAkEBcUUNAAJAAkAgAkECcQ0AAkAgA0EAKAKg0ICAAEcNAEEAIAE2AqDQgIAAQQBBACgClNCAgAAgAGoiADYClNCAgAAgASAAQQFyNgIEIAFBACgCnNCAgABHDQNBAEEANgKQ0ICAAEEAQQA2ApzQgIAADwsCQCADQQAoApzQgIAARw0AQQAgATYCnNCAgABBAEEAKAKQ0ICAACAAaiIANgKQ0ICAACABIABBAXI2AgQgASAAaiAANgIADwsgAkF4cSAAaiEAAkACQCACQf8BSw0AIAMoAggiBCACQQN2IgVBA3RBsNCAgABqIgZGGgJAIAMoAgwiAiAERw0AQQBBACgCiNCAgABBfiAFd3E2AojQgIAADAILIAIgBkYaIAIgBDYCCCAEIAI2AgwMAQsgAygCGCEHAkACQCADKAIMIgYgA0YNACADKAIIIgJBACgCmNCAgABJGiAGIAI2AgggAiAGNgIMDAELAkAgA0EUaiICKAIAIgQNACADQRBqIgIoAgAiBA0AQQAhBgwBCwNAIAIhBSAEIgZBFGoiAigCACIEDQAgBkEQaiECIAYoAhAiBA0ACyAFQQA2AgALIAdFDQACQAJAIAMgAygCHCIEQQJ0QbjSgIAAaiICKAIARw0AIAIgBjYCACAGDQFBAEEAKAKM0ICAAEF+IAR3cTYCjNCAgAAMAgsgB0EQQRQgBygCECADRhtqIAY2AgAgBkUNAQsgBiAHNgIYAkAgAygCECICRQ0AIAYgAjYCECACIAY2AhgLIAMoAhQiAkUNACAGQRRqIAI2AgAgAiAGNgIYCyABIABqIAA2AgAgASAAQQFyNgIEIAFBACgCnNCAgABHDQFBACAANgKQ0ICAAA8LIAMgAkF+cTYCBCABIABqIAA2AgAgASAAQQFyNgIECwJAIABB/wFLDQAgAEF4cUGw0ICAAGohAgJAAkBBACgCiNCAgAAiBEEBIABBA3Z0IgBxDQBBACAEIAByNgKI0ICAACACIQAMAQsgAigCCCEACyAAIAE2AgwgAiABNgIIIAEgAjYCDCABIAA2AggPC0EfIQICQCAAQf///wdLDQAgAEEIdiICIAJBgP4/akEQdkEIcSICdCIEIARBgOAfakEQdkEEcSIEdCIGIAZBgIAPakEQdkECcSIGdEEPdiACIARyIAZyayICQQF0IAAgAkEVanZBAXFyQRxqIQILIAEgAjYCHCABQgA3AhAgAkECdEG40oCAAGohBAJAAkBBACgCjNCAgAAiBkEBIAJ0IgNxDQAgBCABNgIAQQAgBiADcjYCjNCAgAAgASAENgIYIAEgATYCCCABIAE2AgwMAQsgAEEAQRkgAkEBdmsgAkEfRht0IQIgBCgCACEGAkADQCAGIgQoAgRBeHEgAEYNASACQR12IQYgAkEBdCECIAQgBkEEcWpBEGoiAygCACIGDQALIAMgATYCACABIAQ2AhggASABNgIMIAEgATYCCAwBCyAEKAIIIgAgATYCDCAEIAE2AgggAUEANgIYIAEgBDYCDCABIAA2AggLQQBBACgCqNCAgABBf2oiAUF/IAEbNgKo0ICAAAsLBAAAAAtOAAJAIAANAD8AQRB0DwsCQCAAQf//A3ENACAAQX9MDQACQCAAQRB2QAAiAEF/Rw0AQQBBMDYC+NOAgABBfw8LIABBEHQPCxDKgICAAAAL8gICA38BfgJAIAJFDQAgACABOgAAIAIgAGoiA0F/aiABOgAAIAJBA0kNACAAIAE6AAIgACABOgABIANBfWogAToAACADQX5qIAE6AAAgAkEHSQ0AIAAgAToAAyADQXxqIAE6AAAgAkEJSQ0AIABBACAAa0EDcSIEaiIDIAFB/wFxQYGChAhsIgE2AgAgAyACIARrQXxxIgRqIgJBfGogATYCACAEQQlJDQAgAyABNgIIIAMgATYCBCACQXhqIAE2AgAgAkF0aiABNgIAIARBGUkNACADIAE2AhggAyABNgIUIAMgATYCECADIAE2AgwgAkFwaiABNgIAIAJBbGogATYCACACQWhqIAE2AgAgAkFkaiABNgIAIAQgA0EEcUEYciIFayICQSBJDQAgAa1CgYCAgBB+IQYgAyAFaiEBA0AgASAGNwMYIAEgBjcDECABIAY3AwggASAGNwMAIAFBIGohASACQWBqIgJBH0sNAAsLIAALC45IAQBBgAgLhkgBAAAAAgAAAAMAAAAAAAAAAAAAAAQAAAAFAAAAAAAAAAAAAAAGAAAABwAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEludmFsaWQgY2hhciBpbiB1cmwgcXVlcnkAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9ib2R5AENvbnRlbnQtTGVuZ3RoIG92ZXJmbG93AENodW5rIHNpemUgb3ZlcmZsb3cAUmVzcG9uc2Ugb3ZlcmZsb3cASW52YWxpZCBtZXRob2QgZm9yIEhUVFAveC54IHJlcXVlc3QASW52YWxpZCBtZXRob2QgZm9yIFJUU1AveC54IHJlcXVlc3QARXhwZWN0ZWQgU09VUkNFIG1ldGhvZCBmb3IgSUNFL3gueCByZXF1ZXN0AEludmFsaWQgY2hhciBpbiB1cmwgZnJhZ21lbnQgc3RhcnQARXhwZWN0ZWQgZG90AFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fc3RhdHVzAEludmFsaWQgcmVzcG9uc2Ugc3RhdHVzAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMAVXNlciBjYWxsYmFjayBlcnJvcgBgb25fcmVzZXRgIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19oZWFkZXJgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2JlZ2luYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlYCBjYWxsYmFjayBlcnJvcgBgb25fc3RhdHVzX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fdmVyc2lvbl9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3VybF9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25faGVhZGVyX3ZhbHVlX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fbWVzc2FnZV9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX21ldGhvZF9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX2hlYWRlcl9maWVsZF9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX2NodW5rX2V4dGVuc2lvbl9uYW1lYCBjYWxsYmFjayBlcnJvcgBVbmV4cGVjdGVkIGNoYXIgaW4gdXJsIHNlcnZlcgBJbnZhbGlkIGhlYWRlciB2YWx1ZSBjaGFyAEludmFsaWQgaGVhZGVyIGZpZWxkIGNoYXIAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl92ZXJzaW9uAEludmFsaWQgbWlub3IgdmVyc2lvbgBJbnZhbGlkIG1ham9yIHZlcnNpb24ARXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgdmVyc2lvbgBFeHBlY3RlZCBDUkxGIGFmdGVyIHZlcnNpb24ASW52YWxpZCBIVFRQIHZlcnNpb24ASW52YWxpZCBoZWFkZXIgdG9rZW4AU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl91cmwASW52YWxpZCBjaGFyYWN0ZXJzIGluIHVybABVbmV4cGVjdGVkIHN0YXJ0IGNoYXIgaW4gdXJsAERvdWJsZSBAIGluIHVybABFbXB0eSBDb250ZW50LUxlbmd0aABJbnZhbGlkIGNoYXJhY3RlciBpbiBDb250ZW50LUxlbmd0aABEdXBsaWNhdGUgQ29udGVudC1MZW5ndGgASW52YWxpZCBjaGFyIGluIHVybCBwYXRoAENvbnRlbnQtTGVuZ3RoIGNhbid0IGJlIHByZXNlbnQgd2l0aCBUcmFuc2Zlci1FbmNvZGluZwBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBzaXplAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25faGVhZGVyX3ZhbHVlAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgdmFsdWUATWlzc2luZyBleHBlY3RlZCBMRiBhZnRlciBoZWFkZXIgdmFsdWUASW52YWxpZCBgVHJhbnNmZXItRW5jb2RpbmdgIGhlYWRlciB2YWx1ZQBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIHF1b3RlIHZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGVkIHZhbHVlAFBhdXNlZCBieSBvbl9oZWFkZXJzX2NvbXBsZXRlAEludmFsaWQgRU9GIHN0YXRlAG9uX3Jlc2V0IHBhdXNlAG9uX2NodW5rX2hlYWRlciBwYXVzZQBvbl9tZXNzYWdlX2JlZ2luIHBhdXNlAG9uX2NodW5rX2V4dGVuc2lvbl92YWx1ZSBwYXVzZQBvbl9zdGF0dXNfY29tcGxldGUgcGF1c2UAb25fdmVyc2lvbl9jb21wbGV0ZSBwYXVzZQBvbl91cmxfY29tcGxldGUgcGF1c2UAb25fY2h1bmtfY29tcGxldGUgcGF1c2UAb25faGVhZGVyX3ZhbHVlX2NvbXBsZXRlIHBhdXNlAG9uX21lc3NhZ2VfY29tcGxldGUgcGF1c2UAb25fbWV0aG9kX2NvbXBsZXRlIHBhdXNlAG9uX2hlYWRlcl9maWVsZF9jb21wbGV0ZSBwYXVzZQBvbl9jaHVua19leHRlbnNpb25fbmFtZSBwYXVzZQBVbmV4cGVjdGVkIHNwYWNlIGFmdGVyIHN0YXJ0IGxpbmUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9jaHVua19leHRlbnNpb25fbmFtZQBJbnZhbGlkIGNoYXJhY3RlciBpbiBjaHVuayBleHRlbnNpb25zIG5hbWUAUGF1c2Ugb24gQ09OTkVDVC9VcGdyYWRlAFBhdXNlIG9uIFBSSS9VcGdyYWRlAEV4cGVjdGVkIEhUVFAvMiBDb25uZWN0aW9uIFByZWZhY2UAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9tZXRob2QARXhwZWN0ZWQgc3BhY2UgYWZ0ZXIgbWV0aG9kAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25faGVhZGVyX2ZpZWxkAFBhdXNlZABJbnZhbGlkIHdvcmQgZW5jb3VudGVyZWQASW52YWxpZCBtZXRob2QgZW5jb3VudGVyZWQAVW5leHBlY3RlZCBjaGFyIGluIHVybCBzY2hlbWEAUmVxdWVzdCBoYXMgaW52YWxpZCBgVHJhbnNmZXItRW5jb2RpbmdgAFNXSVRDSF9QUk9YWQBVU0VfUFJPWFkATUtBQ1RJVklUWQBVTlBST0NFU1NBQkxFX0VOVElUWQBDT1BZAE1PVkVEX1BFUk1BTkVOVExZAFRPT19FQVJMWQBOT1RJRlkARkFJTEVEX0RFUEVOREVOQ1kAQkFEX0dBVEVXQVkAUExBWQBQVVQAQ0hFQ0tPVVQAR0FURVdBWV9USU1FT1VUAFJFUVVFU1RfVElNRU9VVABORVRXT1JLX0NPTk5FQ1RfVElNRU9VVABDT05ORUNUSU9OX1RJTUVPVVQATE9HSU5fVElNRU9VVABORVRXT1JLX1JFQURfVElNRU9VVABQT1NUAE1JU0RJUkVDVEVEX1JFUVVFU1QAQ0xJRU5UX0NMT1NFRF9SRVFVRVNUAENMSUVOVF9DTE9TRURfTE9BRF9CQUxBTkNFRF9SRVFVRVNUAEJBRF9SRVFVRVNUAEhUVFBfUkVRVUVTVF9TRU5UX1RPX0hUVFBTX1BPUlQAUkVQT1JUAElNX0FfVEVBUE9UAFJFU0VUX0NPTlRFTlQATk9fQ09OVEVOVABQQVJUSUFMX0NPTlRFTlQASFBFX0lOVkFMSURfQ09OU1RBTlQASFBFX0NCX1JFU0VUAEdFVABIUEVfU1RSSUNUAENPTkZMSUNUAFRFTVBPUkFSWV9SRURJUkVDVABQRVJNQU5FTlRfUkVESVJFQ1QAQ09OTkVDVABNVUxUSV9TVEFUVVMASFBFX0lOVkFMSURfU1RBVFVTAFRPT19NQU5ZX1JFUVVFU1RTAEVBUkxZX0hJTlRTAFVOQVZBSUxBQkxFX0ZPUl9MRUdBTF9SRUFTT05TAE9QVElPTlMAU1dJVENISU5HX1BST1RPQ09MUwBWQVJJQU5UX0FMU09fTkVHT1RJQVRFUwBNVUxUSVBMRV9DSE9JQ0VTAElOVEVSTkFMX1NFUlZFUl9FUlJPUgBXRUJfU0VSVkVSX1VOS05PV05fRVJST1IAUkFJTEdVTl9FUlJPUgBJREVOVElUWV9QUk9WSURFUl9BVVRIRU5USUNBVElPTl9FUlJPUgBTU0xfQ0VSVElGSUNBVEVfRVJST1IASU5WQUxJRF9YX0ZPUldBUkRFRF9GT1IAU0VUX1BBUkFNRVRFUgBHRVRfUEFSQU1FVEVSAEhQRV9VU0VSAFNFRV9PVEhFUgBIUEVfQ0JfQ0hVTktfSEVBREVSAE1LQ0FMRU5EQVIAU0VUVVAAV0VCX1NFUlZFUl9JU19ET1dOAFRFQVJET1dOAEhQRV9DTE9TRURfQ09OTkVDVElPTgBIRVVSSVNUSUNfRVhQSVJBVElPTgBESVNDT05ORUNURURfT1BFUkFUSU9OAE5PTl9BVVRIT1JJVEFUSVZFX0lORk9STUFUSU9OAEhQRV9JTlZBTElEX1ZFUlNJT04ASFBFX0NCX01FU1NBR0VfQkVHSU4AU0lURV9JU19GUk9aRU4ASFBFX0lOVkFMSURfSEVBREVSX1RPS0VOAElOVkFMSURfVE9LRU4ARk9SQklEREVOAEVOSEFOQ0VfWU9VUl9DQUxNAEhQRV9JTlZBTElEX1VSTABCTE9DS0VEX0JZX1BBUkVOVEFMX0NPTlRST0wATUtDT0wAQUNMAEhQRV9JTlRFUk5BTABSRVFVRVNUX0hFQURFUl9GSUVMRFNfVE9PX0xBUkdFX1VOT0ZGSUNJQUwASFBFX09LAFVOTElOSwBVTkxPQ0sAUFJJAFJFVFJZX1dJVEgASFBFX0lOVkFMSURfQ09OVEVOVF9MRU5HVEgASFBFX1VORVhQRUNURURfQ09OVEVOVF9MRU5HVEgARkxVU0gAUFJPUFBBVENIAE0tU0VBUkNIAFVSSV9UT09fTE9ORwBQUk9DRVNTSU5HAE1JU0NFTExBTkVPVVNfUEVSU0lTVEVOVF9XQVJOSU5HAE1JU0NFTExBTkVPVVNfV0FSTklORwBIUEVfSU5WQUxJRF9UUkFOU0ZFUl9FTkNPRElORwBFeHBlY3RlZCBDUkxGAEhQRV9JTlZBTElEX0NIVU5LX1NJWkUATU9WRQBDT05USU5VRQBIUEVfQ0JfU1RBVFVTX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJTX0NPTVBMRVRFAEhQRV9DQl9WRVJTSU9OX0NPTVBMRVRFAEhQRV9DQl9VUkxfQ09NUExFVEUASFBFX0NCX0NIVU5LX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJfVkFMVUVfQ09NUExFVEUASFBFX0NCX0NIVU5LX0VYVEVOU0lPTl9WQUxVRV9DT01QTEVURQBIUEVfQ0JfQ0hVTktfRVhURU5TSU9OX05BTUVfQ09NUExFVEUASFBFX0NCX01FU1NBR0VfQ09NUExFVEUASFBFX0NCX01FVEhPRF9DT01QTEVURQBIUEVfQ0JfSEVBREVSX0ZJRUxEX0NPTVBMRVRFAERFTEVURQBIUEVfSU5WQUxJRF9FT0ZfU1RBVEUASU5WQUxJRF9TU0xfQ0VSVElGSUNBVEUAUEFVU0UATk9fUkVTUE9OU0UAVU5TVVBQT1JURURfTUVESUFfVFlQRQBHT05FAE5PVF9BQ0NFUFRBQkxFAFNFUlZJQ0VfVU5BVkFJTEFCTEUAUkFOR0VfTk9UX1NBVElTRklBQkxFAE9SSUdJTl9JU19VTlJFQUNIQUJMRQBSRVNQT05TRV9JU19TVEFMRQBQVVJHRQBNRVJHRQBSRVFVRVNUX0hFQURFUl9GSUVMRFNfVE9PX0xBUkdFAFJFUVVFU1RfSEVBREVSX1RPT19MQVJHRQBQQVlMT0FEX1RPT19MQVJHRQBJTlNVRkZJQ0lFTlRfU1RPUkFHRQBIUEVfUEFVU0VEX1VQR1JBREUASFBFX1BBVVNFRF9IMl9VUEdSQURFAFNPVVJDRQBBTk5PVU5DRQBUUkFDRQBIUEVfVU5FWFBFQ1RFRF9TUEFDRQBERVNDUklCRQBVTlNVQlNDUklCRQBSRUNPUkQASFBFX0lOVkFMSURfTUVUSE9EAE5PVF9GT1VORABQUk9QRklORABVTkJJTkQAUkVCSU5EAFVOQVVUSE9SSVpFRABNRVRIT0RfTk9UX0FMTE9XRUQASFRUUF9WRVJTSU9OX05PVF9TVVBQT1JURUQAQUxSRUFEWV9SRVBPUlRFRABBQ0NFUFRFRABOT1RfSU1QTEVNRU5URUQATE9PUF9ERVRFQ1RFRABIUEVfQ1JfRVhQRUNURUQASFBFX0xGX0VYUEVDVEVEAENSRUFURUQASU1fVVNFRABIUEVfUEFVU0VEAFRJTUVPVVRfT0NDVVJFRABQQVlNRU5UX1JFUVVJUkVEAFBSRUNPTkRJVElPTl9SRVFVSVJFRABQUk9YWV9BVVRIRU5USUNBVElPTl9SRVFVSVJFRABORVRXT1JLX0FVVEhFTlRJQ0FUSU9OX1JFUVVJUkVEAExFTkdUSF9SRVFVSVJFRABTU0xfQ0VSVElGSUNBVEVfUkVRVUlSRUQAVVBHUkFERV9SRVFVSVJFRABQQUdFX0VYUElSRUQAUFJFQ09ORElUSU9OX0ZBSUxFRABFWFBFQ1RBVElPTl9GQUlMRUQAUkVWQUxJREFUSU9OX0ZBSUxFRABTU0xfSEFORFNIQUtFX0ZBSUxFRABMT0NLRUQAVFJBTlNGT1JNQVRJT05fQVBQTElFRABOT1RfTU9ESUZJRUQATk9UX0VYVEVOREVEAEJBTkRXSURUSF9MSU1JVF9FWENFRURFRABTSVRFX0lTX09WRVJMT0FERUQASEVBRABFeHBlY3RlZCBIVFRQLwAAXhMAACYTAAAwEAAA8BcAAJ0TAAAVEgAAORcAAPASAAAKEAAAdRIAAK0SAACCEwAATxQAAH8QAACgFQAAIxQAAIkSAACLFAAATRUAANQRAADPFAAAEBgAAMkWAADcFgAAwREAAOAXAAC7FAAAdBQAAHwVAADlFAAACBcAAB8QAABlFQAAoxQAACgVAAACFQAAmRUAACwQAACLGQAATw8AANQOAABqEAAAzhAAAAIXAACJDgAAbhMAABwTAABmFAAAVhcAAMETAADNEwAAbBMAAGgXAABmFwAAXxcAACITAADODwAAaQ4AANgOAABjFgAAyxMAAKoOAAAoFwAAJhcAAMUTAABdFgAA6BEAAGcTAABlEwAA8hYAAHMTAAAdFwAA+RYAAPMRAADPDgAAzhUAAAwSAACzEQAApREAAGEQAAAyFwAAuxMAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAIDAgICAgIAAAICAAICAAICAgICAgICAgIABAAAAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgACAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAICAgICAAACAgACAgACAgICAgICAgICAAMABAAAAAICAgICAgICAgICAgICAgICAgICAgICAgICAAAAAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAAgACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbG9zZWVlcC1hbGl2ZQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAQEBAQIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBY2h1bmtlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAQEBAQEAAAEBAAEBAAEBAQEBAQEBAQEAAAAAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlY3Rpb25lbnQtbGVuZ3Rob25yb3h5LWNvbm5lY3Rpb24AAAAAAAAAAAAAAAAAAAByYW5zZmVyLWVuY29kaW5ncGdyYWRlDQoNCg0KU00NCg0KVFRQL0NFL1RTUC8AAAAAAAAAAAAAAAABAgABAwAAAAAAAAAAAAAAAAAAAAAAAAQBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAQIAAQMAAAAAAAAAAAAAAAAAAAAAAAAEAQEFAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAEAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAQAAAgAAAAAAAAAAAAAAAAAAAAAAAAMEAAAEBAQEBAQEBAQEBAUEBAQEBAQEBAQEBAQABAAGBwQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAEAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAABAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAIAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOT1VOQ0VFQ0tPVVRORUNURVRFQ1JJQkVMVVNIRVRFQURTRUFSQ0hSR0VDVElWSVRZTEVOREFSVkVPVElGWVBUSU9OU0NIU0VBWVNUQVRDSEdFT1JESVJFQ1RPUlRSQ0hQQVJBTUVURVJVUkNFQlNDUklCRUFSRE9XTkFDRUlORE5LQ0tVQlNDUklCRUhUVFAvQURUUC8="; + } +}); + +// node_modules/undici/lib/llhttp/llhttp_simd-wasm.js +var require_llhttp_simd_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { + module2.exports = "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"; + } +}); + +// node_modules/undici/lib/client.js +var require_client = __commonJS({ + "node_modules/undici/lib/client.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var net = require("net"); + var http = require("http"); + var { pipeline } = require("stream"); + var util = require_util(); + var timers = require_timers(); + var Request = require_request(); + var DispatcherBase = require_dispatcher_base(); + var { + RequestContentLengthMismatchError, + ResponseContentLengthMismatchError, + InvalidArgumentError, + RequestAbortedError, + HeadersTimeoutError, + HeadersOverflowError, + SocketError, + InformationalError, + BodyTimeoutError, + HTTPParserError, + ResponseExceededMaxSizeError, + ClientDestroyedError + } = require_errors(); + var buildConnector = require_connect(); + var { + kUrl, + kReset, + kServerName, + kClient, + kBusy, + kParser, + kConnect, + kBlocking, + kResuming, + kRunning, + kPending, + kSize, + kWriting, + kQueue, + kConnected, + kConnecting, + kNeedDrain, + kNoRef, + kKeepAliveDefaultTimeout, + kHostHeader, + kPendingIdx, + kRunningIdx, + kError, + kPipelining, + kSocket, + kKeepAliveTimeoutValue, + kMaxHeadersSize, + kKeepAliveMaxTimeout, + kKeepAliveTimeoutThreshold, + kHeadersTimeout, + kBodyTimeout, + kStrictContentLength, + kConnector, + kMaxRedirections, + kMaxRequests, + kCounter, + kClose, + kDestroy, + kDispatch, + kInterceptors, + kLocalAddress, + kMaxResponseSize, + kHTTPConnVersion, + // HTTP2 + kHost, + kHTTP2Session, + kHTTP2SessionState, + kHTTP2BuildRequest, + kHTTP2CopyHeaders, + kHTTP1BuildRequest + } = require_symbols(); + var http2; + try { + http2 = require("http2"); + } catch { + http2 = { constants: {} }; + } + var { + constants: { + HTTP2_HEADER_AUTHORITY, + HTTP2_HEADER_METHOD, + HTTP2_HEADER_PATH, + HTTP2_HEADER_SCHEME, + HTTP2_HEADER_CONTENT_LENGTH, + HTTP2_HEADER_EXPECT, + HTTP2_HEADER_STATUS + } + } = http2; + var h2ExperimentalWarned = false; + var FastBuffer = Buffer[Symbol.species]; + var kClosedResolve = Symbol("kClosedResolve"); + var channels = {}; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders"); + channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect"); + channels.connectError = diagnosticsChannel.channel("undici:client:connectError"); + channels.connected = diagnosticsChannel.channel("undici:client:connected"); + } catch { + channels.sendHeaders = { hasSubscribers: false }; + channels.beforeConnect = { hasSubscribers: false }; + channels.connectError = { hasSubscribers: false }; + channels.connected = { hasSubscribers: false }; + } + var Client = class extends DispatcherBase { + /** + * + * @param {string|URL} url + * @param {import('../types/client').Client.Options} options + */ + constructor(url, { + interceptors, + maxHeaderSize, + headersTimeout, + socketTimeout, + requestTimeout, + connectTimeout, + bodyTimeout, + idleTimeout, + keepAlive, + keepAliveTimeout, + maxKeepAliveTimeout, + keepAliveMaxTimeout, + keepAliveTimeoutThreshold, + socketPath, + pipelining, + tls, + strictContentLength, + maxCachedSessions, + maxRedirections, + connect: connect2, + maxRequestsPerClient, + localAddress, + maxResponseSize, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + // h2 + allowH2, + maxConcurrentStreams + } = {}) { + super(); + if (keepAlive !== void 0) { + throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead"); + } + if (socketTimeout !== void 0) { + throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead"); + } + if (requestTimeout !== void 0) { + throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead"); + } + if (idleTimeout !== void 0) { + throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead"); + } + if (maxKeepAliveTimeout !== void 0) { + throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead"); + } + if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) { + throw new InvalidArgumentError("invalid maxHeaderSize"); + } + if (socketPath != null && typeof socketPath !== "string") { + throw new InvalidArgumentError("invalid socketPath"); + } + if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) { + throw new InvalidArgumentError("invalid connectTimeout"); + } + if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveTimeout"); + } + if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveMaxTimeout"); + } + if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) { + throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold"); + } + if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("headersTimeout must be a positive integer or zero"); + } + if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero"); + } + if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) { + throw new InvalidArgumentError("maxRequestsPerClient must be a positive number"); + } + if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) { + throw new InvalidArgumentError("localAddress must be valid string IP address"); + } + if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) { + throw new InvalidArgumentError("maxResponseSize must be a positive number"); + } + if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) { + throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number"); + } + if (allowH2 != null && typeof allowH2 !== "boolean") { + throw new InvalidArgumentError("allowH2 must be a valid boolean value"); + } + if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) { + throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0"); + } + if (typeof connect2 !== "function") { + connect2 = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect2 + }); + } + this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })]; + this[kUrl] = util.parseOrigin(url); + this[kConnector] = connect2; + this[kSocket] = null; + this[kPipelining] = pipelining != null ? pipelining : 1; + this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize; + this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout; + this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout; + this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold; + this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]; + this[kServerName] = null; + this[kLocalAddress] = localAddress != null ? localAddress : null; + this[kResuming] = 0; + this[kNeedDrain] = 0; + this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r +`; + this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5; + this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5; + this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength; + this[kMaxRedirections] = maxRedirections; + this[kMaxRequests] = maxRequestsPerClient; + this[kClosedResolve] = null; + this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1; + this[kHTTPConnVersion] = "h1"; + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = !allowH2 ? null : { + // streams: null, // Fixed queue of streams - For future support of `push` + openStreams: 0, + // Keep track of them to decide wether or not unref the session + maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100 + // Max peerConcurrentStreams for a Node h2 server + }; + this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`; + this[kQueue] = []; + this[kRunningIdx] = 0; + this[kPendingIdx] = 0; + } + get pipelining() { + return this[kPipelining]; + } + set pipelining(value) { + this[kPipelining] = value; + resume(this, true); + } + get [kPending]() { + return this[kQueue].length - this[kPendingIdx]; + } + get [kRunning]() { + return this[kPendingIdx] - this[kRunningIdx]; + } + get [kSize]() { + return this[kQueue].length - this[kRunningIdx]; + } + get [kConnected]() { + return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed; + } + get [kBusy]() { + const socket = this[kSocket]; + return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0; + } + /* istanbul ignore: only used for test */ + [kConnect](cb) { + connect(this); + this.once("connect", cb); + } + [kDispatch](opts, handler) { + const origin = opts.origin || this[kUrl].origin; + const request = this[kHTTPConnVersion] === "h2" ? Request[kHTTP2BuildRequest](origin, opts, handler) : Request[kHTTP1BuildRequest](origin, opts, handler); + this[kQueue].push(request); + if (this[kResuming]) { + } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) { + this[kResuming] = 1; + process.nextTick(resume, this); + } else { + resume(this, true); + } + if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) { + this[kNeedDrain] = 2; + } + return this[kNeedDrain] < 2; + } + async [kClose]() { + return new Promise((resolve) => { + if (!this[kSize]) { + resolve(null); + } else { + this[kClosedResolve] = resolve; + } + }); + } + async [kDestroy](err) { + return new Promise((resolve) => { + const requests = this[kQueue].splice(this[kPendingIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + const callback = () => { + if (this[kClosedResolve]) { + this[kClosedResolve](); + this[kClosedResolve] = null; + } + resolve(); + }; + if (this[kHTTP2Session] != null) { + util.destroy(this[kHTTP2Session], err); + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = null; + } + if (!this[kSocket]) { + queueMicrotask(callback); + } else { + util.destroy(this[kSocket].on("close", callback), err); + } + resume(this); + }); + } + }; + function onHttp2SessionError(err) { + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kSocket][kError] = err; + onError(this[kClient], err); + } + function onHttp2FrameError(type, code, id) { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + if (id === 0) { + this[kSocket][kError] = err; + onError(this[kClient], err); + } + } + function onHttp2SessionEnd() { + util.destroy(this, new SocketError("other side closed")); + util.destroy(this[kSocket], new SocketError("other side closed")); + } + function onHTTP2GoAway(code) { + const client = this[kClient]; + const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`); + client[kSocket] = null; + client[kHTTP2Session] = null; + if (client.destroyed) { + assert(this[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + } else if (client[kRunning] > 0) { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit( + "disconnect", + client[kUrl], + [client], + err + ); + resume(client); + } + var constants = require_constants3(); + var createRedirectInterceptor = require_redirectInterceptor(); + var EMPTY_BUF = Buffer.alloc(0); + async function lazyllhttp() { + const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0; + let mod; + try { + mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64")); + } catch (e) { + mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64")); + } + return await WebAssembly.instantiate(mod, { + env: { + /* eslint-disable camelcase */ + wasm_on_url: (p, at, len) => { + return 0; + }, + wasm_on_status: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_begin: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageBegin() || 0; + }, + wasm_on_header_field: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_header_value: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; + }, + wasm_on_body: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_complete: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageComplete() || 0; + } + /* eslint-enable camelcase */ + } + }); + } + var llhttpInstance = null; + var llhttpPromise = lazyllhttp(); + llhttpPromise.catch(); + var currentParser = null; + var currentBufferRef = null; + var currentBufferSize = 0; + var currentBufferPtr = null; + var TIMEOUT_HEADERS = 1; + var TIMEOUT_BODY = 2; + var TIMEOUT_IDLE = 3; + var Parser = class { + constructor(client, socket, { exports: exports3 }) { + assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); + this.llhttp = exports3; + this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE); + this.client = client; + this.socket = socket; + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.statusCode = null; + this.statusText = ""; + this.upgrade = false; + this.headers = []; + this.headersSize = 0; + this.headersMaxSize = client[kMaxHeadersSize]; + this.shouldKeepAlive = false; + this.paused = false; + this.resume = this.resume.bind(this); + this.bytesRead = 0; + this.keepAlive = ""; + this.contentLength = ""; + this.connection = ""; + this.maxResponseSize = client[kMaxResponseSize]; + } + setTimeout(value, type) { + this.timeoutType = type; + if (value !== this.timeoutValue) { + timers.clearTimeout(this.timeout); + if (value) { + this.timeout = timers.setTimeout(onParserTimeout, value, this); + if (this.timeout.unref) { + this.timeout.unref(); + } + } else { + this.timeout = null; + } + this.timeoutValue = value; + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + } + resume() { + if (this.socket.destroyed || !this.paused) { + return; + } + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_resume(this.ptr); + assert(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + this.paused = false; + this.execute(this.socket.read() || EMPTY_BUF); + this.readMore(); + } + readMore() { + while (!this.paused && this.ptr) { + const chunk = this.socket.read(); + if (chunk === null) { + break; + } + this.execute(chunk); + } + } + execute(data) { + assert(this.ptr != null); + assert(currentParser == null); + assert(!this.paused); + const { socket, llhttp } = this; + if (data.length > currentBufferSize) { + if (currentBufferPtr) { + llhttp.free(currentBufferPtr); + } + currentBufferSize = Math.ceil(data.length / 4096) * 4096; + currentBufferPtr = llhttp.malloc(currentBufferSize); + } + new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data); + try { + let ret; + try { + currentBufferRef = data; + currentParser = this; + ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length); + } catch (err) { + throw err; + } finally { + currentParser = null; + currentBufferRef = null; + } + const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; + if (ret === constants.ERROR.PAUSED_UPGRADE) { + this.onUpgrade(data.slice(offset)); + } else if (ret === constants.ERROR.PAUSED) { + this.paused = true; + socket.unshift(data.slice(offset)); + } else if (ret !== constants.ERROR.OK) { + const ptr = llhttp.llhttp_get_error_reason(this.ptr); + let message = ""; + if (ptr) { + const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); + message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; + } + throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)); + } + } catch (err) { + util.destroy(socket, err); + } + } + destroy() { + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_free(this.ptr); + this.ptr = null; + timers.clearTimeout(this.timeout); + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.paused = false; + } + onStatus(buf) { + this.statusText = buf.toString(); + } + onMessageBegin() { + const { socket, client } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + } + onHeaderField(buf) { + const len = this.headers.length; + if ((len & 1) === 0) { + this.headers.push(buf); + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + } + this.trackHeader(buf.length); + } + onHeaderValue(buf) { + let len = this.headers.length; + if ((len & 1) === 1) { + this.headers.push(buf); + len += 1; + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + } + const key = this.headers[len - 2]; + if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") { + this.keepAlive += buf.toString(); + } else if (key.length === 10 && key.toString().toLowerCase() === "connection") { + this.connection += buf.toString(); + } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") { + this.contentLength += buf.toString(); + } + this.trackHeader(buf.length); + } + trackHeader(len) { + this.headersSize += len; + if (this.headersSize >= this.headersMaxSize) { + util.destroy(this.socket, new HeadersOverflowError()); + } + } + onUpgrade(head) { + const { upgrade, client, socket, headers, statusCode } = this; + assert(upgrade); + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(!socket.destroyed); + assert(socket === client[kSocket]); + assert(!this.paused); + assert(request.upgrade || request.method === "CONNECT"); + this.statusCode = null; + this.statusText = ""; + this.shouldKeepAlive = null; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + socket.unshift(head); + socket[kParser].destroy(); + socket[kParser] = null; + socket[kClient] = null; + socket[kError] = null; + socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose); + client[kSocket] = null; + client[kQueue][client[kRunningIdx]++] = null; + client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); + try { + request.onUpgrade(statusCode, headers, socket); + } catch (err) { + util.destroy(socket, err); + } + resume(client); + } + onHeadersComplete(statusCode, upgrade, shouldKeepAlive) { + const { client, socket, headers, statusText } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + assert(!this.upgrade); + assert(this.statusCode < 200); + if (statusCode === 100) { + util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket))); + return -1; + } + if (upgrade && !request.upgrade) { + util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket))); + return -1; + } + assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS); + this.statusCode = statusCode; + this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. + request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; + if (this.statusCode >= 200) { + const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]; + this.setTimeout(bodyTimeout, TIMEOUT_BODY); + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + if (request.method === "CONNECT") { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + if (upgrade) { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (this.shouldKeepAlive && client[kPipelining]) { + const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null; + if (keepAliveTimeout != null) { + const timeout = Math.min( + keepAliveTimeout - client[kKeepAliveTimeoutThreshold], + client[kKeepAliveMaxTimeout] + ); + if (timeout <= 0) { + socket[kReset] = true; + } else { + client[kKeepAliveTimeoutValue] = timeout; + } + } else { + client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]; + } + } else { + socket[kReset] = true; + } + const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false; + if (request.aborted) { + return -1; + } + if (request.method === "HEAD") { + return 1; + } + if (statusCode < 200) { + return 1; + } + if (socket[kBlocking]) { + socket[kBlocking] = false; + resume(client); + } + return pause ? constants.ERROR.PAUSED : 0; + } + onBody(buf) { + const { client, socket, statusCode, maxResponseSize } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert.strictEqual(this.timeoutType, TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + assert(statusCode >= 200); + if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) { + util.destroy(socket, new ResponseExceededMaxSizeError()); + return -1; + } + this.bytesRead += buf.length; + if (request.onData(buf) === false) { + return constants.ERROR.PAUSED; + } + } + onMessageComplete() { + const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this; + if (socket.destroyed && (!statusCode || shouldKeepAlive)) { + return -1; + } + if (upgrade) { + return; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(statusCode >= 100); + this.statusCode = null; + this.statusText = ""; + this.bytesRead = 0; + this.contentLength = ""; + this.keepAlive = ""; + this.connection = ""; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (statusCode < 200) { + return; + } + if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) { + util.destroy(socket, new ResponseContentLengthMismatchError()); + return -1; + } + request.onComplete(headers); + client[kQueue][client[kRunningIdx]++] = null; + if (socket[kWriting]) { + assert.strictEqual(client[kRunning], 0); + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (!shouldKeepAlive) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (socket[kReset] && client[kRunning] === 0) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (client[kPipelining] === 1) { + setImmediate(resume, client); + } else { + resume(client); + } + } + }; + function onParserTimeout(parser) { + const { socket, timeoutType, client } = parser; + if (timeoutType === TIMEOUT_HEADERS) { + if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { + assert(!parser.paused, "cannot be paused while waiting for headers"); + util.destroy(socket, new HeadersTimeoutError()); + } + } else if (timeoutType === TIMEOUT_BODY) { + if (!parser.paused) { + util.destroy(socket, new BodyTimeoutError()); + } + } else if (timeoutType === TIMEOUT_IDLE) { + assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); + util.destroy(socket, new InformationalError("socket idle timeout")); + } + } + function onSocketReadable() { + const { [kParser]: parser } = this; + if (parser) { + parser.readMore(); + } + } + function onSocketError(err) { + const { [kClient]: client, [kParser]: parser } = this; + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + if (client[kHTTPConnVersion] !== "h2") { + if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + this[kError] = err; + onError(this[kClient], err); + } + function onError(client, err) { + if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") { + assert(client[kPendingIdx] === client[kRunningIdx]); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + assert(client[kSize] === 0); + } + } + function onSocketEnd() { + const { [kParser]: parser, [kClient]: client } = this; + if (client[kHTTPConnVersion] !== "h2") { + if (parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this))); + } + function onSocketClose() { + const { [kClient]: client, [kParser]: parser } = this; + if (client[kHTTPConnVersion] === "h1" && parser) { + if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + } + this[kParser].destroy(); + this[kParser] = null; + } + const err = this[kError] || new SocketError("closed", util.getSocketInfo(this)); + client[kSocket] = null; + if (client.destroyed) { + assert(client[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + resume(client); + } + async function connect(client) { + assert(!client[kConnecting]); + assert(!client[kSocket]); + let { host, hostname, protocol, port } = client[kUrl]; + if (hostname[0] === "[") { + const idx = hostname.indexOf("]"); + assert(idx !== -1); + const ip = hostname.substring(1, idx); + assert(net.isIP(ip)); + hostname = ip; + } + client[kConnecting] = true; + if (channels.beforeConnect.hasSubscribers) { + channels.beforeConnect.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector] + }); + } + try { + const socket = await new Promise((resolve, reject) => { + client[kConnector]({ + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, (err, socket2) => { + if (err) { + reject(err); + } else { + resolve(socket2); + } + }); + }); + if (client.destroyed) { + util.destroy(socket.on("error", () => { + }), new ClientDestroyedError()); + return; + } + client[kConnecting] = false; + assert(socket); + const isH2 = socket.alpnProtocol === "h2"; + if (isH2) { + if (!h2ExperimentalWarned) { + h2ExperimentalWarned = true; + process.emitWarning("H2 support is experimental, expect them to change at any time.", { + code: "UNDICI-H2" + }); + } + const session = http2.connect(client[kUrl], { + createConnection: () => socket, + peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams + }); + client[kHTTPConnVersion] = "h2"; + session[kClient] = client; + session[kSocket] = socket; + session.on("error", onHttp2SessionError); + session.on("frameError", onHttp2FrameError); + session.on("end", onHttp2SessionEnd); + session.on("goaway", onHTTP2GoAway); + session.on("close", onSocketClose); + session.unref(); + client[kHTTP2Session] = session; + socket[kHTTP2Session] = session; + } else { + if (!llhttpInstance) { + llhttpInstance = await llhttpPromise; + llhttpPromise = null; + } + socket[kNoRef] = false; + socket[kWriting] = false; + socket[kReset] = false; + socket[kBlocking] = false; + socket[kParser] = new Parser(client, socket, llhttpInstance); + } + socket[kCounter] = 0; + socket[kMaxRequests] = client[kMaxRequests]; + socket[kClient] = client; + socket[kError] = null; + socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose); + client[kSocket] = socket; + if (channels.connected.hasSubscribers) { + channels.connected.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + socket + }); + } + client.emit("connect", client[kUrl], [client]); + } catch (err) { + if (client.destroyed) { + return; + } + client[kConnecting] = false; + if (channels.connectError.hasSubscribers) { + channels.connectError.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + error: err + }); + } + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { + assert(client[kRunning] === 0); + while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { + const request = client[kQueue][client[kPendingIdx]++]; + errorRequest(client, request, err); + } + } else { + onError(client, err); + } + client.emit("connectionError", client[kUrl], [client], err); + } + resume(client); + } + function emitDrain(client) { + client[kNeedDrain] = 0; + client.emit("drain", client[kUrl], [client]); + } + function resume(client, sync) { + if (client[kResuming] === 2) { + return; + } + client[kResuming] = 2; + _resume(client, sync); + client[kResuming] = 0; + if (client[kRunningIdx] > 256) { + client[kQueue].splice(0, client[kRunningIdx]); + client[kPendingIdx] -= client[kRunningIdx]; + client[kRunningIdx] = 0; + } + } + function _resume(client, sync) { + while (true) { + if (client.destroyed) { + assert(client[kPending] === 0); + return; + } + if (client[kClosedResolve] && !client[kSize]) { + client[kClosedResolve](); + client[kClosedResolve] = null; + return; + } + const socket = client[kSocket]; + if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") { + if (client[kSize] === 0) { + if (!socket[kNoRef] && socket.unref) { + socket.unref(); + socket[kNoRef] = true; + } + } else if (socket[kNoRef] && socket.ref) { + socket.ref(); + socket[kNoRef] = false; + } + if (client[kSize] === 0) { + if (socket[kParser].timeoutType !== TIMEOUT_IDLE) { + socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE); + } + } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) { + if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) { + const request2 = client[kQueue][client[kRunningIdx]]; + const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout]; + socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS); + } + } + } + if (client[kBusy]) { + client[kNeedDrain] = 2; + } else if (client[kNeedDrain] === 2) { + if (sync) { + client[kNeedDrain] = 1; + process.nextTick(emitDrain, client); + } else { + emitDrain(client); + } + continue; + } + if (client[kPending] === 0) { + return; + } + if (client[kRunning] >= (client[kPipelining] || 1)) { + return; + } + const request = client[kQueue][client[kPendingIdx]]; + if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) { + if (client[kRunning] > 0) { + return; + } + client[kServerName] = request.servername; + if (socket && socket.servername !== request.servername) { + util.destroy(socket, new InformationalError("servername changed")); + return; + } + } + if (client[kConnecting]) { + return; + } + if (!socket && !client[kHTTP2Session]) { + connect(client); + return; + } + if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) { + return; + } + if (client[kRunning] > 0 && !request.idempotent) { + return; + } + if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) { + return; + } + if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body))) { + return; + } + if (!request.aborted && write(client, request)) { + client[kPendingIdx]++; + } else { + client[kQueue].splice(client[kPendingIdx], 1); + } + } + } + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; + } + function write(client, request) { + if (client[kHTTPConnVersion] === "h2") { + writeH2(client, client[kHTTP2Session], request); + return; + } + const { body, method, path: path3, host, upgrade, headers, blocking, reset } = request; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + const bodyLength = util.bodyLength(body); + let contentLength = bodyLength; + if (contentLength === null) { + contentLength = request.contentLength; + } + if (contentLength === 0 && !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + const socket = client[kSocket]; + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); + util.destroy(socket, new InformationalError("aborted")); + }); + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + if (method === "HEAD") { + socket[kReset] = true; + } + if (upgrade || method === "CONNECT") { + socket[kReset] = true; + } + if (reset != null) { + socket[kReset] = reset; + } + if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { + socket[kReset] = true; + } + if (blocking) { + socket[kBlocking] = true; + } + let header = `${method} ${path3} HTTP/1.1\r +`; + if (typeof host === "string") { + header += `host: ${host}\r +`; + } else { + header += client[kHostHeader]; + } + if (upgrade) { + header += `connection: upgrade\r +upgrade: ${upgrade}\r +`; + } else if (client[kPipelining] && !socket[kReset]) { + header += "connection: keep-alive\r\n"; + } else { + header += "connection: close\r\n"; + } + if (headers) { + header += headers; + } + if (channels.sendHeaders.hasSubscribers) { + channels.sendHeaders.publish({ request, headers: header, socket }); + } + if (!body || bodyLength === 0) { + if (contentLength === 0) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + assert(contentLength === null, "no body must not have content length"); + socket.write(`${header}\r +`, "latin1"); + } + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(body); + socket.uncork(); + request.onBodySent(body); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload }); + } else { + writeBlob({ body, client, request, socket, contentLength, header, expectsPayload }); + } + } else if (util.isStream(body)) { + writeStream({ body, client, request, socket, contentLength, header, expectsPayload }); + } else if (util.isIterable(body)) { + writeIterable({ body, client, request, socket, contentLength, header, expectsPayload }); + } else { + assert(false); + } + return true; + } + function writeH2(client, session, request) { + const { body, method, path: path3, host, upgrade, expectContinue, signal, headers: reqHeaders } = request; + let headers; + if (typeof reqHeaders === "string") headers = Request[kHTTP2CopyHeaders](reqHeaders.trim()); + else headers = reqHeaders; + if (upgrade) { + errorRequest(client, request, new Error("Upgrade not supported for H2")); + return false; + } + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); + }); + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + let stream; + const h2State = client[kHTTP2SessionState]; + headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost]; + headers[HTTP2_HEADER_METHOD] = method; + if (method === "CONNECT") { + session.ref(); + stream = session.request(headers, { endStream: false, signal }); + if (stream.id && !stream.pending) { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + } else { + stream.once("ready", () => { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + }); + } + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) session.unref(); + }); + return true; + } + headers[HTTP2_HEADER_PATH] = path3; + headers[HTTP2_HEADER_SCHEME] = "https"; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + let contentLength = util.bodyLength(body); + if (contentLength == null) { + contentLength = request.contentLength; + } + if (contentLength === 0 || !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + if (contentLength != null) { + assert(body, "no body must not have content length"); + headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`; + } + session.ref(); + const shouldEndStream = method === "GET" || method === "HEAD"; + if (expectContinue) { + headers[HTTP2_HEADER_EXPECT] = "100-continue"; + stream = session.request(headers, { endStream: shouldEndStream, signal }); + stream.once("continue", writeBodyH2); + } else { + stream = session.request(headers, { + endStream: shouldEndStream, + signal + }); + writeBodyH2(); + } + ++h2State.openStreams; + stream.once("response", (headers2) => { + const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2; + if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), "") === false) { + stream.pause(); + } + }); + stream.once("end", () => { + request.onComplete([]); + }); + stream.on("data", (chunk) => { + if (request.onData(chunk) === false) { + stream.pause(); + } + }); + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) { + session.unref(); + } + }); + stream.once("error", function(err) { + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + stream.once("frameError", (type, code) => { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + errorRequest(client, request, err); + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + return true; + function writeBodyH2() { + if (!body) { + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + stream.cork(); + stream.write(body); + stream.uncork(); + stream.end(); + request.onBodySent(body); + request.onRequestSent(); + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ + client, + request, + contentLength, + h2stream: stream, + expectsPayload, + body: body.stream(), + socket: client[kSocket], + header: "" + }); + } else { + writeBlob({ + body, + client, + request, + contentLength, + expectsPayload, + h2stream: stream, + header: "", + socket: client[kSocket] + }); + } + } else if (util.isStream(body)) { + writeStream({ + body, + client, + request, + contentLength, + expectsPayload, + socket: client[kSocket], + h2stream: stream, + header: "" + }); + } else if (util.isIterable(body)) { + writeIterable({ + body, + client, + request, + contentLength, + expectsPayload, + header: "", + h2stream: stream, + socket: client[kSocket] + }); + } else { + assert(false); + } + } + } + function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + if (client[kHTTPConnVersion] === "h2") { + let onPipeData = function(chunk) { + request.onBodySent(chunk); + }; + const pipe = pipeline( + body, + h2stream, + (err) => { + if (err) { + util.destroy(body, err); + util.destroy(h2stream, err); + } else { + request.onRequestSent(); + } + } + ); + pipe.on("data", onPipeData); + pipe.once("end", () => { + pipe.removeListener("data", onPipeData); + util.destroy(pipe); + }); + return; + } + let finished = false; + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + const onData = function(chunk) { + if (finished) { + return; + } + try { + if (!writer.write(chunk) && this.pause) { + this.pause(); + } + } catch (err) { + util.destroy(this, err); + } + }; + const onDrain = function() { + if (finished) { + return; + } + if (body.resume) { + body.resume(); + } + }; + const onAbort = function() { + if (finished) { + return; + } + const err = new RequestAbortedError(); + queueMicrotask(() => onFinished(err)); + }; + const onFinished = function(err) { + if (finished) { + return; + } + finished = true; + assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); + socket.off("drain", onDrain).off("error", onFinished); + body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort); + if (!err) { + try { + writer.end(); + } catch (er) { + err = er; + } + } + writer.destroy(err); + if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) { + util.destroy(body, err); + } else { + util.destroy(body); + } + }; + body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort); + if (body.resume) { + body.resume(); + } + socket.on("drain", onDrain).on("error", onFinished); + } + async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength === body.size, "blob body must have content length"); + const isH2 = client[kHTTPConnVersion] === "h2"; + try { + if (contentLength != null && contentLength !== body.size) { + throw new RequestContentLengthMismatchError(); + } + const buffer = Buffer.from(await body.arrayBuffer()); + if (isH2) { + h2stream.cork(); + h2stream.write(buffer); + h2stream.uncork(); + } else { + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(buffer); + socket.uncork(); + } + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + resume(client); + } catch (err) { + util.destroy(isH2 ? h2stream : socket, err); + } + } + async function writeIterable({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve, reject) => { + assert(callback === null); + if (socket[kError]) { + reject(socket[kError]); + } else { + callback = resolve; + } + }); + if (client[kHTTPConnVersion] === "h2") { + h2stream.on("close", onDrain).on("drain", onDrain); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + const res = h2stream.write(chunk); + request.onBodySent(chunk); + if (!res) { + await waitForDrain(); + } + } + } catch (err) { + h2stream.destroy(err); + } finally { + request.onRequestSent(); + h2stream.end(); + h2stream.off("close", onDrain).off("drain", onDrain); + } + return; + } + socket.on("close", onDrain).on("drain", onDrain); + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + if (!writer.write(chunk)) { + await waitForDrain(); + } + } + writer.end(); + } catch (err) { + writer.destroy(err); + } finally { + socket.off("close", onDrain).off("drain", onDrain); + } + } + var AsyncWriter = class { + constructor({ socket, request, contentLength, client, expectsPayload, header }) { + this.socket = socket; + this.request = request; + this.contentLength = contentLength; + this.client = client; + this.bytesWritten = 0; + this.expectsPayload = expectsPayload; + this.header = header; + socket[kWriting] = true; + } + write(chunk) { + const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return false; + } + const len = Buffer.byteLength(chunk); + if (!len) { + return true; + } + if (contentLength !== null && bytesWritten + len > contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + socket.cork(); + if (bytesWritten === 0) { + if (!expectsPayload) { + socket[kReset] = true; + } + if (contentLength === null) { + socket.write(`${header}transfer-encoding: chunked\r +`, "latin1"); + } else { + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + } + } + if (contentLength === null) { + socket.write(`\r +${len.toString(16)}\r +`, "latin1"); + } + this.bytesWritten += len; + const ret = socket.write(chunk); + socket.uncork(); + request.onBodySent(chunk); + if (!ret) { + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + } + return ret; + } + end() { + const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this; + request.onRequestSent(); + socket[kWriting] = false; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return; + } + if (bytesWritten === 0) { + if (expectsPayload) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + socket.write(`${header}\r +`, "latin1"); + } + } else if (contentLength === null) { + socket.write("\r\n0\r\n\r\n", "latin1"); + } + if (contentLength !== null && bytesWritten !== contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } else { + process.emitWarning(new RequestContentLengthMismatchError()); + } + } + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + resume(client); + } + destroy(err) { + const { socket, client } = this; + socket[kWriting] = false; + if (err) { + assert(client[kRunning] <= 1, "pipeline should only contain this request"); + util.destroy(socket, err); + } + } + }; + function errorRequest(client, request, err) { + try { + request.onError(err); + assert(request.aborted); + } catch (err2) { + client.emit("error", err2); + } + } + module2.exports = Client; + } +}); + +// node_modules/undici/lib/node/fixed-queue.js +var require_fixed_queue = __commonJS({ + "node_modules/undici/lib/node/fixed-queue.js"(exports2, module2) { + "use strict"; + var kSize = 2048; + var kMask = kSize - 1; + var FixedCircularBuffer = class { + constructor() { + this.bottom = 0; + this.top = 0; + this.list = new Array(kSize); + this.next = null; + } + isEmpty() { + return this.top === this.bottom; + } + isFull() { + return (this.top + 1 & kMask) === this.bottom; + } + push(data) { + this.list[this.top] = data; + this.top = this.top + 1 & kMask; + } + shift() { + const nextItem = this.list[this.bottom]; + if (nextItem === void 0) + return null; + this.list[this.bottom] = void 0; + this.bottom = this.bottom + 1 & kMask; + return nextItem; + } + }; + module2.exports = class FixedQueue { + constructor() { + this.head = this.tail = new FixedCircularBuffer(); + } + isEmpty() { + return this.head.isEmpty(); + } + push(data) { + if (this.head.isFull()) { + this.head = this.head.next = new FixedCircularBuffer(); + } + this.head.push(data); + } + shift() { + const tail = this.tail; + const next = tail.shift(); + if (tail.isEmpty() && tail.next !== null) { + this.tail = tail.next; + } + return next; + } + }; + } +}); + +// node_modules/undici/lib/pool-stats.js +var require_pool_stats = __commonJS({ + "node_modules/undici/lib/pool-stats.js"(exports2, module2) { + var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols(); + var kPool = Symbol("pool"); + var PoolStats = class { + constructor(pool) { + this[kPool] = pool; + } + get connected() { + return this[kPool][kConnected]; + } + get free() { + return this[kPool][kFree]; + } + get pending() { + return this[kPool][kPending]; + } + get queued() { + return this[kPool][kQueued]; + } + get running() { + return this[kPool][kRunning]; + } + get size() { + return this[kPool][kSize]; + } + }; + module2.exports = PoolStats; + } +}); + +// node_modules/undici/lib/pool-base.js +var require_pool_base = __commonJS({ + "node_modules/undici/lib/pool-base.js"(exports2, module2) { + "use strict"; + var DispatcherBase = require_dispatcher_base(); + var FixedQueue = require_fixed_queue(); + var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols(); + var PoolStats = require_pool_stats(); + var kClients = Symbol("clients"); + var kNeedDrain = Symbol("needDrain"); + var kQueue = Symbol("queue"); + var kClosedResolve = Symbol("closed resolve"); + var kOnDrain = Symbol("onDrain"); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kGetDispatcher = Symbol("get dispatcher"); + var kAddClient = Symbol("add client"); + var kRemoveClient = Symbol("remove client"); + var kStats = Symbol("stats"); + var PoolBase = class extends DispatcherBase { + constructor() { + super(); + this[kQueue] = new FixedQueue(); + this[kClients] = []; + this[kQueued] = 0; + const pool = this; + this[kOnDrain] = function onDrain(origin, targets) { + const queue = pool[kQueue]; + let needDrain = false; + while (!needDrain) { + const item = queue.shift(); + if (!item) { + break; + } + pool[kQueued]--; + needDrain = !this.dispatch(item.opts, item.handler); + } + this[kNeedDrain] = needDrain; + if (!this[kNeedDrain] && pool[kNeedDrain]) { + pool[kNeedDrain] = false; + pool.emit("drain", origin, [pool, ...targets]); + } + if (pool[kClosedResolve] && queue.isEmpty()) { + Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]); + } + }; + this[kOnConnect] = (origin, targets) => { + pool.emit("connect", origin, [pool, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + pool.emit("disconnect", origin, [pool, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + pool.emit("connectionError", origin, [pool, ...targets], err); + }; + this[kStats] = new PoolStats(this); + } + get [kBusy]() { + return this[kNeedDrain]; + } + get [kConnected]() { + return this[kClients].filter((client) => client[kConnected]).length; + } + get [kFree]() { + return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length; + } + get [kPending]() { + let ret = this[kQueued]; + for (const { [kPending]: pending } of this[kClients]) { + ret += pending; + } + return ret; + } + get [kRunning]() { + let ret = 0; + for (const { [kRunning]: running } of this[kClients]) { + ret += running; + } + return ret; + } + get [kSize]() { + let ret = this[kQueued]; + for (const { [kSize]: size } of this[kClients]) { + ret += size; + } + return ret; + } + get stats() { + return this[kStats]; + } + async [kClose]() { + if (this[kQueue].isEmpty()) { + return Promise.all(this[kClients].map((c) => c.close())); + } else { + return new Promise((resolve) => { + this[kClosedResolve] = resolve; + }); + } + } + async [kDestroy](err) { + while (true) { + const item = this[kQueue].shift(); + if (!item) { + break; + } + item.handler.onError(err); + } + return Promise.all(this[kClients].map((c) => c.destroy(err))); + } + [kDispatch](opts, handler) { + const dispatcher = this[kGetDispatcher](); + if (!dispatcher) { + this[kNeedDrain] = true; + this[kQueue].push({ opts, handler }); + this[kQueued]++; + } else if (!dispatcher.dispatch(opts, handler)) { + dispatcher[kNeedDrain] = true; + this[kNeedDrain] = !this[kGetDispatcher](); + } + return !this[kNeedDrain]; + } + [kAddClient](client) { + client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].push(client); + if (this[kNeedDrain]) { + process.nextTick(() => { + if (this[kNeedDrain]) { + this[kOnDrain](client[kUrl], [this, client]); + } + }); + } + return this; + } + [kRemoveClient](client) { + client.close(() => { + const idx = this[kClients].indexOf(client); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + }); + this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true); + } + }; + module2.exports = { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + }; + } +}); + +// node_modules/undici/lib/pool.js +var require_pool = __commonJS({ + "node_modules/undici/lib/pool.js"(exports2, module2) { + "use strict"; + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kGetDispatcher + } = require_pool_base(); + var Client = require_client(); + var { + InvalidArgumentError + } = require_errors(); + var util = require_util(); + var { kUrl, kInterceptors } = require_symbols(); + var buildConnector = require_connect(); + var kOptions = Symbol("options"); + var kConnections = Symbol("connections"); + var kFactory = Symbol("factory"); + function defaultFactory(origin, opts) { + return new Client(origin, opts); + } + var Pool = class extends PoolBase { + constructor(origin, { + connections, + factory = defaultFactory, + connect, + connectTimeout, + tls, + maxCachedSessions, + socketPath, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + allowH2, + ...options + } = {}) { + super(); + if (connections != null && (!Number.isFinite(connections) || connections < 0)) { + throw new InvalidArgumentError("invalid connections"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (typeof connect !== "function") { + connect = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect + }); + } + this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : []; + this[kConnections] = connections || null; + this[kUrl] = util.parseOrigin(origin); + this[kOptions] = { ...util.deepClone(options), connect, allowH2 }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kFactory] = factory; + this.on("connectionError", (origin2, targets, error) => { + for (const target of targets) { + const idx = this[kClients].indexOf(target); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + } + }); + } + [kGetDispatcher]() { + let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]); + if (dispatcher) { + return dispatcher; + } + if (!this[kConnections] || this[kClients].length < this[kConnections]) { + dispatcher = this[kFactory](this[kUrl], this[kOptions]); + this[kAddClient](dispatcher); + } + return dispatcher; + } + }; + module2.exports = Pool; + } +}); + +// node_modules/undici/lib/balanced-pool.js +var require_balanced_pool = __commonJS({ + "node_modules/undici/lib/balanced-pool.js"(exports2, module2) { + "use strict"; + var { + BalancedPoolMissingUpstreamError, + InvalidArgumentError + } = require_errors(); + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + } = require_pool_base(); + var Pool = require_pool(); + var { kUrl, kInterceptors } = require_symbols(); + var { parseOrigin } = require_util(); + var kFactory = Symbol("factory"); + var kOptions = Symbol("options"); + var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor"); + var kCurrentWeight = Symbol("kCurrentWeight"); + var kIndex = Symbol("kIndex"); + var kWeight = Symbol("kWeight"); + var kMaxWeightPerServer = Symbol("kMaxWeightPerServer"); + var kErrorPenalty = Symbol("kErrorPenalty"); + function getGreatestCommonDivisor(a, b) { + if (b === 0) return a; + return getGreatestCommonDivisor(b, a % b); + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var BalancedPool = class extends PoolBase { + constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) { + super(); + this[kOptions] = opts; + this[kIndex] = -1; + this[kCurrentWeight] = 0; + this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100; + this[kErrorPenalty] = this[kOptions].errorPenalty || 15; + if (!Array.isArray(upstreams)) { + upstreams = [upstreams]; + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : []; + this[kFactory] = factory; + for (const upstream of upstreams) { + this.addUpstream(upstream); + } + this._updateBalancedPoolStats(); + } + addUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) { + return this; + } + const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions])); + this[kAddClient](pool); + pool.on("connect", () => { + pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]); + }); + pool.on("connectionError", () => { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + }); + pool.on("disconnect", (...args) => { + const err = args[2]; + if (err && err.code === "UND_ERR_SOCKET") { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + } + }); + for (const client of this[kClients]) { + client[kWeight] = this[kMaxWeightPerServer]; + } + this._updateBalancedPoolStats(); + return this; + } + _updateBalancedPoolStats() { + this[kGreatestCommonDivisor] = this[kClients].map((p) => p[kWeight]).reduce(getGreatestCommonDivisor, 0); + } + removeUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true); + if (pool) { + this[kRemoveClient](pool); + } + return this; + } + get upstreams() { + return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin); + } + [kGetDispatcher]() { + if (this[kClients].length === 0) { + throw new BalancedPoolMissingUpstreamError(); + } + const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true); + if (!dispatcher) { + return; + } + const allClientsBusy = this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true); + if (allClientsBusy) { + return; + } + let counter = 0; + let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]); + while (counter++ < this[kClients].length) { + this[kIndex] = (this[kIndex] + 1) % this[kClients].length; + const pool = this[kClients][this[kIndex]]; + if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) { + maxWeightIndex = this[kIndex]; + } + if (this[kIndex] === 0) { + this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]; + if (this[kCurrentWeight] <= 0) { + this[kCurrentWeight] = this[kMaxWeightPerServer]; + } + } + if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) { + return pool; + } + } + this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]; + this[kIndex] = maxWeightIndex; + return this[kClients][maxWeightIndex]; + } + }; + module2.exports = BalancedPool; + } +}); + +// node_modules/undici/lib/compat/dispatcher-weakref.js +var require_dispatcher_weakref = __commonJS({ + "node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module2) { + "use strict"; + var { kConnected, kSize } = require_symbols(); + var CompatWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value; + } + }; + var CompatFinalizer = class { + constructor(finalizer) { + this.finalizer = finalizer; + } + register(dispatcher, key) { + if (dispatcher.on) { + dispatcher.on("disconnect", () => { + if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) { + this.finalizer(key); + } + }); + } + } + }; + module2.exports = function() { + if (process.env.NODE_V8_COVERAGE) { + return { + WeakRef: CompatWeakRef, + FinalizationRegistry: CompatFinalizer + }; + } + return { + WeakRef: global.WeakRef || CompatWeakRef, + FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer + }; + }; + } +}); + +// node_modules/undici/lib/agent.js +var require_agent = __commonJS({ + "node_modules/undici/lib/agent.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError } = require_errors(); + var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); + var DispatcherBase = require_dispatcher_base(); + var Pool = require_pool(); + var Client = require_client(); + var util = require_util(); + var createRedirectInterceptor = require_redirectInterceptor(); + var { WeakRef: WeakRef2, FinalizationRegistry } = require_dispatcher_weakref()(); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kMaxRedirections = Symbol("maxRedirections"); + var kOnDrain = Symbol("onDrain"); + var kFactory = Symbol("factory"); + var kFinalizer = Symbol("finalizer"); + var kOptions = Symbol("options"); + function defaultFactory(origin, opts) { + return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts); + } + var Agent = class extends DispatcherBase { + constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { + super(); + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (!Number.isInteger(maxRedirections) || maxRedirections < 0) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (connect && typeof connect !== "function") { + connect = { ...connect }; + } + this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })]; + this[kOptions] = { ...util.deepClone(options), connect }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kMaxRedirections] = maxRedirections; + this[kFactory] = factory; + this[kClients] = /* @__PURE__ */ new Map(); + this[kFinalizer] = new FinalizationRegistry( + /* istanbul ignore next: gc is undeterministic */ + (key) => { + const ref = this[kClients].get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this[kClients].delete(key); + } + } + ); + const agent = this; + this[kOnDrain] = (origin, targets) => { + agent.emit("drain", origin, [agent, ...targets]); + }; + this[kOnConnect] = (origin, targets) => { + agent.emit("connect", origin, [agent, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + agent.emit("disconnect", origin, [agent, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + agent.emit("connectionError", origin, [agent, ...targets], err); + }; + } + get [kRunning]() { + let ret = 0; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + ret += client[kRunning]; + } + } + return ret; + } + [kDispatch](opts, handler) { + let key; + if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) { + key = String(opts.origin); + } else { + throw new InvalidArgumentError("opts.origin must be a non-empty string or URL."); + } + const ref = this[kClients].get(key); + let dispatcher = ref ? ref.deref() : null; + if (!dispatcher) { + dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].set(key, new WeakRef2(dispatcher)); + this[kFinalizer].register(dispatcher, key); + } + return dispatcher.dispatch(opts, handler); + } + async [kClose]() { + const closePromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + closePromises.push(client.close()); + } + } + await Promise.all(closePromises); + } + async [kDestroy](err) { + const destroyPromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + destroyPromises.push(client.destroy(err)); + } + } + await Promise.all(destroyPromises); + } + }; + module2.exports = Agent; + } +}); + +// node_modules/undici/lib/api/readable.js +var require_readable = __commonJS({ + "node_modules/undici/lib/api/readable.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { Readable } = require("stream"); + var { RequestAbortedError, NotSupportedError, InvalidArgumentError } = require_errors(); + var util = require_util(); + var { ReadableStreamFrom: ReadableStreamFrom3, toUSVString } = require_util(); + var Blob2; + var kConsume = Symbol("kConsume"); + var kReading = Symbol("kReading"); + var kBody = Symbol("kBody"); + var kAbort = Symbol("abort"); + var kContentType = Symbol("kContentType"); + var noop3 = () => { + }; + module2.exports = class BodyReadable extends Readable { + constructor({ + resume, + abort, + contentType = "", + highWaterMark = 64 * 1024 + // Same as nodejs fs streams. + }) { + super({ + autoDestroy: true, + read: resume, + highWaterMark + }); + this._readableState.dataEmitted = false; + this[kAbort] = abort; + this[kConsume] = null; + this[kBody] = null; + this[kContentType] = contentType; + this[kReading] = false; + } + destroy(err) { + if (this.destroyed) { + return this; + } + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (err) { + this[kAbort](); + } + return super.destroy(err); + } + emit(ev, ...args) { + if (ev === "data") { + this._readableState.dataEmitted = true; + } else if (ev === "error") { + this._readableState.errorEmitted = true; + } + return super.emit(ev, ...args); + } + on(ev, ...args) { + if (ev === "data" || ev === "readable") { + this[kReading] = true; + } + return super.on(ev, ...args); + } + addListener(ev, ...args) { + return this.on(ev, ...args); + } + off(ev, ...args) { + const ret = super.off(ev, ...args); + if (ev === "data" || ev === "readable") { + this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0; + } + return ret; + } + removeListener(ev, ...args) { + return this.off(ev, ...args); + } + push(chunk) { + if (this[kConsume] && chunk !== null && this.readableLength === 0) { + consumePush(this[kConsume], chunk); + return this[kReading] ? super.push(chunk) : true; + } + return super.push(chunk); + } + // https://fetch.spec.whatwg.org/#dom-body-text + async text() { + return consume(this, "text"); + } + // https://fetch.spec.whatwg.org/#dom-body-json + async json() { + return consume(this, "json"); + } + // https://fetch.spec.whatwg.org/#dom-body-blob + async blob() { + return consume(this, "blob"); + } + // https://fetch.spec.whatwg.org/#dom-body-arraybuffer + async arrayBuffer() { + return consume(this, "arrayBuffer"); + } + // https://fetch.spec.whatwg.org/#dom-body-formdata + async formData() { + throw new NotSupportedError(); + } + // https://fetch.spec.whatwg.org/#dom-body-bodyused + get bodyUsed() { + return util.isDisturbed(this); + } + // https://fetch.spec.whatwg.org/#dom-body-body + get body() { + if (!this[kBody]) { + this[kBody] = ReadableStreamFrom3(this); + if (this[kConsume]) { + this[kBody].getReader(); + assert(this[kBody].locked); + } + } + return this[kBody]; + } + dump(opts) { + let limit3 = opts && Number.isFinite(opts.limit) ? opts.limit : 262144; + const signal = opts && opts.signal; + if (signal) { + try { + if (typeof signal !== "object" || !("aborted" in signal)) { + throw new InvalidArgumentError("signal must be an AbortSignal"); + } + util.throwIfAborted(signal); + } catch (err) { + return Promise.reject(err); + } + } + if (this.closed) { + return Promise.resolve(null); + } + return new Promise((resolve, reject) => { + const signalListenerCleanup = signal ? util.addAbortListener(signal, () => { + this.destroy(); + }) : noop3; + this.on("close", function() { + signalListenerCleanup(); + if (signal && signal.aborted) { + reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" })); + } else { + resolve(null); + } + }).on("error", noop3).on("data", function(chunk) { + limit3 -= chunk.length; + if (limit3 <= 0) { + this.destroy(); + } + }).resume(); + }); + } + }; + function isLocked(self2) { + return self2[kBody] && self2[kBody].locked === true || self2[kConsume]; + } + function isUnusable(self2) { + return util.isDisturbed(self2) || isLocked(self2); + } + async function consume(stream, type) { + if (isUnusable(stream)) { + throw new TypeError("unusable"); + } + assert(!stream[kConsume]); + return new Promise((resolve, reject) => { + stream[kConsume] = { + type, + stream, + resolve, + reject, + length: 0, + body: [] + }; + stream.on("error", function(err) { + consumeFinish(this[kConsume], err); + }).on("close", function() { + if (this[kConsume].body !== null) { + consumeFinish(this[kConsume], new RequestAbortedError()); + } + }); + process.nextTick(consumeStart, stream[kConsume]); + }); + } + function consumeStart(consume2) { + if (consume2.body === null) { + return; + } + const { _readableState: state } = consume2.stream; + for (const chunk of state.buffer) { + consumePush(consume2, chunk); + } + if (state.endEmitted) { + consumeEnd(this[kConsume]); + } else { + consume2.stream.on("end", function() { + consumeEnd(this[kConsume]); + }); + } + consume2.stream.resume(); + while (consume2.stream.read() != null) { + } + } + function consumeEnd(consume2) { + const { type, body, resolve, stream, length } = consume2; + try { + if (type === "text") { + resolve(toUSVString(Buffer.concat(body))); + } else if (type === "json") { + resolve(JSON.parse(Buffer.concat(body))); + } else if (type === "arrayBuffer") { + const dst = new Uint8Array(length); + let pos = 0; + for (const buf of body) { + dst.set(buf, pos); + pos += buf.byteLength; + } + resolve(dst.buffer); + } else if (type === "blob") { + if (!Blob2) { + Blob2 = require("buffer").Blob; + } + resolve(new Blob2(body, { type: stream[kContentType] })); + } + consumeFinish(consume2); + } catch (err) { + stream.destroy(err); + } + } + function consumePush(consume2, chunk) { + consume2.length += chunk.length; + consume2.body.push(chunk); + } + function consumeFinish(consume2, err) { + if (consume2.body === null) { + return; + } + if (err) { + consume2.reject(err); + } else { + consume2.resolve(); + } + consume2.type = null; + consume2.stream = null; + consume2.resolve = null; + consume2.reject = null; + consume2.length = 0; + consume2.body = null; + } + } +}); + +// node_modules/undici/lib/api/util.js +var require_util3 = __commonJS({ + "node_modules/undici/lib/api/util.js"(exports2, module2) { + var assert = require("assert"); + var { + ResponseStatusCodeError + } = require_errors(); + var { toUSVString } = require_util(); + async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) { + assert(body); + let chunks = []; + let limit3 = 0; + for await (const chunk of body) { + chunks.push(chunk); + limit3 += chunk.length; + if (limit3 > 128 * 1024) { + chunks = null; + break; + } + } + if (statusCode === 204 || !contentType || !chunks) { + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + return; + } + try { + if (contentType.startsWith("application/json")) { + const payload = JSON.parse(toUSVString(Buffer.concat(chunks))); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + if (contentType.startsWith("text/")) { + const payload = toUSVString(Buffer.concat(chunks)); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + } catch (err) { + } + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + } + module2.exports = { getResolveErrorBodyCallback }; + } +}); + +// node_modules/undici/lib/api/abort-signal.js +var require_abort_signal = __commonJS({ + "node_modules/undici/lib/api/abort-signal.js"(exports2, module2) { + var { addAbortListener } = require_util(); + var { RequestAbortedError } = require_errors(); + var kListener = Symbol("kListener"); + var kSignal = Symbol("kSignal"); + function abort(self2) { + if (self2.abort) { + self2.abort(); + } else { + self2.onError(new RequestAbortedError()); + } + } + function addSignal(self2, signal) { + self2[kSignal] = null; + self2[kListener] = null; + if (!signal) { + return; + } + if (signal.aborted) { + abort(self2); + return; + } + self2[kSignal] = signal; + self2[kListener] = () => { + abort(self2); + }; + addAbortListener(self2[kSignal], self2[kListener]); + } + function removeSignal(self2) { + if (!self2[kSignal]) { + return; + } + if ("removeEventListener" in self2[kSignal]) { + self2[kSignal].removeEventListener("abort", self2[kListener]); + } else { + self2[kSignal].removeListener("abort", self2[kListener]); + } + self2[kSignal] = null; + self2[kListener] = null; + } + module2.exports = { + addSignal, + removeSignal + }; + } +}); + +// node_modules/undici/lib/api/api-request.js +var require_api_request = __commonJS({ + "node_modules/undici/lib/api/api-request.js"(exports2, module2) { + "use strict"; + var Readable = require_readable(); + var { + InvalidArgumentError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var RequestHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) { + throw new InvalidArgumentError("invalid highWaterMark"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_REQUEST"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.res = null; + this.abort = null; + this.body = body; + this.trailers = {}; + this.context = null; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError; + this.highWaterMark = highWaterMark; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context2) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context2; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { callback, opaque, abort, context: context2, responseHeaders, highWaterMark } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + const body = new Readable({ resume, abort, contentType, highWaterMark }); + this.callback = null; + this.res = body; + if (callback !== null) { + if (this.throwOnError && statusCode >= 400) { + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body, contentType, statusCode, statusMessage, headers } + ); + } else { + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + trailers: this.trailers, + opaque, + body, + context: context2 + }); + } + } + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + util.parseHeaders(trailers, this.trailers); + res.push(null); + } + onError(err) { + const { res, callback, body, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (res) { + this.res = null; + queueMicrotask(() => { + util.destroy(res, err); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function request(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + request.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + this.dispatch(opts, new RequestHandler(opts, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = request; + module2.exports.RequestHandler = RequestHandler; + } +}); + +// node_modules/undici/lib/api/api-stream.js +var require_api_stream = __commonJS({ + "node_modules/undici/lib/api/api-stream.js"(exports2, module2) { + "use strict"; + var { finished, PassThrough } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var StreamHandler = class extends AsyncResource { + constructor(opts, factory, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("invalid factory"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_STREAM"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.factory = factory; + this.callback = callback; + this.res = null; + this.abort = null; + this.context = null; + this.trailers = null; + this.body = body; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError || false; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context2) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context2; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { factory, opaque, context: context2, callback, responseHeaders } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + this.factory = null; + let res; + if (this.throwOnError && statusCode >= 400) { + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + res = new PassThrough(); + this.callback = null; + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body: res, contentType, statusCode, statusMessage, headers } + ); + } else { + if (factory === null) { + return; + } + res = this.runInAsyncScope(factory, null, { + statusCode, + headers, + opaque, + context: context2 + }); + if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") { + throw new InvalidReturnValueError("expected Writable"); + } + finished(res, { readable: false }, (err) => { + const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this; + this.res = null; + if (err || !res2.readable) { + util.destroy(res2, err); + } + this.callback = null; + this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers }); + if (err) { + abort(); + } + }); + } + res.on("drain", resume); + this.res = res; + const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain; + return needDrain !== true; + } + onData(chunk) { + const { res } = this; + return res ? res.write(chunk) : true; + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + if (!res) { + return; + } + this.trailers = util.parseHeaders(trailers); + res.end(); + } + onError(err) { + const { res, callback, opaque, body } = this; + removeSignal(this); + this.factory = null; + if (res) { + this.res = null; + util.destroy(res, err); + } else if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function stream(opts, factory, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + stream.call(this, opts, factory, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + this.dispatch(opts, new StreamHandler(opts, factory, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = stream; + } +}); + +// node_modules/undici/lib/api/api-pipeline.js +var require_api_pipeline = __commonJS({ + "node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) { + "use strict"; + var { + Readable, + Duplex, + PassThrough + } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var kResume = Symbol("resume"); + var PipelineRequest = class extends Readable { + constructor() { + super({ autoDestroy: true }); + this[kResume] = null; + } + _read() { + const { [kResume]: resume } = this; + if (resume) { + this[kResume] = null; + resume(); + } + } + _destroy(err, callback) { + this._read(); + callback(err); + } + }; + var PipelineResponse = class extends Readable { + constructor(resume) { + super({ autoDestroy: true }); + this[kResume] = resume; + } + _read() { + this[kResume](); + } + _destroy(err, callback) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + callback(err); + } + }; + var PipelineHandler = class extends AsyncResource { + constructor(opts, handler) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof handler !== "function") { + throw new InvalidArgumentError("invalid handler"); + } + const { signal, method, opaque, onInfo, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_PIPELINE"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.handler = handler; + this.abort = null; + this.context = null; + this.onInfo = onInfo || null; + this.req = new PipelineRequest().on("error", util.nop); + this.ret = new Duplex({ + readableObjectMode: opts.objectMode, + autoDestroy: true, + read: () => { + const { body } = this; + if (body && body.resume) { + body.resume(); + } + }, + write: (chunk, encoding, callback) => { + const { req } = this; + if (req.push(chunk, encoding) || req._readableState.destroyed) { + callback(); + } else { + req[kResume] = callback; + } + }, + destroy: (err, callback) => { + const { body, req, res, ret, abort } = this; + if (!err && !ret._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (abort && err) { + abort(); + } + util.destroy(body, err); + util.destroy(req, err); + util.destroy(res, err); + removeSignal(this); + callback(err); + } + }).on("prefinish", () => { + const { req } = this; + req.push(null); + }); + this.res = null; + addSignal(this, signal); + } + onConnect(abort, context2) { + const { ret, res } = this; + assert(!res, "pipeline cannot be retried"); + if (ret.destroyed) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context2; + } + onHeaders(statusCode, rawHeaders, resume) { + const { opaque, handler, context: context2 } = this; + if (statusCode < 200) { + if (this.onInfo) { + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.onInfo({ statusCode, headers }); + } + return; + } + this.res = new PipelineResponse(resume); + let body; + try { + this.handler = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + body = this.runInAsyncScope(handler, null, { + statusCode, + headers, + opaque, + body: this.res, + context: context2 + }); + } catch (err) { + this.res.on("error", util.nop); + throw err; + } + if (!body || typeof body.on !== "function") { + throw new InvalidReturnValueError("expected Readable"); + } + body.on("data", (chunk) => { + const { ret, body: body2 } = this; + if (!ret.push(chunk) && body2.pause) { + body2.pause(); + } + }).on("error", (err) => { + const { ret } = this; + util.destroy(ret, err); + }).on("end", () => { + const { ret } = this; + ret.push(null); + }).on("close", () => { + const { ret } = this; + if (!ret._readableState.ended) { + util.destroy(ret, new RequestAbortedError()); + } + }); + this.body = body; + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + res.push(null); + } + onError(err) { + const { ret } = this; + this.handler = null; + util.destroy(ret, err); + } + }; + function pipeline(opts, handler) { + try { + const pipelineHandler = new PipelineHandler(opts, handler); + this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler); + return pipelineHandler.ret; + } catch (err) { + return new PassThrough().destroy(err); + } + } + module2.exports = pipeline; + } +}); + +// node_modules/undici/lib/api/api-upgrade.js +var require_api_upgrade = __commonJS({ + "node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors(); + var { AsyncResource } = require("async_hooks"); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var UpgradeHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_UPGRADE"); + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.abort = null; + this.context = null; + addSignal(this, signal); + } + onConnect(abort, context2) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = null; + } + onHeaders() { + throw new SocketError("bad upgrade", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context: context2 } = this; + assert.strictEqual(statusCode, 101); + removeSignal(this); + this.callback = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.runInAsyncScope(callback, null, null, { + headers, + socket, + opaque, + context: context2 + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function upgrade(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + upgrade.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const upgradeHandler = new UpgradeHandler(opts, callback); + this.dispatch({ + ...opts, + method: opts.method || "GET", + upgrade: opts.protocol || "Websocket" + }, upgradeHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = upgrade; + } +}); + +// node_modules/undici/lib/api/api-connect.js +var require_api_connect = __commonJS({ + "node_modules/undici/lib/api/api-connect.js"(exports2, module2) { + "use strict"; + var { AsyncResource } = require("async_hooks"); + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors(); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var ConnectHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_CONNECT"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.callback = callback; + this.abort = null; + addSignal(this, signal); + } + onConnect(abort, context2) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context2; + } + onHeaders() { + throw new SocketError("bad connect", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context: context2 } = this; + removeSignal(this); + this.callback = null; + let headers = rawHeaders; + if (headers != null) { + headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + } + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + socket, + opaque, + context: context2 + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function connect(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + connect.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const connectHandler = new ConnectHandler(opts, callback); + this.dispatch({ ...opts, method: "CONNECT" }, connectHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = connect; + } +}); + +// node_modules/undici/lib/api/index.js +var require_api = __commonJS({ + "node_modules/undici/lib/api/index.js"(exports2, module2) { + "use strict"; + module2.exports.request = require_api_request(); + module2.exports.stream = require_api_stream(); + module2.exports.pipeline = require_api_pipeline(); + module2.exports.upgrade = require_api_upgrade(); + module2.exports.connect = require_api_connect(); + } +}); + +// node_modules/undici/lib/mock/mock-errors.js +var require_mock_errors = __commonJS({ + "node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) { + "use strict"; + var { UndiciError } = require_errors(); + var MockNotMatchedError = class _MockNotMatchedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _MockNotMatchedError); + this.name = "MockNotMatchedError"; + this.message = message || "The request does not match any registered mock dispatches"; + this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED"; + } + }; + module2.exports = { + MockNotMatchedError + }; + } +}); + +// node_modules/undici/lib/mock/mock-symbols.js +var require_mock_symbols = __commonJS({ + "node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kAgent: Symbol("agent"), + kOptions: Symbol("options"), + kFactory: Symbol("factory"), + kDispatches: Symbol("dispatches"), + kDispatchKey: Symbol("dispatch key"), + kDefaultHeaders: Symbol("default headers"), + kDefaultTrailers: Symbol("default trailers"), + kContentLength: Symbol("content length"), + kMockAgent: Symbol("mock agent"), + kMockAgentSet: Symbol("mock agent set"), + kMockAgentGet: Symbol("mock agent get"), + kMockDispatch: Symbol("mock dispatch"), + kClose: Symbol("close"), + kOriginalClose: Symbol("original agent close"), + kOrigin: Symbol("origin"), + kIsMockActive: Symbol("is mock active"), + kNetConnect: Symbol("net connect"), + kGetNetConnect: Symbol("get net connect"), + kConnected: Symbol("connected") + }; + } +}); + +// node_modules/undici/lib/mock/mock-utils.js +var require_mock_utils = __commonJS({ + "node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) { + "use strict"; + var { MockNotMatchedError } = require_mock_errors(); + var { + kDispatches, + kMockAgent, + kOriginalDispatch, + kOrigin, + kGetNetConnect + } = require_mock_symbols(); + var { buildURL, nop } = require_util(); + var { STATUS_CODES } = require("http"); + var { + types: { + isPromise + } + } = require("util"); + function matchValue(match, value) { + if (typeof match === "string") { + return match === value; + } + if (match instanceof RegExp) { + return match.test(value); + } + if (typeof match === "function") { + return match(value) === true; + } + return false; + } + function lowerCaseEntries(headers) { + return Object.fromEntries( + Object.entries(headers).map(([headerName, headerValue]) => { + return [headerName.toLocaleLowerCase(), headerValue]; + }) + ); + } + function getHeaderByName(headers, key) { + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) { + return headers[i + 1]; + } + } + return void 0; + } else if (typeof headers.get === "function") { + return headers.get(key); + } else { + return lowerCaseEntries(headers)[key.toLocaleLowerCase()]; + } + } + function buildHeadersFromArray(headers) { + const clone = headers.slice(); + const entries = []; + for (let index = 0; index < clone.length; index += 2) { + entries.push([clone[index], clone[index + 1]]); + } + return Object.fromEntries(entries); + } + function matchHeaders(mockDispatch2, headers) { + if (typeof mockDispatch2.headers === "function") { + if (Array.isArray(headers)) { + headers = buildHeadersFromArray(headers); + } + return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {}); + } + if (typeof mockDispatch2.headers === "undefined") { + return true; + } + if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") { + return false; + } + for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) { + const headerValue = getHeaderByName(headers, matchHeaderName); + if (!matchValue(matchHeaderValue, headerValue)) { + return false; + } + } + return true; + } + function safeUrl(path3) { + if (typeof path3 !== "string") { + return path3; + } + const pathSegments = path3.split("?"); + if (pathSegments.length !== 2) { + return path3; + } + const qp = new URLSearchParams(pathSegments.pop()); + qp.sort(); + return [...pathSegments, qp.toString()].join("?"); + } + function matchKey(mockDispatch2, { path: path3, method, body, headers }) { + const pathMatch = matchValue(mockDispatch2.path, path3); + const methodMatch = matchValue(mockDispatch2.method, method); + const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true; + const headersMatch = matchHeaders(mockDispatch2, headers); + return pathMatch && methodMatch && bodyMatch && headersMatch; + } + function getResponseData(data) { + if (Buffer.isBuffer(data)) { + return data; + } else if (typeof data === "object") { + return JSON.stringify(data); + } else { + return data.toString(); + } + } + function getMockDispatch(mockDispatches, key) { + const basePath = key.query ? buildURL(key.path, key.query) : key.path; + const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath; + let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path3 }) => matchValue(safeUrl(path3), resolvedPath)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`); + } + matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`); + } + return matchedMockDispatches[0]; + } + function addMockDispatch(mockDispatches, key, data) { + const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false }; + const replyData = typeof data === "function" ? { callback: data } : { ...data }; + const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } }; + mockDispatches.push(newMockDispatch); + return newMockDispatch; + } + function deleteMockDispatch(mockDispatches, key) { + const index = mockDispatches.findIndex((dispatch) => { + if (!dispatch.consumed) { + return false; + } + return matchKey(dispatch, key); + }); + if (index !== -1) { + mockDispatches.splice(index, 1); + } + } + function buildKey(opts) { + const { path: path3, method, body, headers, query } = opts; + return { + path: path3, + method, + body, + headers, + query + }; + } + function generateKeyValues(data) { + return Object.entries(data).reduce((keyValuePairs, [key, value]) => [ + ...keyValuePairs, + Buffer.from(`${key}`), + Array.isArray(value) ? value.map((x) => Buffer.from(`${x}`)) : Buffer.from(`${value}`) + ], []); + } + function getStatusText(statusCode) { + return STATUS_CODES[statusCode] || "unknown"; + } + async function getResponse(body) { + const buffers = []; + for await (const data of body) { + buffers.push(data); + } + return Buffer.concat(buffers).toString("utf8"); + } + function mockDispatch(opts, handler) { + const key = buildKey(opts); + const mockDispatch2 = getMockDispatch(this[kDispatches], key); + mockDispatch2.timesInvoked++; + if (mockDispatch2.data.callback) { + mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) }; + } + const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2; + const { timesInvoked, times } = mockDispatch2; + mockDispatch2.consumed = !persist && timesInvoked >= times; + mockDispatch2.pending = timesInvoked < times; + if (error !== null) { + deleteMockDispatch(this[kDispatches], key); + handler.onError(error); + return true; + } + if (typeof delay === "number" && delay > 0) { + setTimeout(() => { + handleReply(this[kDispatches]); + }, delay); + } else { + handleReply(this[kDispatches]); + } + function handleReply(mockDispatches, _data = data) { + const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers; + const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data; + if (isPromise(body)) { + body.then((newData) => handleReply(mockDispatches, newData)); + return; + } + const responseData = getResponseData(body); + const responseHeaders = generateKeyValues(headers); + const responseTrailers = generateKeyValues(trailers); + handler.abort = nop; + handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode)); + handler.onData(Buffer.from(responseData)); + handler.onComplete(responseTrailers); + deleteMockDispatch(mockDispatches, key); + } + function resume() { + } + return true; + } + function buildMockDispatch() { + const agent = this[kMockAgent]; + const origin = this[kOrigin]; + const originalDispatch = this[kOriginalDispatch]; + return function dispatch(opts, handler) { + if (agent.isMockActive) { + try { + mockDispatch.call(this, opts, handler); + } catch (error) { + if (error instanceof MockNotMatchedError) { + const netConnect = agent[kGetNetConnect](); + if (netConnect === false) { + throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`); + } + if (checkNetConnect(netConnect, origin)) { + originalDispatch.call(this, opts, handler); + } else { + throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`); + } + } else { + throw error; + } + } + } else { + originalDispatch.call(this, opts, handler); + } + }; + } + function checkNetConnect(netConnect, origin) { + const url = new URL(origin); + if (netConnect === true) { + return true; + } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) { + return true; + } + return false; + } + function buildMockOptions(opts) { + if (opts) { + const { agent, ...mockOptions } = opts; + return mockOptions; + } + } + module2.exports = { + getResponseData, + getMockDispatch, + addMockDispatch, + deleteMockDispatch, + buildKey, + generateKeyValues, + matchValue, + getResponse, + getStatusText, + mockDispatch, + buildMockDispatch, + checkNetConnect, + buildMockOptions, + getHeaderByName + }; + } +}); + +// node_modules/undici/lib/mock/mock-interceptor.js +var require_mock_interceptor = __commonJS({ + "node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) { + "use strict"; + var { getResponseData, buildKey, addMockDispatch } = require_mock_utils(); + var { + kDispatches, + kDispatchKey, + kDefaultHeaders, + kDefaultTrailers, + kContentLength, + kMockDispatch + } = require_mock_symbols(); + var { InvalidArgumentError } = require_errors(); + var { buildURL } = require_util(); + var MockScope = class { + constructor(mockDispatch) { + this[kMockDispatch] = mockDispatch; + } + /** + * Delay a reply by a set amount in ms. + */ + delay(waitInMs) { + if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) { + throw new InvalidArgumentError("waitInMs must be a valid integer > 0"); + } + this[kMockDispatch].delay = waitInMs; + return this; + } + /** + * For a defined reply, never mark as consumed. + */ + persist() { + this[kMockDispatch].persist = true; + return this; + } + /** + * Allow one to define a reply for a set amount of matching requests. + */ + times(repeatTimes) { + if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) { + throw new InvalidArgumentError("repeatTimes must be a valid integer > 0"); + } + this[kMockDispatch].times = repeatTimes; + return this; + } + }; + var MockInterceptor = class { + constructor(opts, mockDispatches) { + if (typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object"); + } + if (typeof opts.path === "undefined") { + throw new InvalidArgumentError("opts.path must be defined"); + } + if (typeof opts.method === "undefined") { + opts.method = "GET"; + } + if (typeof opts.path === "string") { + if (opts.query) { + opts.path = buildURL(opts.path, opts.query); + } else { + const parsedURL = new URL(opts.path, "data://"); + opts.path = parsedURL.pathname + parsedURL.search; + } + } + if (typeof opts.method === "string") { + opts.method = opts.method.toUpperCase(); + } + this[kDispatchKey] = buildKey(opts); + this[kDispatches] = mockDispatches; + this[kDefaultHeaders] = {}; + this[kDefaultTrailers] = {}; + this[kContentLength] = false; + } + createMockScopeDispatchData(statusCode, data, responseOptions = {}) { + const responseData = getResponseData(data); + const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {}; + const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }; + const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }; + return { statusCode, data, headers, trailers }; + } + validateReplyParameters(statusCode, data, responseOptions) { + if (typeof statusCode === "undefined") { + throw new InvalidArgumentError("statusCode must be defined"); + } + if (typeof data === "undefined") { + throw new InvalidArgumentError("data must be defined"); + } + if (typeof responseOptions !== "object") { + throw new InvalidArgumentError("responseOptions must be an object"); + } + } + /** + * Mock an undici request with a defined reply. + */ + reply(replyData) { + if (typeof replyData === "function") { + const wrappedDefaultsCallback = (opts) => { + const resolvedData = replyData(opts); + if (typeof resolvedData !== "object") { + throw new InvalidArgumentError("reply options callback must return an object"); + } + const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData; + this.validateReplyParameters(statusCode2, data2, responseOptions2); + return { + ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2) + }; + }; + const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback); + return new MockScope(newMockDispatch2); + } + const [statusCode, data = "", responseOptions = {}] = [...arguments]; + this.validateReplyParameters(statusCode, data, responseOptions); + const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions); + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData); + return new MockScope(newMockDispatch); + } + /** + * Mock an undici request with a defined error. + */ + replyWithError(error) { + if (typeof error === "undefined") { + throw new InvalidArgumentError("error must be defined"); + } + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error }); + return new MockScope(newMockDispatch); + } + /** + * Set default reply headers on the interceptor for subsequent replies + */ + defaultReplyHeaders(headers) { + if (typeof headers === "undefined") { + throw new InvalidArgumentError("headers must be defined"); + } + this[kDefaultHeaders] = headers; + return this; + } + /** + * Set default reply trailers on the interceptor for subsequent replies + */ + defaultReplyTrailers(trailers) { + if (typeof trailers === "undefined") { + throw new InvalidArgumentError("trailers must be defined"); + } + this[kDefaultTrailers] = trailers; + return this; + } + /** + * Set reply content length header for replies on the interceptor + */ + replyContentLength() { + this[kContentLength] = true; + return this; + } + }; + module2.exports.MockInterceptor = MockInterceptor; + module2.exports.MockScope = MockScope; + } +}); + +// node_modules/undici/lib/mock/mock-client.js +var require_mock_client = __commonJS({ + "node_modules/undici/lib/mock/mock-client.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Client = require_client(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockClient = class extends Client { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockClient; + } +}); + +// node_modules/undici/lib/mock/mock-pool.js +var require_mock_pool = __commonJS({ + "node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Pool = require_pool(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockPool = class extends Pool { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockPool; + } +}); + +// node_modules/undici/lib/mock/pluralizer.js +var require_pluralizer = __commonJS({ + "node_modules/undici/lib/mock/pluralizer.js"(exports2, module2) { + "use strict"; + var singulars = { + pronoun: "it", + is: "is", + was: "was", + this: "this" + }; + var plurals = { + pronoun: "they", + is: "are", + was: "were", + this: "these" + }; + module2.exports = class Pluralizer { + constructor(singular, plural) { + this.singular = singular; + this.plural = plural; + } + pluralize(count) { + const one = count === 1; + const keys = one ? singulars : plurals; + const noun = one ? this.singular : this.plural; + return { ...keys, count, noun }; + } + }; + } +}); + +// node_modules/undici/lib/mock/pending-interceptors-formatter.js +var require_pending_interceptors_formatter = __commonJS({ + "node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module2) { + "use strict"; + var { Transform } = require("stream"); + var { Console } = require("console"); + module2.exports = class PendingInterceptorsFormatter { + constructor({ disableColors } = {}) { + this.transform = new Transform({ + transform(chunk, _enc, cb) { + cb(null, chunk); + } + }); + this.logger = new Console({ + stdout: this.transform, + inspectOptions: { + colors: !disableColors && !process.env.CI + } + }); + } + format(pendingInterceptors) { + const withPrettyHeaders = pendingInterceptors.map( + ({ method, path: path3, data: { statusCode }, persist, times, timesInvoked, origin }) => ({ + Method: method, + Origin: origin, + Path: path3, + "Status code": statusCode, + Persistent: persist ? "\u2705" : "\u274C", + Invocations: timesInvoked, + Remaining: persist ? Infinity : times - timesInvoked + }) + ); + this.logger.table(withPrettyHeaders); + return this.transform.read().toString(); + } + }; + } +}); + +// node_modules/undici/lib/mock/mock-agent.js +var require_mock_agent = __commonJS({ + "node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) { + "use strict"; + var { kClients } = require_symbols(); + var Agent = require_agent(); + var { + kAgent, + kMockAgentSet, + kMockAgentGet, + kDispatches, + kIsMockActive, + kNetConnect, + kGetNetConnect, + kOptions, + kFactory + } = require_mock_symbols(); + var MockClient = require_mock_client(); + var MockPool = require_mock_pool(); + var { matchValue, buildMockOptions } = require_mock_utils(); + var { InvalidArgumentError, UndiciError } = require_errors(); + var Dispatcher = require_dispatcher(); + var Pluralizer = require_pluralizer(); + var PendingInterceptorsFormatter = require_pending_interceptors_formatter(); + var FakeWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value; + } + }; + var MockAgent = class extends Dispatcher { + constructor(opts) { + super(opts); + this[kNetConnect] = true; + this[kIsMockActive] = true; + if (opts && opts.agent && typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + const agent = opts && opts.agent ? opts.agent : new Agent(opts); + this[kAgent] = agent; + this[kClients] = agent[kClients]; + this[kOptions] = buildMockOptions(opts); + } + get(origin) { + let dispatcher = this[kMockAgentGet](origin); + if (!dispatcher) { + dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + } + return dispatcher; + } + dispatch(opts, handler) { + this.get(opts.origin); + return this[kAgent].dispatch(opts, handler); + } + async close() { + await this[kAgent].close(); + this[kClients].clear(); + } + deactivate() { + this[kIsMockActive] = false; + } + activate() { + this[kIsMockActive] = true; + } + enableNetConnect(matcher) { + if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) { + if (Array.isArray(this[kNetConnect])) { + this[kNetConnect].push(matcher); + } else { + this[kNetConnect] = [matcher]; + } + } else if (typeof matcher === "undefined") { + this[kNetConnect] = true; + } else { + throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp."); + } + } + disableNetConnect() { + this[kNetConnect] = false; + } + // This is required to bypass issues caused by using global symbols - see: + // https://github.com/nodejs/undici/issues/1447 + get isMockActive() { + return this[kIsMockActive]; + } + [kMockAgentSet](origin, dispatcher) { + this[kClients].set(origin, new FakeWeakRef(dispatcher)); + } + [kFactory](origin) { + const mockOptions = Object.assign({ agent: this }, this[kOptions]); + return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions); + } + [kMockAgentGet](origin) { + const ref = this[kClients].get(origin); + if (ref) { + return ref.deref(); + } + if (typeof origin !== "string") { + const dispatcher = this[kFactory]("http://localhost:9999"); + this[kMockAgentSet](origin, dispatcher); + return dispatcher; + } + for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) { + const nonExplicitDispatcher = nonExplicitRef.deref(); + if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) { + const dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]; + return dispatcher; + } + } + } + [kGetNetConnect]() { + return this[kNetConnect]; + } + pendingInterceptors() { + const mockAgentClients = this[kClients]; + return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending); + } + assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) { + const pending = this.pendingInterceptors(); + if (pending.length === 0) { + return; + } + const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length); + throw new UndiciError(` +${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending: + +${pendingInterceptorsFormatter.format(pending)} +`.trim()); + } + }; + module2.exports = MockAgent; + } +}); + +// node_modules/undici/lib/proxy-agent.js +var require_proxy_agent = __commonJS({ + "node_modules/undici/lib/proxy-agent.js"(exports2, module2) { + "use strict"; + var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols(); + var { URL: URL2 } = require("url"); + var Agent = require_agent(); + var Pool = require_pool(); + var DispatcherBase = require_dispatcher_base(); + var { InvalidArgumentError, RequestAbortedError } = require_errors(); + var buildConnector = require_connect(); + var kAgent = Symbol("proxy agent"); + var kClient = Symbol("proxy client"); + var kProxyHeaders = Symbol("proxy headers"); + var kRequestTls = Symbol("request tls settings"); + var kProxyTls = Symbol("proxy tls settings"); + var kConnectEndpoint = Symbol("connect endpoint function"); + function defaultProtocolPort(protocol) { + return protocol === "https:" ? 443 : 80; + } + function buildProxyOptions(opts) { + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + return { + uri: opts.uri, + protocol: opts.protocol || "https" + }; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var ProxyAgent = class extends DispatcherBase { + constructor(opts) { + super(opts); + this[kProxy] = buildProxyOptions(opts); + this[kAgent] = new Agent(opts); + this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : []; + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + const { clientFactory = defaultFactory } = opts; + if (typeof clientFactory !== "function") { + throw new InvalidArgumentError("Proxy opts.clientFactory must be a function."); + } + this[kRequestTls] = opts.requestTls; + this[kProxyTls] = opts.proxyTls; + this[kProxyHeaders] = opts.headers || {}; + const resolvedUrl = new URL2(opts.uri); + const { origin, port, host, username, password } = resolvedUrl; + if (opts.auth && opts.token) { + throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token"); + } else if (opts.auth) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`; + } else if (opts.token) { + this[kProxyHeaders]["proxy-authorization"] = opts.token; + } else if (username && password) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`; + } + const connect = buildConnector({ ...opts.proxyTls }); + this[kConnectEndpoint] = buildConnector({ ...opts.requestTls }); + this[kClient] = clientFactory(resolvedUrl, { connect }); + this[kAgent] = new Agent({ + ...opts, + connect: async (opts2, callback) => { + let requestedHost = opts2.host; + if (!opts2.port) { + requestedHost += `:${defaultProtocolPort(opts2.protocol)}`; + } + try { + const { socket, statusCode } = await this[kClient].connect({ + origin, + port, + path: requestedHost, + signal: opts2.signal, + headers: { + ...this[kProxyHeaders], + host + } + }); + if (statusCode !== 200) { + socket.on("error", () => { + }).destroy(); + callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`)); + } + if (opts2.protocol !== "https:") { + callback(null, socket); + return; + } + let servername; + if (this[kRequestTls]) { + servername = this[kRequestTls].servername; + } else { + servername = opts2.servername; + } + this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback); + } catch (err) { + callback(err); + } + } + }); + } + dispatch(opts, handler) { + const { host } = new URL2(opts.origin); + const headers = buildHeaders3(opts.headers); + throwIfProxyAuthIsSent(headers); + return this[kAgent].dispatch( + { + ...opts, + headers: { + ...headers, + host + } + }, + handler + ); + } + async [kClose]() { + await this[kAgent].close(); + await this[kClient].close(); + } + async [kDestroy]() { + await this[kAgent].destroy(); + await this[kClient].destroy(); + } + }; + function buildHeaders3(headers) { + if (Array.isArray(headers)) { + const headersPair = {}; + for (let i = 0; i < headers.length; i += 2) { + headersPair[headers[i]] = headers[i + 1]; + } + return headersPair; + } + return headers; + } + function throwIfProxyAuthIsSent(headers) { + const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization"); + if (existProxyAuth) { + throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor"); + } + } + module2.exports = ProxyAgent; + } +}); + +// node_modules/undici/lib/handler/RetryHandler.js +var require_RetryHandler = __commonJS({ + "node_modules/undici/lib/handler/RetryHandler.js"(exports2, module2) { + var assert = require("assert"); + var { kRetryHandlerDefaultRetry } = require_symbols(); + var { RequestRetryError } = require_errors(); + var { isDisturbed, parseHeaders, parseRangeHeader } = require_util(); + function calculateRetryAfterHeader(retryAfter) { + const current = Date.now(); + const diff = new Date(retryAfter).getTime() - current; + return diff; + } + var RetryHandler = class _RetryHandler { + constructor(opts, handlers) { + const { retryOptions, ...dispatchOpts } = opts; + const { + // Retry scoped + retry: retryFn, + maxRetries, + maxTimeout, + minTimeout, + timeoutFactor, + // Response scoped + methods, + errorCodes, + retryAfter, + statusCodes + } = retryOptions ?? {}; + this.dispatch = handlers.dispatch; + this.handler = handlers.handler; + this.opts = dispatchOpts; + this.abort = null; + this.aborted = false; + this.retryOpts = { + retry: retryFn ?? _RetryHandler[kRetryHandlerDefaultRetry], + retryAfter: retryAfter ?? true, + maxTimeout: maxTimeout ?? 30 * 1e3, + // 30s, + timeout: minTimeout ?? 500, + // .5s + timeoutFactor: timeoutFactor ?? 2, + maxRetries: maxRetries ?? 5, + // What errors we should retry + methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"], + // Indicates which errors to retry + statusCodes: statusCodes ?? [500, 502, 503, 504, 429], + // List of errors to retry + errorCodes: errorCodes ?? [ + "ECONNRESET", + "ECONNREFUSED", + "ENOTFOUND", + "ENETDOWN", + "ENETUNREACH", + "EHOSTDOWN", + "EHOSTUNREACH", + "EPIPE" + ] + }; + this.retryCount = 0; + this.start = 0; + this.end = null; + this.etag = null; + this.resume = null; + this.handler.onConnect((reason) => { + this.aborted = true; + if (this.abort) { + this.abort(reason); + } else { + this.reason = reason; + } + }); + } + onRequestSent() { + if (this.handler.onRequestSent) { + this.handler.onRequestSent(); + } + } + onUpgrade(statusCode, headers, socket) { + if (this.handler.onUpgrade) { + this.handler.onUpgrade(statusCode, headers, socket); + } + } + onConnect(abort) { + if (this.aborted) { + abort(this.reason); + } else { + this.abort = abort; + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) return this.handler.onBodySent(chunk); + } + static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) { + const { statusCode, code, headers } = err; + const { method, retryOptions } = opts; + const { + maxRetries, + timeout, + maxTimeout, + timeoutFactor, + statusCodes, + errorCodes, + methods + } = retryOptions; + let { counter, currentTimeout } = state; + currentTimeout = currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout; + if (code && code !== "UND_ERR_REQ_RETRY" && code !== "UND_ERR_SOCKET" && !errorCodes.includes(code)) { + cb(err); + return; + } + if (Array.isArray(methods) && !methods.includes(method)) { + cb(err); + return; + } + if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) { + cb(err); + return; + } + if (counter > maxRetries) { + cb(err); + return; + } + let retryAfterHeader = headers != null && headers["retry-after"]; + if (retryAfterHeader) { + retryAfterHeader = Number(retryAfterHeader); + retryAfterHeader = isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3; + } + const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout); + state.currentTimeout = retryTimeout; + setTimeout(() => cb(null), retryTimeout); + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const headers = parseHeaders(rawHeaders); + this.retryCount += 1; + if (statusCode >= 300) { + this.abort( + new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.resume != null) { + this.resume = null; + if (statusCode !== 206) { + return true; + } + const contentRange = parseRangeHeader(headers["content-range"]); + if (!contentRange) { + this.abort( + new RequestRetryError("Content-Range mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.etag != null && this.etag !== headers.etag) { + this.abort( + new RequestRetryError("ETag mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + const { start, size, end = size } = contentRange; + assert(this.start === start, "content-range mismatch"); + assert(this.end == null || this.end === end, "content-range mismatch"); + this.resume = resume; + return true; + } + if (this.end == null) { + if (statusCode === 206) { + const range = parseRangeHeader(headers["content-range"]); + if (range == null) { + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const { start, size, end = size } = range; + assert( + start != null && Number.isFinite(start) && this.start !== start, + "content-range mismatch" + ); + assert(Number.isFinite(start)); + assert( + end != null && Number.isFinite(end) && this.end !== end, + "invalid content-length" + ); + this.start = start; + this.end = end; + } + if (this.end == null) { + const contentLength = headers["content-length"]; + this.end = contentLength != null ? Number(contentLength) : null; + } + assert(Number.isFinite(this.start)); + assert( + this.end == null || Number.isFinite(this.end), + "invalid content-length" + ); + this.resume = resume; + this.etag = headers.etag != null ? headers.etag : null; + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const err = new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }); + this.abort(err); + return false; + } + onData(chunk) { + this.start += chunk.length; + return this.handler.onData(chunk); + } + onComplete(rawTrailers) { + this.retryCount = 0; + return this.handler.onComplete(rawTrailers); + } + onError(err) { + if (this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err); + } + this.retryOpts.retry( + err, + { + state: { counter: this.retryCount++, currentTimeout: this.retryAfter }, + opts: { retryOptions: this.retryOpts, ...this.opts } + }, + onRetry.bind(this) + ); + function onRetry(err2) { + if (err2 != null || this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err2); + } + if (this.start !== 0) { + this.opts = { + ...this.opts, + headers: { + ...this.opts.headers, + range: `bytes=${this.start}-${this.end ?? ""}` + } + }; + } + try { + this.dispatch(this.opts, this); + } catch (err3) { + this.handler.onError(err3); + } + } + } + }; + module2.exports = RetryHandler; + } +}); + +// node_modules/undici/lib/global.js +var require_global2 = __commonJS({ + "node_modules/undici/lib/global.js"(exports2, module2) { + "use strict"; + var globalDispatcher = Symbol.for("undici.globalDispatcher.1"); + var { InvalidArgumentError } = require_errors(); + var Agent = require_agent(); + if (getGlobalDispatcher() === void 0) { + setGlobalDispatcher(new Agent()); + } + function setGlobalDispatcher(agent) { + if (!agent || typeof agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument agent must implement Agent"); + } + Object.defineProperty(globalThis, globalDispatcher, { + value: agent, + writable: true, + enumerable: false, + configurable: false + }); + } + function getGlobalDispatcher() { + return globalThis[globalDispatcher]; + } + module2.exports = { + setGlobalDispatcher, + getGlobalDispatcher + }; + } +}); + +// node_modules/undici/lib/handler/DecoratorHandler.js +var require_DecoratorHandler = __commonJS({ + "node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module2) { + "use strict"; + module2.exports = class DecoratorHandler { + constructor(handler) { + this.handler = handler; + } + onConnect(...args) { + return this.handler.onConnect(...args); + } + onError(...args) { + return this.handler.onError(...args); + } + onUpgrade(...args) { + return this.handler.onUpgrade(...args); + } + onHeaders(...args) { + return this.handler.onHeaders(...args); + } + onData(...args) { + return this.handler.onData(...args); + } + onComplete(...args) { + return this.handler.onComplete(...args); + } + onBodySent(...args) { + return this.handler.onBodySent(...args); + } + }; + } +}); + +// node_modules/undici/lib/fetch/headers.js +var require_headers = __commonJS({ + "node_modules/undici/lib/fetch/headers.js"(exports2, module2) { + "use strict"; + var { kHeadersList, kConstruct } = require_symbols(); + var { kGuard } = require_symbols2(); + var { kEnumerableProperty } = require_util(); + var { + makeIterator, + isValidHeaderName, + isValidHeaderValue + } = require_util2(); + var util = require("util"); + var { webidl } = require_webidl(); + var assert = require("assert"); + var kHeadersMap = Symbol("headers map"); + var kHeadersSortedMap = Symbol("headers map sorted"); + function isHTTPWhiteSpaceCharCode(code) { + return code === 10 || code === 13 || code === 9 || code === 32; + } + function headerValueNormalize(potentialValue) { + let i = 0; + let j = potentialValue.length; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i; + return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j); + } + function fill(headers, object) { + if (Array.isArray(object)) { + for (let i = 0; i < object.length; ++i) { + const header = object[i]; + if (header.length !== 2) { + throw webidl.errors.exception({ + header: "Headers constructor", + message: `expected name/value pair to be length 2, found ${header.length}.` + }); + } + appendHeader(headers, header[0], header[1]); + } + } else if (typeof object === "object" && object !== null) { + const keys = Object.keys(object); + for (let i = 0; i < keys.length; ++i) { + appendHeader(headers, keys[i], object[keys[i]]); + } + } else { + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + } + } + function appendHeader(headers, name, value) { + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value, + type: "header value" + }); + } + if (headers[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (headers[kGuard] === "request-no-cors") { + } + return headers[kHeadersList].append(name, value); + } + var HeadersList = class _HeadersList { + /** @type {[string, string][]|null} */ + cookies = null; + constructor(init) { + if (init instanceof _HeadersList) { + this[kHeadersMap] = new Map(init[kHeadersMap]); + this[kHeadersSortedMap] = init[kHeadersSortedMap]; + this.cookies = init.cookies === null ? null : [...init.cookies]; + } else { + this[kHeadersMap] = new Map(init); + this[kHeadersSortedMap] = null; + } + } + // https://fetch.spec.whatwg.org/#header-list-contains + contains(name) { + name = name.toLowerCase(); + return this[kHeadersMap].has(name); + } + clear() { + this[kHeadersMap].clear(); + this[kHeadersSortedMap] = null; + this.cookies = null; + } + // https://fetch.spec.whatwg.org/#concept-header-list-append + append(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + const exists = this[kHeadersMap].get(lowercaseName); + if (exists) { + const delimiter = lowercaseName === "cookie" ? "; " : ", "; + this[kHeadersMap].set(lowercaseName, { + name: exists.name, + value: `${exists.value}${delimiter}${value}` + }); + } else { + this[kHeadersMap].set(lowercaseName, { name, value }); + } + if (lowercaseName === "set-cookie") { + this.cookies ??= []; + this.cookies.push(value); + } + } + // https://fetch.spec.whatwg.org/#concept-header-list-set + set(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + if (lowercaseName === "set-cookie") { + this.cookies = [value]; + } + this[kHeadersMap].set(lowercaseName, { name, value }); + } + // https://fetch.spec.whatwg.org/#concept-header-list-delete + delete(name) { + this[kHeadersSortedMap] = null; + name = name.toLowerCase(); + if (name === "set-cookie") { + this.cookies = null; + } + this[kHeadersMap].delete(name); + } + // https://fetch.spec.whatwg.org/#concept-header-list-get + get(name) { + const value = this[kHeadersMap].get(name.toLowerCase()); + return value === void 0 ? null : value.value; + } + *[Symbol.iterator]() { + for (const [name, { value }] of this[kHeadersMap]) { + yield [name, value]; + } + } + get entries() { + const headers = {}; + if (this[kHeadersMap].size) { + for (const { name, value } of this[kHeadersMap].values()) { + headers[name] = value; + } + } + return headers; + } + }; + var Headers2 = class _Headers { + constructor(init = void 0) { + if (init === kConstruct) { + return; + } + this[kHeadersList] = new HeadersList(); + this[kGuard] = "none"; + if (init !== void 0) { + init = webidl.converters.HeadersInit(init); + fill(this, init); + } + } + // https://fetch.spec.whatwg.org/#dom-headers-append + append(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + return appendHeader(this, name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-delete + delete(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.delete", + value: name, + type: "header name" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + if (!this[kHeadersList].contains(name)) { + return; + } + this[kHeadersList].delete(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-get + get(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.get", + value: name, + type: "header name" + }); + } + return this[kHeadersList].get(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-has + has(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.has", + value: name, + type: "header name" + }); + } + return this[kHeadersList].contains(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-set + set(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value, + type: "header value" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + this[kHeadersList].set(name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie + getSetCookie() { + webidl.brandCheck(this, _Headers); + const list = this[kHeadersList].cookies; + if (list) { + return [...list]; + } + return []; + } + // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine + get [kHeadersSortedMap]() { + if (this[kHeadersList][kHeadersSortedMap]) { + return this[kHeadersList][kHeadersSortedMap]; + } + const headers = []; + const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1); + const cookies = this[kHeadersList].cookies; + for (let i = 0; i < names.length; ++i) { + const [name, value] = names[i]; + if (name === "set-cookie") { + for (let j = 0; j < cookies.length; ++j) { + headers.push([name, cookies[j]]); + } + } else { + assert(value !== null); + headers.push([name, value]); + } + } + this[kHeadersList][kHeadersSortedMap] = headers; + return headers; + } + keys() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key" + ); + } + values() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "value" + ); + } + entries() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key+value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key+value" + ); + } + /** + * @param {(value: string, key: string, self: Headers) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'." + ); + } + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); + } + } + [Symbol.for("nodejs.util.inspect.custom")]() { + webidl.brandCheck(this, _Headers); + return this[kHeadersList]; + } + }; + Headers2.prototype[Symbol.iterator] = Headers2.prototype.entries; + Object.defineProperties(Headers2.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + getSetCookie: kEnumerableProperty, + keys: kEnumerableProperty, + values: kEnumerableProperty, + entries: kEnumerableProperty, + forEach: kEnumerableProperty, + [Symbol.iterator]: { enumerable: false }, + [Symbol.toStringTag]: { + value: "Headers", + configurable: true + }, + [util.inspect.custom]: { + enumerable: false + } + }); + webidl.converters.HeadersInit = function(V) { + if (webidl.util.Type(V) === "Object") { + if (V[Symbol.iterator]) { + return webidl.converters["sequence>"](V); + } + return webidl.converters["record"](V); + } + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + }; + module2.exports = { + fill, + Headers: Headers2, + HeadersList + }; + } +}); + +// node_modules/undici/lib/fetch/response.js +var require_response = __commonJS({ + "node_modules/undici/lib/fetch/response.js"(exports2, module2) { + "use strict"; + var { Headers: Headers2, HeadersList, fill } = require_headers(); + var { extractBody, cloneBody, mixinBody } = require_body(); + var util = require_util(); + var { kEnumerableProperty } = util; + var { + isValidReasonPhrase, + isCancelled, + isAborted, + isBlobLike: isBlobLike2, + serializeJavascriptValueToJSONString, + isErrorLike, + isomorphicEncode + } = require_util2(); + var { + redirectStatusSet, + nullBodyStatus, + DOMException: DOMException2 + } = require_constants2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { FormData: FormData2 } = require_formdata(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { types } = require("util"); + var ReadableStream = globalThis.ReadableStream || require("stream/web").ReadableStream; + var textEncoder = new TextEncoder("utf-8"); + var Response2 = class _Response { + // Creates network error Response. + static error() { + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kState] = makeNetworkError(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response-json + static json(data, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" }); + if (init !== null) { + init = webidl.converters.ResponseInit(init); + } + const bytes = textEncoder.encode( + serializeJavascriptValueToJSONString(data) + ); + const body = extractBody(bytes); + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "response"; + responseObject[kHeaders][kRealm] = relevantRealm; + initializeResponse(responseObject, init, { body: body[0], type: "application/json" }); + return responseObject; + } + // Creates a redirect Response that redirects to url with status status. + static redirect(url, status = 302) { + const relevantRealm = { settingsObject: {} }; + webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" }); + url = webidl.converters.USVString(url); + status = webidl.converters["unsigned short"](status); + let parsedURL; + try { + parsedURL = new URL(url, getGlobalOrigin()); + } catch (err) { + throw Object.assign(new TypeError("Failed to parse URL from " + url), { + cause: err + }); + } + if (!redirectStatusSet.has(status)) { + throw new RangeError("Invalid status code " + status); + } + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + responseObject[kState].status = status; + const value = isomorphicEncode(URLSerializer(parsedURL)); + responseObject[kState].headersList.append("location", value); + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response + constructor(body = null, init = {}) { + if (body !== null) { + body = webidl.converters.BodyInit(body); + } + init = webidl.converters.ResponseInit(init); + this[kRealm] = { settingsObject: {} }; + this[kState] = makeResponse({}); + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kGuard] = "response"; + this[kHeaders][kHeadersList] = this[kState].headersList; + this[kHeaders][kRealm] = this[kRealm]; + let bodyWithType = null; + if (body != null) { + const [extractedBody, type] = extractBody(body); + bodyWithType = { body: extractedBody, type }; + } + initializeResponse(this, init, bodyWithType); + } + // Returns response’s type, e.g., "cors". + get type() { + webidl.brandCheck(this, _Response); + return this[kState].type; + } + // Returns response’s URL, if it has one; otherwise the empty string. + get url() { + webidl.brandCheck(this, _Response); + const urlList = this[kState].urlList; + const url = urlList[urlList.length - 1] ?? null; + if (url === null) { + return ""; + } + return URLSerializer(url, true); + } + // Returns whether response was obtained through a redirect. + get redirected() { + webidl.brandCheck(this, _Response); + return this[kState].urlList.length > 1; + } + // Returns response’s status. + get status() { + webidl.brandCheck(this, _Response); + return this[kState].status; + } + // Returns whether response’s status is an ok status. + get ok() { + webidl.brandCheck(this, _Response); + return this[kState].status >= 200 && this[kState].status <= 299; + } + // Returns response’s status message. + get statusText() { + webidl.brandCheck(this, _Response); + return this[kState].statusText; + } + // Returns response’s headers as Headers. + get headers() { + webidl.brandCheck(this, _Response); + return this[kHeaders]; + } + get body() { + webidl.brandCheck(this, _Response); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Response); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + // Returns a clone of response. + clone() { + webidl.brandCheck(this, _Response); + if (this.bodyUsed || this.body && this.body.locked) { + throw webidl.errors.exception({ + header: "Response.clone", + message: "Body has already been consumed." + }); + } + const clonedResponse = cloneResponse(this[kState]); + const clonedResponseObject = new _Response(); + clonedResponseObject[kState] = clonedResponse; + clonedResponseObject[kRealm] = this[kRealm]; + clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList; + clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + return clonedResponseObject; + } + }; + mixinBody(Response2); + Object.defineProperties(Response2.prototype, { + type: kEnumerableProperty, + url: kEnumerableProperty, + status: kEnumerableProperty, + ok: kEnumerableProperty, + redirected: kEnumerableProperty, + statusText: kEnumerableProperty, + headers: kEnumerableProperty, + clone: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Response", + configurable: true + } + }); + Object.defineProperties(Response2, { + json: kEnumerableProperty, + redirect: kEnumerableProperty, + error: kEnumerableProperty + }); + function cloneResponse(response) { + if (response.internalResponse) { + return filterResponse( + cloneResponse(response.internalResponse), + response.type + ); + } + const newResponse = makeResponse({ ...response, body: null }); + if (response.body != null) { + newResponse.body = cloneBody(response.body); + } + return newResponse; + } + function makeResponse(init) { + return { + aborted: false, + rangeRequested: false, + timingAllowPassed: false, + requestIncludesCredentials: false, + type: "default", + status: 200, + timingInfo: null, + cacheState: "", + statusText: "", + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList(), + urlList: init.urlList ? [...init.urlList] : [] + }; + } + function makeNetworkError(reason) { + const isError = isErrorLike(reason); + return makeResponse({ + type: "error", + status: 0, + error: isError ? reason : new Error(reason ? String(reason) : reason), + aborted: reason && reason.name === "AbortError" + }); + } + function makeFilteredResponse(response, state) { + state = { + internalResponse: response, + ...state + }; + return new Proxy(response, { + get(target, p) { + return p in state ? state[p] : target[p]; + }, + set(target, p, value) { + assert(!(p in state)); + target[p] = value; + return true; + } + }); + } + function filterResponse(response, type) { + if (type === "basic") { + return makeFilteredResponse(response, { + type: "basic", + headersList: response.headersList + }); + } else if (type === "cors") { + return makeFilteredResponse(response, { + type: "cors", + headersList: response.headersList + }); + } else if (type === "opaque") { + return makeFilteredResponse(response, { + type: "opaque", + urlList: Object.freeze([]), + status: 0, + statusText: "", + body: null + }); + } else if (type === "opaqueredirect") { + return makeFilteredResponse(response, { + type: "opaqueredirect", + status: 0, + statusText: "", + headersList: [], + body: null + }); + } else { + assert(false); + } + } + function makeAppropriateNetworkError(fetchParams, err = null) { + assert(isCancelled(fetchParams)); + return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException2("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException2("Request was cancelled."), { cause: err })); + } + function initializeResponse(response, init, body) { + if (init.status !== null && (init.status < 200 || init.status > 599)) { + throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.'); + } + if ("statusText" in init && init.statusText != null) { + if (!isValidReasonPhrase(String(init.statusText))) { + throw new TypeError("Invalid statusText"); + } + } + if ("status" in init && init.status != null) { + response[kState].status = init.status; + } + if ("statusText" in init && init.statusText != null) { + response[kState].statusText = init.statusText; + } + if ("headers" in init && init.headers != null) { + fill(response[kHeaders], init.headers); + } + if (body) { + if (nullBodyStatus.includes(response.status)) { + throw webidl.errors.exception({ + header: "Response constructor", + message: "Invalid response status code " + response.status + }); + } + response[kState].body = body.body; + if (body.type != null && !response[kState].headersList.contains("Content-Type")) { + response[kState].headersList.append("content-type", body.type); + } + } + } + webidl.converters.ReadableStream = webidl.interfaceConverter( + ReadableStream + ); + webidl.converters.FormData = webidl.interfaceConverter( + FormData2 + ); + webidl.converters.URLSearchParams = webidl.interfaceConverter( + URLSearchParams + ); + webidl.converters.XMLHttpRequestBodyInit = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (types.isArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) { + return webidl.converters.BufferSource(V); + } + if (util.isFormDataLike(V)) { + return webidl.converters.FormData(V, { strict: false }); + } + if (V instanceof URLSearchParams) { + return webidl.converters.URLSearchParams(V); + } + return webidl.converters.DOMString(V); + }; + webidl.converters.BodyInit = function(V) { + if (V instanceof ReadableStream) { + return webidl.converters.ReadableStream(V); + } + if (V?.[Symbol.asyncIterator]) { + return V; + } + return webidl.converters.XMLHttpRequestBodyInit(V); + }; + webidl.converters.ResponseInit = webidl.dictionaryConverter([ + { + key: "status", + converter: webidl.converters["unsigned short"], + defaultValue: 200 + }, + { + key: "statusText", + converter: webidl.converters.ByteString, + defaultValue: "" + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + } + ]); + module2.exports = { + makeNetworkError, + makeResponse, + makeAppropriateNetworkError, + filterResponse, + Response: Response2, + cloneResponse + }; + } +}); + +// node_modules/undici/lib/fetch/request.js +var require_request2 = __commonJS({ + "node_modules/undici/lib/fetch/request.js"(exports2, module2) { + "use strict"; + var { extractBody, mixinBody, cloneBody } = require_body(); + var { Headers: Headers2, fill: fillHeaders, HeadersList } = require_headers(); + var { FinalizationRegistry } = require_dispatcher_weakref()(); + var util = require_util(); + var { + isValidHTTPToken, + sameOrigin, + normalizeMethod, + makePolicyContainer, + normalizeMethodRecord + } = require_util2(); + var { + forbiddenMethodsSet, + corsSafeListedMethodsSet, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + requestDuplex + } = require_constants2(); + var { kEnumerableProperty } = util; + var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events"); + var TransformStream = globalThis.TransformStream; + var kAbortController = Symbol("abortController"); + var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => { + signal.removeEventListener("abort", abort); + }); + var Request = class _Request { + // https://fetch.spec.whatwg.org/#dom-request + constructor(input, init = {}) { + if (input === kConstruct) { + return; + } + webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" }); + input = webidl.converters.RequestInfo(input); + init = webidl.converters.RequestInit(init); + this[kRealm] = { + settingsObject: { + baseUrl: getGlobalOrigin(), + get origin() { + return this.baseUrl?.origin; + }, + policyContainer: makePolicyContainer() + } + }; + let request = null; + let fallbackMode = null; + const baseUrl = this[kRealm].settingsObject.baseUrl; + let signal = null; + if (typeof input === "string") { + let parsedURL; + try { + parsedURL = new URL(input, baseUrl); + } catch (err) { + throw new TypeError("Failed to parse URL from " + input, { cause: err }); + } + if (parsedURL.username || parsedURL.password) { + throw new TypeError( + "Request cannot be constructed from a URL that includes credentials: " + input + ); + } + request = makeRequest({ urlList: [parsedURL] }); + fallbackMode = "cors"; + } else { + assert(input instanceof _Request); + request = input[kState]; + signal = input[kSignal]; + } + const origin = this[kRealm].settingsObject.origin; + let window2 = "client"; + if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) { + window2 = request.window; + } + if (init.window != null) { + throw new TypeError(`'window' option '${window2}' must be null`); + } + if ("window" in init) { + window2 = "no-window"; + } + request = makeRequest({ + // URL request’s URL. + // undici implementation note: this is set as the first item in request's urlList in makeRequest + // method request’s method. + method: request.method, + // header list A copy of request’s header list. + // undici implementation note: headersList is cloned in makeRequest + headersList: request.headersList, + // unsafe-request flag Set. + unsafeRequest: request.unsafeRequest, + // client This’s relevant settings object. + client: this[kRealm].settingsObject, + // window window. + window: window2, + // priority request’s priority. + priority: request.priority, + // origin request’s origin. The propagation of the origin is only significant for navigation requests + // being handled by a service worker. In this scenario a request can have an origin that is different + // from the current client. + origin: request.origin, + // referrer request’s referrer. + referrer: request.referrer, + // referrer policy request’s referrer policy. + referrerPolicy: request.referrerPolicy, + // mode request’s mode. + mode: request.mode, + // credentials mode request’s credentials mode. + credentials: request.credentials, + // cache mode request’s cache mode. + cache: request.cache, + // redirect mode request’s redirect mode. + redirect: request.redirect, + // integrity metadata request’s integrity metadata. + integrity: request.integrity, + // keepalive request’s keepalive. + keepalive: request.keepalive, + // reload-navigation flag request’s reload-navigation flag. + reloadNavigation: request.reloadNavigation, + // history-navigation flag request’s history-navigation flag. + historyNavigation: request.historyNavigation, + // URL list A clone of request’s URL list. + urlList: [...request.urlList] + }); + const initHasKey = Object.keys(init).length !== 0; + if (initHasKey) { + if (request.mode === "navigate") { + request.mode = "same-origin"; + } + request.reloadNavigation = false; + request.historyNavigation = false; + request.origin = "client"; + request.referrer = "client"; + request.referrerPolicy = ""; + request.url = request.urlList[request.urlList.length - 1]; + request.urlList = [request.url]; + } + if (init.referrer !== void 0) { + const referrer = init.referrer; + if (referrer === "") { + request.referrer = "no-referrer"; + } else { + let parsedReferrer; + try { + parsedReferrer = new URL(referrer, baseUrl); + } catch (err) { + throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err }); + } + if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) { + request.referrer = "client"; + } else { + request.referrer = parsedReferrer; + } + } + } + if (init.referrerPolicy !== void 0) { + request.referrerPolicy = init.referrerPolicy; + } + let mode; + if (init.mode !== void 0) { + mode = init.mode; + } else { + mode = fallbackMode; + } + if (mode === "navigate") { + throw webidl.errors.exception({ + header: "Request constructor", + message: "invalid request mode navigate." + }); + } + if (mode != null) { + request.mode = mode; + } + if (init.credentials !== void 0) { + request.credentials = init.credentials; + } + if (init.cache !== void 0) { + request.cache = init.cache; + } + if (request.cache === "only-if-cached" && request.mode !== "same-origin") { + throw new TypeError( + "'only-if-cached' can be set only with 'same-origin' mode" + ); + } + if (init.redirect !== void 0) { + request.redirect = init.redirect; + } + if (init.integrity != null) { + request.integrity = String(init.integrity); + } + if (init.keepalive !== void 0) { + request.keepalive = Boolean(init.keepalive); + } + if (init.method !== void 0) { + let method = init.method; + if (!isValidHTTPToken(method)) { + throw new TypeError(`'${method}' is not a valid HTTP method.`); + } + if (forbiddenMethodsSet.has(method.toUpperCase())) { + throw new TypeError(`'${method}' HTTP method is unsupported.`); + } + method = normalizeMethodRecord[method] ?? normalizeMethod(method); + request.method = method; + } + if (init.signal !== void 0) { + signal = init.signal; + } + this[kState] = request; + const ac = new AbortController(); + this[kSignal] = ac.signal; + this[kSignal][kRealm] = this[kRealm]; + if (signal != null) { + if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") { + throw new TypeError( + "Failed to construct 'Request': member signal is not of type AbortSignal." + ); + } + if (signal.aborted) { + ac.abort(signal.reason); + } else { + this[kAbortController] = ac; + const acRef = new WeakRef(ac); + const abort = function() { + const ac2 = acRef.deref(); + if (ac2 !== void 0) { + ac2.abort(this.reason); + } + }; + try { + if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) { + setMaxListeners(100, signal); + } else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) { + setMaxListeners(100, signal); + } + } catch { + } + util.addAbortListener(signal, abort); + requestFinalizer.register(ac, { signal, abort }); + } + } + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kHeadersList] = request.headersList; + this[kHeaders][kGuard] = "request"; + this[kHeaders][kRealm] = this[kRealm]; + if (mode === "no-cors") { + if (!corsSafeListedMethodsSet.has(request.method)) { + throw new TypeError( + `'${request.method} is unsupported in no-cors mode.` + ); + } + this[kHeaders][kGuard] = "request-no-cors"; + } + if (initHasKey) { + const headersList = this[kHeaders][kHeadersList]; + const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList); + headersList.clear(); + if (headers instanceof HeadersList) { + for (const [key, val] of headers) { + headersList.append(key, val); + } + headersList.cookies = headers.cookies; + } else { + fillHeaders(this[kHeaders], headers); + } + } + const inputBody = input instanceof _Request ? input[kState].body : null; + if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) { + throw new TypeError("Request with GET/HEAD method cannot have body."); + } + let initBody = null; + if (init.body != null) { + const [extractedBody, contentType] = extractBody( + init.body, + request.keepalive + ); + initBody = extractedBody; + if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) { + this[kHeaders].append("content-type", contentType); + } + } + const inputOrInitBody = initBody ?? inputBody; + if (inputOrInitBody != null && inputOrInitBody.source == null) { + if (initBody != null && init.duplex == null) { + throw new TypeError("RequestInit: duplex option is required when sending a body."); + } + if (request.mode !== "same-origin" && request.mode !== "cors") { + throw new TypeError( + 'If request is made from ReadableStream, mode should be "same-origin" or "cors"' + ); + } + request.useCORSPreflightFlag = true; + } + let finalBody = inputOrInitBody; + if (initBody == null && inputBody != null) { + if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) { + throw new TypeError( + "Cannot construct a Request with a Request object that has already been used." + ); + } + if (!TransformStream) { + TransformStream = require("stream/web").TransformStream; + } + const identityTransform = new TransformStream(); + inputBody.stream.pipeThrough(identityTransform); + finalBody = { + source: inputBody.source, + length: inputBody.length, + stream: identityTransform.readable + }; + } + this[kState].body = finalBody; + } + // Returns request’s HTTP method, which is "GET" by default. + get method() { + webidl.brandCheck(this, _Request); + return this[kState].method; + } + // Returns the URL of request as a string. + get url() { + webidl.brandCheck(this, _Request); + return URLSerializer(this[kState].url); + } + // Returns a Headers object consisting of the headers associated with request. + // Note that headers added in the network layer by the user agent will not + // be accounted for in this object, e.g., the "Host" header. + get headers() { + webidl.brandCheck(this, _Request); + return this[kHeaders]; + } + // Returns the kind of resource requested by request, e.g., "document" + // or "script". + get destination() { + webidl.brandCheck(this, _Request); + return this[kState].destination; + } + // Returns the referrer of request. Its value can be a same-origin URL if + // explicitly set in init, the empty string to indicate no referrer, and + // "about:client" when defaulting to the global’s default. This is used + // during fetching to determine the value of the `Referer` header of the + // request being made. + get referrer() { + webidl.brandCheck(this, _Request); + if (this[kState].referrer === "no-referrer") { + return ""; + } + if (this[kState].referrer === "client") { + return "about:client"; + } + return this[kState].referrer.toString(); + } + // Returns the referrer policy associated with request. + // This is used during fetching to compute the value of the request’s + // referrer. + get referrerPolicy() { + webidl.brandCheck(this, _Request); + return this[kState].referrerPolicy; + } + // Returns the mode associated with request, which is a string indicating + // whether the request will use CORS, or will be restricted to same-origin + // URLs. + get mode() { + webidl.brandCheck(this, _Request); + return this[kState].mode; + } + // Returns the credentials mode associated with request, + // which is a string indicating whether credentials will be sent with the + // request always, never, or only when sent to a same-origin URL. + get credentials() { + return this[kState].credentials; + } + // Returns the cache mode associated with request, + // which is a string indicating how the request will + // interact with the browser’s cache when fetching. + get cache() { + webidl.brandCheck(this, _Request); + return this[kState].cache; + } + // Returns the redirect mode associated with request, + // which is a string indicating how redirects for the + // request will be handled during fetching. A request + // will follow redirects by default. + get redirect() { + webidl.brandCheck(this, _Request); + return this[kState].redirect; + } + // Returns request’s subresource integrity metadata, which is a + // cryptographic hash of the resource being fetched. Its value + // consists of multiple hashes separated by whitespace. [SRI] + get integrity() { + webidl.brandCheck(this, _Request); + return this[kState].integrity; + } + // Returns a boolean indicating whether or not request can outlive the + // global in which it was created. + get keepalive() { + webidl.brandCheck(this, _Request); + return this[kState].keepalive; + } + // Returns a boolean indicating whether or not request is for a reload + // navigation. + get isReloadNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].reloadNavigation; + } + // Returns a boolean indicating whether or not request is for a history + // navigation (a.k.a. back-foward navigation). + get isHistoryNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].historyNavigation; + } + // Returns the signal associated with request, which is an AbortSignal + // object indicating whether or not request has been aborted, and its + // abort event handler. + get signal() { + webidl.brandCheck(this, _Request); + return this[kSignal]; + } + get body() { + webidl.brandCheck(this, _Request); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Request); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + get duplex() { + webidl.brandCheck(this, _Request); + return "half"; + } + // Returns a clone of request. + clone() { + webidl.brandCheck(this, _Request); + if (this.bodyUsed || this.body?.locked) { + throw new TypeError("unusable"); + } + const clonedRequest = cloneRequest(this[kState]); + const clonedRequestObject = new _Request(kConstruct); + clonedRequestObject[kState] = clonedRequest; + clonedRequestObject[kRealm] = this[kRealm]; + clonedRequestObject[kHeaders] = new Headers2(kConstruct); + clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList; + clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + const ac = new AbortController(); + if (this.signal.aborted) { + ac.abort(this.signal.reason); + } else { + util.addAbortListener( + this.signal, + () => { + ac.abort(this.signal.reason); + } + ); + } + clonedRequestObject[kSignal] = ac.signal; + return clonedRequestObject; + } + }; + mixinBody(Request); + function makeRequest(init) { + const request = { + method: "GET", + localURLsOnly: false, + unsafeRequest: false, + body: null, + client: null, + reservedClient: null, + replacesClientId: "", + window: "client", + keepalive: false, + serviceWorkers: "all", + initiator: "", + destination: "", + priority: null, + origin: "client", + policyContainer: "client", + referrer: "client", + referrerPolicy: "", + mode: "no-cors", + useCORSPreflightFlag: false, + credentials: "same-origin", + useCredentials: false, + cache: "default", + redirect: "follow", + integrity: "", + cryptoGraphicsNonceMetadata: "", + parserMetadata: "", + reloadNavigation: false, + historyNavigation: false, + userActivation: false, + taintedOrigin: false, + redirectCount: 0, + responseTainting: "basic", + preventNoCacheCacheControlHeaderModification: false, + done: false, + timingAllowFailed: false, + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList() + }; + request.url = request.urlList[0]; + return request; + } + function cloneRequest(request) { + const newRequest = makeRequest({ ...request, body: null }); + if (request.body != null) { + newRequest.body = cloneBody(request.body); + } + return newRequest; + } + Object.defineProperties(Request.prototype, { + method: kEnumerableProperty, + url: kEnumerableProperty, + headers: kEnumerableProperty, + redirect: kEnumerableProperty, + clone: kEnumerableProperty, + signal: kEnumerableProperty, + duplex: kEnumerableProperty, + destination: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + isHistoryNavigation: kEnumerableProperty, + isReloadNavigation: kEnumerableProperty, + keepalive: kEnumerableProperty, + integrity: kEnumerableProperty, + cache: kEnumerableProperty, + credentials: kEnumerableProperty, + attribute: kEnumerableProperty, + referrerPolicy: kEnumerableProperty, + referrer: kEnumerableProperty, + mode: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Request", + configurable: true + } + }); + webidl.converters.Request = webidl.interfaceConverter( + Request + ); + webidl.converters.RequestInfo = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (V instanceof Request) { + return webidl.converters.Request(V); + } + return webidl.converters.USVString(V); + }; + webidl.converters.AbortSignal = webidl.interfaceConverter( + AbortSignal + ); + webidl.converters.RequestInit = webidl.dictionaryConverter([ + { + key: "method", + converter: webidl.converters.ByteString + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + }, + { + key: "body", + converter: webidl.nullableConverter( + webidl.converters.BodyInit + ) + }, + { + key: "referrer", + converter: webidl.converters.USVString + }, + { + key: "referrerPolicy", + converter: webidl.converters.DOMString, + // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy + allowedValues: referrerPolicy + }, + { + key: "mode", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#concept-request-mode + allowedValues: requestMode + }, + { + key: "credentials", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcredentials + allowedValues: requestCredentials + }, + { + key: "cache", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcache + allowedValues: requestCache + }, + { + key: "redirect", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestredirect + allowedValues: requestRedirect + }, + { + key: "integrity", + converter: webidl.converters.DOMString + }, + { + key: "keepalive", + converter: webidl.converters.boolean + }, + { + key: "signal", + converter: webidl.nullableConverter( + (signal) => webidl.converters.AbortSignal( + signal, + { strict: false } + ) + ) + }, + { + key: "window", + converter: webidl.converters.any + }, + { + key: "duplex", + converter: webidl.converters.DOMString, + allowedValues: requestDuplex + } + ]); + module2.exports = { Request, makeRequest }; + } +}); + +// node_modules/undici/lib/fetch/index.js +var require_fetch = __commonJS({ + "node_modules/undici/lib/fetch/index.js"(exports2, module2) { + "use strict"; + var { + Response: Response2, + makeNetworkError, + makeAppropriateNetworkError, + filterResponse, + makeResponse + } = require_response(); + var { Headers: Headers2 } = require_headers(); + var { Request, makeRequest } = require_request2(); + var zlib = require("zlib"); + var { + bytesMatch, + makePolicyContainer, + clonePolicyContainer, + requestBadPort, + TAOCheck, + appendRequestOriginHeader, + responseLocationURL, + requestCurrentURL, + setRequestReferrerPolicyOnRedirect, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + createOpaqueTimingInfo, + appendFetchMetadata, + corsCheck, + crossOriginResourcePolicyCheck, + determineRequestsReferrer, + coarsenedSharedCurrentTime, + createDeferredPromise, + isBlobLike: isBlobLike2, + sameOrigin, + isCancelled, + isAborted, + isErrorLike, + fullyReadBody, + readableStreamClose, + isomorphicEncode, + urlIsLocal, + urlIsHttpHttpsScheme, + urlHasHttpsScheme + } = require_util2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var assert = require("assert"); + var { safelyExtractBody } = require_body(); + var { + redirectStatusSet, + nullBodyStatus, + safeMethodsSet, + requestBodyHeader, + subresourceSet, + DOMException: DOMException2 + } = require_constants2(); + var { kHeadersList } = require_symbols(); + var EE = require("events"); + var { Readable, pipeline } = require("stream"); + var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util(); + var { dataURLProcessor, serializeAMimeType } = require_dataURL(); + var { TransformStream } = require("stream/web"); + var { getGlobalDispatcher } = require_global2(); + var { webidl } = require_webidl(); + var { STATUS_CODES } = require("http"); + var GET_OR_HEAD = ["GET", "HEAD"]; + var resolveObjectURL; + var ReadableStream = globalThis.ReadableStream; + var Fetch = class extends EE { + constructor(dispatcher) { + super(); + this.dispatcher = dispatcher; + this.connection = null; + this.dump = false; + this.state = "ongoing"; + this.setMaxListeners(21); + } + terminate(reason) { + if (this.state !== "ongoing") { + return; + } + this.state = "terminated"; + this.connection?.destroy(reason); + this.emit("terminated", reason); + } + // https://fetch.spec.whatwg.org/#fetch-controller-abort + abort(error) { + if (this.state !== "ongoing") { + return; + } + this.state = "aborted"; + if (!error) { + error = new DOMException2("The operation was aborted.", "AbortError"); + } + this.serializedAbortReason = error; + this.connection?.destroy(error); + this.emit("terminated", error); + } + }; + function fetch2(input, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" }); + const p = createDeferredPromise(); + let requestObject; + try { + requestObject = new Request(input, init); + } catch (e) { + p.reject(e); + return p.promise; + } + const request = requestObject[kState]; + if (requestObject.signal.aborted) { + abortFetch(p, request, null, requestObject.signal.reason); + return p.promise; + } + const globalObject = request.client.globalObject; + if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") { + request.serviceWorkers = "none"; + } + let responseObject = null; + const relevantRealm = null; + let locallyAborted = false; + let controller = null; + addAbortListener( + requestObject.signal, + () => { + locallyAborted = true; + assert(controller != null); + controller.abort(requestObject.signal.reason); + abortFetch(p, request, responseObject, requestObject.signal.reason); + } + ); + const handleFetchDone = (response) => finalizeAndReportTiming(response, "fetch"); + const processResponse = (response) => { + if (locallyAborted) { + return Promise.resolve(); + } + if (response.aborted) { + abortFetch(p, request, responseObject, controller.serializedAbortReason); + return Promise.resolve(); + } + if (response.type === "error") { + p.reject( + Object.assign(new TypeError("fetch failed"), { cause: response.error }) + ); + return Promise.resolve(); + } + responseObject = new Response2(); + responseObject[kState] = response; + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + p.resolve(responseObject); + }; + controller = fetching({ + request, + processResponseEndOfBody: handleFetchDone, + processResponse, + dispatcher: init.dispatcher ?? getGlobalDispatcher() + // undici + }); + return p.promise; + } + function finalizeAndReportTiming(response, initiatorType = "other") { + if (response.type === "error" && response.aborted) { + return; + } + if (!response.urlList?.length) { + return; + } + const originalURL = response.urlList[0]; + let timingInfo = response.timingInfo; + let cacheState = response.cacheState; + if (!urlIsHttpHttpsScheme(originalURL)) { + return; + } + if (timingInfo === null) { + return; + } + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo({ + startTime: timingInfo.startTime + }); + cacheState = ""; + } + timingInfo.endTime = coarsenedSharedCurrentTime(); + response.timingInfo = timingInfo; + markResourceTiming( + timingInfo, + originalURL, + initiatorType, + globalThis, + cacheState + ); + } + function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) { + if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) { + performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState); + } + } + function abortFetch(p, request, responseObject, error) { + if (!error) { + error = new DOMException2("The operation was aborted.", "AbortError"); + } + p.reject(error); + if (request.body != null && isReadable(request.body?.stream)) { + request.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + if (responseObject == null) { + return; + } + const response = responseObject[kState]; + if (response.body != null && isReadable(response.body?.stream)) { + response.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + } + function fetching({ + request, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseEndOfBody, + processResponseConsumeBody, + useParallelQueue = false, + dispatcher + // undici + }) { + let taskDestination = null; + let crossOriginIsolatedCapability = false; + if (request.client != null) { + taskDestination = request.client.globalObject; + crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability; + } + const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability); + const timingInfo = createOpaqueTimingInfo({ + startTime: currenTime + }); + const fetchParams = { + controller: new Fetch(dispatcher), + request, + timingInfo, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseConsumeBody, + processResponseEndOfBody, + taskDestination, + crossOriginIsolatedCapability + }; + assert(!request.body || request.body.stream); + if (request.window === "client") { + request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window"; + } + if (request.origin === "client") { + request.origin = request.client?.origin; + } + if (request.policyContainer === "client") { + if (request.client != null) { + request.policyContainer = clonePolicyContainer( + request.client.policyContainer + ); + } else { + request.policyContainer = makePolicyContainer(); + } + } + if (!request.headersList.contains("accept")) { + const value = "*/*"; + request.headersList.append("accept", value); + } + if (!request.headersList.contains("accept-language")) { + request.headersList.append("accept-language", "*"); + } + if (request.priority === null) { + } + if (subresourceSet.has(request.destination)) { + } + mainFetch(fetchParams).catch((err) => { + fetchParams.controller.terminate(err); + }); + return fetchParams.controller; + } + async function mainFetch(fetchParams, recursive = false) { + const request = fetchParams.request; + let response = null; + if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) { + response = makeNetworkError("local URLs only"); + } + tryUpgradeRequestToAPotentiallyTrustworthyURL(request); + if (requestBadPort(request) === "blocked") { + response = makeNetworkError("bad port"); + } + if (request.referrerPolicy === "") { + request.referrerPolicy = request.policyContainer.referrerPolicy; + } + if (request.referrer !== "no-referrer") { + request.referrer = determineRequestsReferrer(request); + } + if (response === null) { + response = await (async () => { + const currentURL = requestCurrentURL(request); + if ( + // - request’s current URL’s origin is same origin with request’s origin, + // and request’s response tainting is "basic" + sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data" + currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket" + (request.mode === "navigate" || request.mode === "websocket") + ) { + request.responseTainting = "basic"; + return await schemeFetch(fetchParams); + } + if (request.mode === "same-origin") { + return makeNetworkError('request mode cannot be "same-origin"'); + } + if (request.mode === "no-cors") { + if (request.redirect !== "follow") { + return makeNetworkError( + 'redirect mode cannot be "follow" for "no-cors" request' + ); + } + request.responseTainting = "opaque"; + return await schemeFetch(fetchParams); + } + if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) { + return makeNetworkError("URL scheme must be a HTTP(S) scheme"); + } + request.responseTainting = "cors"; + return await httpFetch(fetchParams); + })(); + } + if (recursive) { + return response; + } + if (response.status !== 0 && !response.internalResponse) { + if (request.responseTainting === "cors") { + } + if (request.responseTainting === "basic") { + response = filterResponse(response, "basic"); + } else if (request.responseTainting === "cors") { + response = filterResponse(response, "cors"); + } else if (request.responseTainting === "opaque") { + response = filterResponse(response, "opaque"); + } else { + assert(false); + } + } + let internalResponse = response.status === 0 ? response : response.internalResponse; + if (internalResponse.urlList.length === 0) { + internalResponse.urlList.push(...request.urlList); + } + if (!request.timingAllowFailed) { + response.timingAllowPassed = true; + } + if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range")) { + response = internalResponse = makeNetworkError(); + } + if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) { + internalResponse.body = null; + fetchParams.controller.dump = true; + } + if (request.integrity) { + const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason)); + if (request.responseTainting === "opaque" || response.body == null) { + processBodyError(response.error); + return; + } + const processBody = (bytes) => { + if (!bytesMatch(bytes, request.integrity)) { + processBodyError("integrity mismatch"); + return; + } + response.body = safelyExtractBody(bytes)[0]; + fetchFinale(fetchParams, response); + }; + await fullyReadBody(response.body, processBody, processBodyError); + } else { + fetchFinale(fetchParams, response); + } + } + function schemeFetch(fetchParams) { + if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) { + return Promise.resolve(makeAppropriateNetworkError(fetchParams)); + } + const { request } = fetchParams; + const { protocol: scheme } = requestCurrentURL(request); + switch (scheme) { + case "about:": { + return Promise.resolve(makeNetworkError("about scheme is not supported")); + } + case "blob:": { + if (!resolveObjectURL) { + resolveObjectURL = require("buffer").resolveObjectURL; + } + const blobURLEntry = requestCurrentURL(request); + if (blobURLEntry.search.length !== 0) { + return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource.")); + } + const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString()); + if (request.method !== "GET" || !isBlobLike2(blobURLEntryObject)) { + return Promise.resolve(makeNetworkError("invalid method")); + } + const bodyWithType = safelyExtractBody(blobURLEntryObject); + const body = bodyWithType[0]; + const length = isomorphicEncode(`${body.length}`); + const type = bodyWithType[1] ?? ""; + const response = makeResponse({ + statusText: "OK", + headersList: [ + ["content-length", { name: "Content-Length", value: length }], + ["content-type", { name: "Content-Type", value: type }] + ] + }); + response.body = body; + return Promise.resolve(response); + } + case "data:": { + const currentURL = requestCurrentURL(request); + const dataURLStruct = dataURLProcessor(currentURL); + if (dataURLStruct === "failure") { + return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + } + const mimeType = serializeAMimeType(dataURLStruct.mimeType); + return Promise.resolve(makeResponse({ + statusText: "OK", + headersList: [ + ["content-type", { name: "Content-Type", value: mimeType }] + ], + body: safelyExtractBody(dataURLStruct.body)[0] + })); + } + case "file:": { + return Promise.resolve(makeNetworkError("not implemented... yet...")); + } + case "http:": + case "https:": { + return httpFetch(fetchParams).catch((err) => makeNetworkError(err)); + } + default: { + return Promise.resolve(makeNetworkError("unknown scheme")); + } + } + } + function finalizeResponse(fetchParams, response) { + fetchParams.request.done = true; + if (fetchParams.processResponseDone != null) { + queueMicrotask(() => fetchParams.processResponseDone(response)); + } + } + function fetchFinale(fetchParams, response) { + if (response.type === "error") { + response.urlList = [fetchParams.request.urlList[0]]; + response.timingInfo = createOpaqueTimingInfo({ + startTime: fetchParams.timingInfo.startTime + }); + } + const processResponseEndOfBody = () => { + fetchParams.request.done = true; + if (fetchParams.processResponseEndOfBody != null) { + queueMicrotask(() => fetchParams.processResponseEndOfBody(response)); + } + }; + if (fetchParams.processResponse != null) { + queueMicrotask(() => fetchParams.processResponse(response)); + } + if (response.body == null) { + processResponseEndOfBody(); + } else { + const identityTransformAlgorithm = (chunk, controller) => { + controller.enqueue(chunk); + }; + const transformStream = new TransformStream({ + start() { + }, + transform: identityTransformAlgorithm, + flush: processResponseEndOfBody + }, { + size() { + return 1; + } + }, { + size() { + return 1; + } + }); + response.body = { stream: response.body.stream.pipeThrough(transformStream) }; + } + if (fetchParams.processResponseConsumeBody != null) { + const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes); + const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure); + if (response.body == null) { + queueMicrotask(() => processBody(null)); + } else { + return fullyReadBody(response.body, processBody, processBodyError); + } + return Promise.resolve(); + } + } + async function httpFetch(fetchParams) { + const request = fetchParams.request; + let response = null; + let actualResponse = null; + const timingInfo = fetchParams.timingInfo; + if (request.serviceWorkers === "all") { + } + if (response === null) { + if (request.redirect === "follow") { + request.serviceWorkers = "none"; + } + actualResponse = response = await httpNetworkOrCacheFetch(fetchParams); + if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") { + return makeNetworkError("cors failure"); + } + if (TAOCheck(request, response) === "failure") { + request.timingAllowFailed = true; + } + } + if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck( + request.origin, + request.client, + request.destination, + actualResponse + ) === "blocked") { + return makeNetworkError("blocked"); + } + if (redirectStatusSet.has(actualResponse.status)) { + if (request.redirect !== "manual") { + fetchParams.controller.connection.destroy(); + } + if (request.redirect === "error") { + response = makeNetworkError("unexpected redirect"); + } else if (request.redirect === "manual") { + response = actualResponse; + } else if (request.redirect === "follow") { + response = await httpRedirectFetch(fetchParams, response); + } else { + assert(false); + } + } + response.timingInfo = timingInfo; + return response; + } + function httpRedirectFetch(fetchParams, response) { + const request = fetchParams.request; + const actualResponse = response.internalResponse ? response.internalResponse : response; + let locationURL; + try { + locationURL = responseLocationURL( + actualResponse, + requestCurrentURL(request).hash + ); + if (locationURL == null) { + return response; + } + } catch (err) { + return Promise.resolve(makeNetworkError(err)); + } + if (!urlIsHttpHttpsScheme(locationURL)) { + return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme")); + } + if (request.redirectCount === 20) { + return Promise.resolve(makeNetworkError("redirect count exceeded")); + } + request.redirectCount += 1; + if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) { + return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"')); + } + if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) { + return Promise.resolve(makeNetworkError( + 'URL cannot contain credentials for request mode "cors"' + )); + } + if (actualResponse.status !== 303 && request.body != null && request.body.source == null) { + return Promise.resolve(makeNetworkError()); + } + if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) { + request.method = "GET"; + request.body = null; + for (const headerName of requestBodyHeader) { + request.headersList.delete(headerName); + } + } + if (!sameOrigin(requestCurrentURL(request), locationURL)) { + request.headersList.delete("authorization"); + request.headersList.delete("proxy-authorization", true); + request.headersList.delete("cookie"); + request.headersList.delete("host"); + } + if (request.body != null) { + assert(request.body.source != null); + request.body = safelyExtractBody(request.body.source)[0]; + } + const timingInfo = fetchParams.timingInfo; + timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + if (timingInfo.redirectStartTime === 0) { + timingInfo.redirectStartTime = timingInfo.startTime; + } + request.urlList.push(locationURL); + setRequestReferrerPolicyOnRedirect(request, actualResponse); + return mainFetch(fetchParams, true); + } + async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) { + const request = fetchParams.request; + let httpFetchParams = null; + let httpRequest = null; + let response = null; + const httpCache = null; + const revalidatingFlag = false; + if (request.window === "no-window" && request.redirect === "error") { + httpFetchParams = fetchParams; + httpRequest = request; + } else { + httpRequest = makeRequest(request); + httpFetchParams = { ...fetchParams }; + httpFetchParams.request = httpRequest; + } + const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic"; + const contentLength = httpRequest.body ? httpRequest.body.length : null; + let contentLengthHeaderValue = null; + if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) { + contentLengthHeaderValue = "0"; + } + if (contentLength != null) { + contentLengthHeaderValue = isomorphicEncode(`${contentLength}`); + } + if (contentLengthHeaderValue != null) { + httpRequest.headersList.append("content-length", contentLengthHeaderValue); + } + if (contentLength != null && httpRequest.keepalive) { + } + if (httpRequest.referrer instanceof URL) { + httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href)); + } + appendRequestOriginHeader(httpRequest); + appendFetchMetadata(httpRequest); + if (!httpRequest.headersList.contains("user-agent")) { + httpRequest.headersList.append("user-agent", typeof esbuildDetection === "undefined" ? "undici" : "node"); + } + if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) { + httpRequest.cache = "no-store"; + } + if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "max-age=0"); + } + if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") { + if (!httpRequest.headersList.contains("pragma")) { + httpRequest.headersList.append("pragma", "no-cache"); + } + if (!httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "no-cache"); + } + } + if (httpRequest.headersList.contains("range")) { + httpRequest.headersList.append("accept-encoding", "identity"); + } + if (!httpRequest.headersList.contains("accept-encoding")) { + if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) { + httpRequest.headersList.append("accept-encoding", "br, gzip, deflate"); + } else { + httpRequest.headersList.append("accept-encoding", "gzip, deflate"); + } + } + httpRequest.headersList.delete("host"); + if (includeCredentials) { + } + if (httpCache == null) { + httpRequest.cache = "no-store"; + } + if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") { + } + if (response == null) { + if (httpRequest.mode === "only-if-cached") { + return makeNetworkError("only if cached"); + } + const forwardResponse = await httpNetworkFetch( + httpFetchParams, + includeCredentials, + isNewConnectionFetch + ); + if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) { + } + if (revalidatingFlag && forwardResponse.status === 304) { + } + if (response == null) { + response = forwardResponse; + } + } + response.urlList = [...httpRequest.urlList]; + if (httpRequest.headersList.contains("range")) { + response.rangeRequested = true; + } + response.requestIncludesCredentials = includeCredentials; + if (response.status === 407) { + if (request.window === "no-window") { + return makeNetworkError(); + } + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + return makeNetworkError("proxy authentication required"); + } + if ( + // response’s status is 421 + response.status === 421 && // isNewConnectionFetch is false + !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null + (request.body == null || request.body.source != null) + ) { + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + fetchParams.controller.connection.destroy(); + response = await httpNetworkOrCacheFetch( + fetchParams, + isAuthenticationFetch, + true + ); + } + if (isAuthenticationFetch) { + } + return response; + } + async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) { + assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed); + fetchParams.controller.connection = { + abort: null, + destroyed: false, + destroy(err) { + if (!this.destroyed) { + this.destroyed = true; + this.abort?.(err ?? new DOMException2("The operation was aborted.", "AbortError")); + } + } + }; + const request = fetchParams.request; + let response = null; + const timingInfo = fetchParams.timingInfo; + const httpCache = null; + if (httpCache == null) { + request.cache = "no-store"; + } + const newConnection = forceNewConnection ? "yes" : "no"; + if (request.mode === "websocket") { + } else { + } + let requestBody = null; + if (request.body == null && fetchParams.processRequestEndOfBody) { + queueMicrotask(() => fetchParams.processRequestEndOfBody()); + } else if (request.body != null) { + const processBodyChunk = async function* (bytes) { + if (isCancelled(fetchParams)) { + return; + } + yield bytes; + fetchParams.processRequestBodyChunkLength?.(bytes.byteLength); + }; + const processEndOfBody = () => { + if (isCancelled(fetchParams)) { + return; + } + if (fetchParams.processRequestEndOfBody) { + fetchParams.processRequestEndOfBody(); + } + }; + const processBodyError = (e) => { + if (isCancelled(fetchParams)) { + return; + } + if (e.name === "AbortError") { + fetchParams.controller.abort(); + } else { + fetchParams.controller.terminate(e); + } + }; + requestBody = async function* () { + try { + for await (const bytes of request.body.stream) { + yield* processBodyChunk(bytes); + } + processEndOfBody(); + } catch (err) { + processBodyError(err); + } + }(); + } + try { + const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody }); + if (socket) { + response = makeResponse({ status, statusText, headersList, socket }); + } else { + const iterator = body[Symbol.asyncIterator](); + fetchParams.controller.next = () => iterator.next(); + response = makeResponse({ status, statusText, headersList }); + } + } catch (err) { + if (err.name === "AbortError") { + fetchParams.controller.connection.destroy(); + return makeAppropriateNetworkError(fetchParams, err); + } + return makeNetworkError(err); + } + const pullAlgorithm = () => { + fetchParams.controller.resume(); + }; + const cancelAlgorithm = (reason) => { + fetchParams.controller.abort(reason); + }; + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + const stream = new ReadableStream( + { + async start(controller) { + fetchParams.controller.controller = controller; + }, + async pull(controller) { + await pullAlgorithm(controller); + }, + async cancel(reason) { + await cancelAlgorithm(reason); + } + }, + { + highWaterMark: 0, + size() { + return 1; + } + } + ); + response.body = { stream }; + fetchParams.controller.on("terminated", onAborted); + fetchParams.controller.resume = async () => { + while (true) { + let bytes; + let isFailure; + try { + const { done, value } = await fetchParams.controller.next(); + if (isAborted(fetchParams)) { + break; + } + bytes = done ? void 0 : value; + } catch (err) { + if (fetchParams.controller.ended && !timingInfo.encodedBodySize) { + bytes = void 0; + } else { + bytes = err; + isFailure = true; + } + } + if (bytes === void 0) { + readableStreamClose(fetchParams.controller.controller); + finalizeResponse(fetchParams, response); + return; + } + timingInfo.decodedBodySize += bytes?.byteLength ?? 0; + if (isFailure) { + fetchParams.controller.terminate(bytes); + return; + } + fetchParams.controller.controller.enqueue(new Uint8Array(bytes)); + if (isErrored(stream)) { + fetchParams.controller.terminate(); + return; + } + if (!fetchParams.controller.controller.desiredSize) { + return; + } + } + }; + function onAborted(reason) { + if (isAborted(fetchParams)) { + response.aborted = true; + if (isReadable(stream)) { + fetchParams.controller.controller.error( + fetchParams.controller.serializedAbortReason + ); + } + } else { + if (isReadable(stream)) { + fetchParams.controller.controller.error(new TypeError("terminated", { + cause: isErrorLike(reason) ? reason : void 0 + })); + } + } + fetchParams.controller.connection.destroy(); + } + return response; + async function dispatch({ body }) { + const url = requestCurrentURL(request); + const agent = fetchParams.controller.dispatcher; + return new Promise((resolve, reject) => agent.dispatch( + { + path: url.pathname + url.search, + origin: url.origin, + method: request.method, + body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body, + headers: request.headersList.entries, + maxRedirections: 0, + upgrade: request.mode === "websocket" ? "websocket" : void 0 + }, + { + body: null, + abort: null, + onConnect(abort) { + const { connection } = fetchParams.controller; + if (connection.destroyed) { + abort(new DOMException2("The operation was aborted.", "AbortError")); + } else { + fetchParams.controller.on("terminated", abort); + this.abort = connection.abort = abort; + } + }, + onHeaders(status, headersList, resume, statusText) { + if (status < 200) { + return; + } + let codings = []; + let location = ""; + const headers = new Headers2(); + if (Array.isArray(headersList)) { + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } else { + const keys = Object.keys(headersList); + for (const key of keys) { + const val = headersList[key]; + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()).reverse(); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } + this.body = new Readable({ read: resume }); + const decoders = []; + const willFollow = request.redirect === "follow" && location && redirectStatusSet.has(status); + if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) { + for (const coding of codings) { + if (coding === "x-gzip" || coding === "gzip") { + decoders.push(zlib.createGunzip({ + // 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. + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + } else if (coding === "deflate") { + decoders.push(zlib.createInflate()); + } else if (coding === "br") { + decoders.push(zlib.createBrotliDecompress()); + } else { + decoders.length = 0; + break; + } + } + } + resolve({ + status, + statusText, + headersList: headers[kHeadersList], + body: decoders.length ? pipeline(this.body, ...decoders, () => { + }) : this.body.on("error", () => { + }) + }); + return true; + }, + onData(chunk) { + if (fetchParams.controller.dump) { + return; + } + const bytes = chunk; + timingInfo.encodedBodySize += bytes.byteLength; + return this.body.push(bytes); + }, + onComplete() { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + fetchParams.controller.ended = true; + this.body.push(null); + }, + onError(error) { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + this.body?.destroy(error); + fetchParams.controller.terminate(error); + reject(error); + }, + onUpgrade(status, headersList, socket) { + if (status !== 101) { + return; + } + const headers = new Headers2(); + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + headers[kHeadersList].append(key, val); + } + resolve({ + status, + statusText: STATUS_CODES[status], + headersList: headers[kHeadersList], + socket + }); + return true; + } + } + )); + } + } + module2.exports = { + fetch: fetch2, + Fetch, + fetching, + finalizeAndReportTiming + }; + } +}); + +// node_modules/undici/lib/fileapi/symbols.js +var require_symbols3 = __commonJS({ + "node_modules/undici/lib/fileapi/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kState: Symbol("FileReader state"), + kResult: Symbol("FileReader result"), + kError: Symbol("FileReader error"), + kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"), + kEvents: Symbol("FileReader events"), + kAborted: Symbol("FileReader aborted") + }; + } +}); + +// node_modules/undici/lib/fileapi/progressevent.js +var require_progressevent = __commonJS({ + "node_modules/undici/lib/fileapi/progressevent.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var kState = Symbol("ProgressEvent state"); + var ProgressEvent = class _ProgressEvent extends Event { + constructor(type, eventInitDict = {}) { + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {}); + super(type, eventInitDict); + this[kState] = { + lengthComputable: eventInitDict.lengthComputable, + loaded: eventInitDict.loaded, + total: eventInitDict.total + }; + } + get lengthComputable() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].lengthComputable; + } + get loaded() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].loaded; + } + get total() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].total; + } + }; + webidl.converters.ProgressEventInit = webidl.dictionaryConverter([ + { + key: "lengthComputable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "loaded", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "total", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]); + module2.exports = { + ProgressEvent + }; + } +}); + +// node_modules/undici/lib/fileapi/encoding.js +var require_encoding = __commonJS({ + "node_modules/undici/lib/fileapi/encoding.js"(exports2, module2) { + "use strict"; + function getEncoding(label) { + if (!label) { + return "failure"; + } + switch (label.trim().toLowerCase()) { + case "unicode-1-1-utf-8": + case "unicode11utf8": + case "unicode20utf8": + case "utf-8": + case "utf8": + case "x-unicode20utf8": + return "UTF-8"; + case "866": + case "cp866": + case "csibm866": + case "ibm866": + return "IBM866"; + case "csisolatin2": + case "iso-8859-2": + case "iso-ir-101": + case "iso8859-2": + case "iso88592": + case "iso_8859-2": + case "iso_8859-2:1987": + case "l2": + case "latin2": + return "ISO-8859-2"; + case "csisolatin3": + case "iso-8859-3": + case "iso-ir-109": + case "iso8859-3": + case "iso88593": + case "iso_8859-3": + case "iso_8859-3:1988": + case "l3": + case "latin3": + return "ISO-8859-3"; + case "csisolatin4": + case "iso-8859-4": + case "iso-ir-110": + case "iso8859-4": + case "iso88594": + case "iso_8859-4": + case "iso_8859-4:1988": + case "l4": + case "latin4": + return "ISO-8859-4"; + case "csisolatincyrillic": + case "cyrillic": + case "iso-8859-5": + case "iso-ir-144": + case "iso8859-5": + case "iso88595": + case "iso_8859-5": + case "iso_8859-5:1988": + return "ISO-8859-5"; + case "arabic": + case "asmo-708": + case "csiso88596e": + case "csiso88596i": + case "csisolatinarabic": + case "ecma-114": + case "iso-8859-6": + case "iso-8859-6-e": + case "iso-8859-6-i": + case "iso-ir-127": + case "iso8859-6": + case "iso88596": + case "iso_8859-6": + case "iso_8859-6:1987": + return "ISO-8859-6"; + case "csisolatingreek": + case "ecma-118": + case "elot_928": + case "greek": + case "greek8": + case "iso-8859-7": + case "iso-ir-126": + case "iso8859-7": + case "iso88597": + case "iso_8859-7": + case "iso_8859-7:1987": + case "sun_eu_greek": + return "ISO-8859-7"; + case "csiso88598e": + case "csisolatinhebrew": + case "hebrew": + case "iso-8859-8": + case "iso-8859-8-e": + case "iso-ir-138": + case "iso8859-8": + case "iso88598": + case "iso_8859-8": + case "iso_8859-8:1988": + case "visual": + return "ISO-8859-8"; + case "csiso88598i": + case "iso-8859-8-i": + case "logical": + return "ISO-8859-8-I"; + case "csisolatin6": + case "iso-8859-10": + case "iso-ir-157": + case "iso8859-10": + case "iso885910": + case "l6": + case "latin6": + return "ISO-8859-10"; + case "iso-8859-13": + case "iso8859-13": + case "iso885913": + return "ISO-8859-13"; + case "iso-8859-14": + case "iso8859-14": + case "iso885914": + return "ISO-8859-14"; + case "csisolatin9": + case "iso-8859-15": + case "iso8859-15": + case "iso885915": + case "iso_8859-15": + case "l9": + return "ISO-8859-15"; + case "iso-8859-16": + return "ISO-8859-16"; + case "cskoi8r": + case "koi": + case "koi8": + case "koi8-r": + case "koi8_r": + return "KOI8-R"; + case "koi8-ru": + case "koi8-u": + return "KOI8-U"; + case "csmacintosh": + case "mac": + case "macintosh": + case "x-mac-roman": + return "macintosh"; + case "iso-8859-11": + case "iso8859-11": + case "iso885911": + case "tis-620": + case "windows-874": + return "windows-874"; + case "cp1250": + case "windows-1250": + case "x-cp1250": + return "windows-1250"; + case "cp1251": + case "windows-1251": + case "x-cp1251": + return "windows-1251"; + case "ansi_x3.4-1968": + case "ascii": + case "cp1252": + case "cp819": + case "csisolatin1": + case "ibm819": + case "iso-8859-1": + case "iso-ir-100": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "iso_8859-1:1987": + case "l1": + case "latin1": + case "us-ascii": + case "windows-1252": + case "x-cp1252": + return "windows-1252"; + case "cp1253": + case "windows-1253": + case "x-cp1253": + return "windows-1253"; + case "cp1254": + case "csisolatin5": + case "iso-8859-9": + case "iso-ir-148": + case "iso8859-9": + case "iso88599": + case "iso_8859-9": + case "iso_8859-9:1989": + case "l5": + case "latin5": + case "windows-1254": + case "x-cp1254": + return "windows-1254"; + case "cp1255": + case "windows-1255": + case "x-cp1255": + return "windows-1255"; + case "cp1256": + case "windows-1256": + case "x-cp1256": + return "windows-1256"; + case "cp1257": + case "windows-1257": + case "x-cp1257": + return "windows-1257"; + case "cp1258": + case "windows-1258": + case "x-cp1258": + return "windows-1258"; + case "x-mac-cyrillic": + case "x-mac-ukrainian": + return "x-mac-cyrillic"; + case "chinese": + case "csgb2312": + case "csiso58gb231280": + case "gb2312": + case "gb_2312": + case "gb_2312-80": + case "gbk": + case "iso-ir-58": + case "x-gbk": + return "GBK"; + case "gb18030": + return "gb18030"; + case "big5": + case "big5-hkscs": + case "cn-big5": + case "csbig5": + case "x-x-big5": + return "Big5"; + case "cseucpkdfmtjapanese": + case "euc-jp": + case "x-euc-jp": + return "EUC-JP"; + case "csiso2022jp": + case "iso-2022-jp": + return "ISO-2022-JP"; + case "csshiftjis": + case "ms932": + case "ms_kanji": + case "shift-jis": + case "shift_jis": + case "sjis": + case "windows-31j": + case "x-sjis": + return "Shift_JIS"; + case "cseuckr": + case "csksc56011987": + case "euc-kr": + case "iso-ir-149": + case "korean": + case "ks_c_5601-1987": + case "ks_c_5601-1989": + case "ksc5601": + case "ksc_5601": + case "windows-949": + return "EUC-KR"; + case "csiso2022kr": + case "hz-gb-2312": + case "iso-2022-cn": + case "iso-2022-cn-ext": + case "iso-2022-kr": + case "replacement": + return "replacement"; + case "unicodefffe": + case "utf-16be": + return "UTF-16BE"; + case "csunicode": + case "iso-10646-ucs-2": + case "ucs-2": + case "unicode": + case "unicodefeff": + case "utf-16": + case "utf-16le": + return "UTF-16LE"; + case "x-user-defined": + return "x-user-defined"; + default: + return "failure"; + } + } + module2.exports = { + getEncoding + }; + } +}); + +// node_modules/undici/lib/fileapi/util.js +var require_util4 = __commonJS({ + "node_modules/undici/lib/fileapi/util.js"(exports2, module2) { + "use strict"; + var { + kState, + kError, + kResult, + kAborted, + kLastProgressEventFired + } = require_symbols3(); + var { ProgressEvent } = require_progressevent(); + var { getEncoding } = require_encoding(); + var { DOMException: DOMException2 } = require_constants2(); + var { serializeAMimeType, parseMIMEType } = require_dataURL(); + var { types } = require("util"); + var { StringDecoder } = require("string_decoder"); + var { btoa } = require("buffer"); + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + function readOperation(fr, blob, type, encodingName) { + if (fr[kState] === "loading") { + throw new DOMException2("Invalid state", "InvalidStateError"); + } + fr[kState] = "loading"; + fr[kResult] = null; + fr[kError] = null; + const stream = blob.stream(); + const reader = stream.getReader(); + const bytes = []; + let chunkPromise = reader.read(); + let isFirstChunk = true; + (async () => { + while (!fr[kAborted]) { + try { + const { done, value } = await chunkPromise; + if (isFirstChunk && !fr[kAborted]) { + queueMicrotask(() => { + fireAProgressEvent("loadstart", fr); + }); + } + isFirstChunk = false; + if (!done && types.isUint8Array(value)) { + bytes.push(value); + if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) { + fr[kLastProgressEventFired] = Date.now(); + queueMicrotask(() => { + fireAProgressEvent("progress", fr); + }); + } + chunkPromise = reader.read(); + } else if (done) { + queueMicrotask(() => { + fr[kState] = "done"; + try { + const result = packageData(bytes, type, blob.type, encodingName); + if (fr[kAborted]) { + return; + } + fr[kResult] = result; + fireAProgressEvent("load", fr); + } catch (error) { + fr[kError] = error; + fireAProgressEvent("error", fr); + } + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } catch (error) { + if (fr[kAborted]) { + return; + } + queueMicrotask(() => { + fr[kState] = "done"; + fr[kError] = error; + fireAProgressEvent("error", fr); + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } + })(); + } + function fireAProgressEvent(e, reader) { + const event = new ProgressEvent(e, { + bubbles: false, + cancelable: false + }); + reader.dispatchEvent(event); + } + function packageData(bytes, type, mimeType, encodingName) { + switch (type) { + case "DataURL": { + let dataURL = "data:"; + const parsed = parseMIMEType(mimeType || "application/octet-stream"); + if (parsed !== "failure") { + dataURL += serializeAMimeType(parsed); + } + dataURL += ";base64,"; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + dataURL += btoa(decoder.write(chunk)); + } + dataURL += btoa(decoder.end()); + return dataURL; + } + case "Text": { + let encoding = "failure"; + if (encodingName) { + encoding = getEncoding(encodingName); + } + if (encoding === "failure" && mimeType) { + const type2 = parseMIMEType(mimeType); + if (type2 !== "failure") { + encoding = getEncoding(type2.parameters.get("charset")); + } + } + if (encoding === "failure") { + encoding = "UTF-8"; + } + return decode(bytes, encoding); + } + case "ArrayBuffer": { + const sequence = combineByteSequences(bytes); + return sequence.buffer; + } + case "BinaryString": { + let binaryString = ""; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + binaryString += decoder.write(chunk); + } + binaryString += decoder.end(); + return binaryString; + } + } + } + function decode(ioQueue, encoding) { + const bytes = combineByteSequences(ioQueue); + const BOMEncoding = BOMSniffing(bytes); + let slice = 0; + if (BOMEncoding !== null) { + encoding = BOMEncoding; + slice = BOMEncoding === "UTF-8" ? 3 : 2; + } + const sliced = bytes.slice(slice); + return new TextDecoder(encoding).decode(sliced); + } + function BOMSniffing(ioQueue) { + const [a, b, c] = ioQueue; + if (a === 239 && b === 187 && c === 191) { + return "UTF-8"; + } else if (a === 254 && b === 255) { + return "UTF-16BE"; + } else if (a === 255 && b === 254) { + return "UTF-16LE"; + } + return null; + } + function combineByteSequences(sequences) { + const size = sequences.reduce((a, b) => { + return a + b.byteLength; + }, 0); + let offset = 0; + return sequences.reduce((a, b) => { + a.set(b, offset); + offset += b.byteLength; + return a; + }, new Uint8Array(size)); + } + module2.exports = { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + }; + } +}); + +// node_modules/undici/lib/fileapi/filereader.js +var require_filereader = __commonJS({ + "node_modules/undici/lib/fileapi/filereader.js"(exports2, module2) { + "use strict"; + var { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + } = require_util4(); + var { + kState, + kError, + kResult, + kEvents, + kAborted + } = require_symbols3(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var FileReader = class _FileReader extends EventTarget { + constructor() { + super(); + this[kState] = "empty"; + this[kResult] = null; + this[kError] = null; + this[kEvents] = { + loadend: null, + error: null, + abort: null, + load: null, + progress: null, + loadstart: null + }; + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer + * @param {import('buffer').Blob} blob + */ + readAsArrayBuffer(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "ArrayBuffer"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsBinaryString + * @param {import('buffer').Blob} blob + */ + readAsBinaryString(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "BinaryString"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsDataText + * @param {import('buffer').Blob} blob + * @param {string?} encoding + */ + readAsText(blob, encoding = void 0) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" }); + blob = webidl.converters.Blob(blob, { strict: false }); + if (encoding !== void 0) { + encoding = webidl.converters.DOMString(encoding); + } + readOperation(this, blob, "Text", encoding); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL + * @param {import('buffer').Blob} blob + */ + readAsDataURL(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "DataURL"); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-abort + */ + abort() { + if (this[kState] === "empty" || this[kState] === "done") { + this[kResult] = null; + return; + } + if (this[kState] === "loading") { + this[kState] = "done"; + this[kResult] = null; + } + this[kAborted] = true; + fireAProgressEvent("abort", this); + if (this[kState] !== "loading") { + fireAProgressEvent("loadend", this); + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate + */ + get readyState() { + webidl.brandCheck(this, _FileReader); + switch (this[kState]) { + case "empty": + return this.EMPTY; + case "loading": + return this.LOADING; + case "done": + return this.DONE; + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-result + */ + get result() { + webidl.brandCheck(this, _FileReader); + return this[kResult]; + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-error + */ + get error() { + webidl.brandCheck(this, _FileReader); + return this[kError]; + } + get onloadend() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadend; + } + set onloadend(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadend) { + this.removeEventListener("loadend", this[kEvents].loadend); + } + if (typeof fn === "function") { + this[kEvents].loadend = fn; + this.addEventListener("loadend", fn); + } else { + this[kEvents].loadend = null; + } + } + get onerror() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].error; + } + set onerror(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].error) { + this.removeEventListener("error", this[kEvents].error); + } + if (typeof fn === "function") { + this[kEvents].error = fn; + this.addEventListener("error", fn); + } else { + this[kEvents].error = null; + } + } + get onloadstart() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadstart; + } + set onloadstart(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadstart) { + this.removeEventListener("loadstart", this[kEvents].loadstart); + } + if (typeof fn === "function") { + this[kEvents].loadstart = fn; + this.addEventListener("loadstart", fn); + } else { + this[kEvents].loadstart = null; + } + } + get onprogress() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].progress; + } + set onprogress(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].progress) { + this.removeEventListener("progress", this[kEvents].progress); + } + if (typeof fn === "function") { + this[kEvents].progress = fn; + this.addEventListener("progress", fn); + } else { + this[kEvents].progress = null; + } + } + get onload() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].load; + } + set onload(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].load) { + this.removeEventListener("load", this[kEvents].load); + } + if (typeof fn === "function") { + this[kEvents].load = fn; + this.addEventListener("load", fn); + } else { + this[kEvents].load = null; + } + } + get onabort() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].abort; + } + set onabort(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].abort) { + this.removeEventListener("abort", this[kEvents].abort); + } + if (typeof fn === "function") { + this[kEvents].abort = fn; + this.addEventListener("abort", fn); + } else { + this[kEvents].abort = null; + } + } + }; + FileReader.EMPTY = FileReader.prototype.EMPTY = 0; + FileReader.LOADING = FileReader.prototype.LOADING = 1; + FileReader.DONE = FileReader.prototype.DONE = 2; + Object.defineProperties(FileReader.prototype, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors, + readAsArrayBuffer: kEnumerableProperty, + readAsBinaryString: kEnumerableProperty, + readAsText: kEnumerableProperty, + readAsDataURL: kEnumerableProperty, + abort: kEnumerableProperty, + readyState: kEnumerableProperty, + result: kEnumerableProperty, + error: kEnumerableProperty, + onloadstart: kEnumerableProperty, + onprogress: kEnumerableProperty, + onload: kEnumerableProperty, + onabort: kEnumerableProperty, + onerror: kEnumerableProperty, + onloadend: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FileReader", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(FileReader, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors + }); + module2.exports = { + FileReader + }; + } +}); + +// node_modules/undici/lib/cache/symbols.js +var require_symbols4 = __commonJS({ + "node_modules/undici/lib/cache/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kConstruct: require_symbols().kConstruct + }; + } +}); + +// node_modules/undici/lib/cache/util.js +var require_util5 = __commonJS({ + "node_modules/undici/lib/cache/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { URLSerializer } = require_dataURL(); + var { isValidHeaderName } = require_util2(); + function urlEquals(A, B, excludeFragment = false) { + const serializedA = URLSerializer(A, excludeFragment); + const serializedB = URLSerializer(B, excludeFragment); + return serializedA === serializedB; + } + function fieldValues(header) { + assert(header !== null); + const values = []; + for (let value of header.split(",")) { + value = value.trim(); + if (!value.length) { + continue; + } else if (!isValidHeaderName(value)) { + continue; + } + values.push(value); + } + return values; + } + module2.exports = { + urlEquals, + fieldValues + }; + } +}); + +// node_modules/undici/lib/cache/cache.js +var require_cache = __commonJS({ + "node_modules/undici/lib/cache/cache.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { urlEquals, fieldValues: getFieldValues } = require_util5(); + var { kEnumerableProperty, isDisturbed } = require_util(); + var { kHeadersList } = require_symbols(); + var { webidl } = require_webidl(); + var { Response: Response2, cloneResponse } = require_response(); + var { Request } = require_request2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { fetching } = require_fetch(); + var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util2(); + var assert = require("assert"); + var { getGlobalDispatcher } = require_global2(); + var Cache3 = class _Cache { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list + * @type {requestResponseList} + */ + #relevantRequestResponseList; + constructor() { + if (arguments[0] !== kConstruct) { + webidl.illegalConstructor(); + } + this.#relevantRequestResponseList = arguments[1]; + } + async match(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.match" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + const p = await this.matchAll(request, options); + if (p.length === 0) { + return; + } + return p[0]; + } + async matchAll(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } + } + const responses = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + responses.push(requestResponse[1]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + responses.push(requestResponse[1]); + } + } + const responseList = []; + for (const response of responses) { + const responseObject = new Response2(response.body?.source ?? null); + const body = responseObject[kState].body; + responseObject[kState] = response; + responseObject[kState].body = body; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseList.push(responseObject); + } + return Object.freeze(responseList); + } + async add(request) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.add" }); + request = webidl.converters.RequestInfo(request); + const requests = [request]; + const responseArrayPromise = this.addAll(requests); + return await responseArrayPromise; + } + async addAll(requests) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.addAll" }); + requests = webidl.converters["sequence"](requests); + const responsePromises = []; + const requestList = []; + for (const request of requests) { + if (typeof request === "string") { + continue; + } + const r = request[kState]; + if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme when method is not GET." + }); + } + } + const fetchControllers = []; + for (const request of requests) { + const r = new Request(request)[kState]; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme." + }); + } + r.initiator = "fetch"; + r.destination = "subresource"; + requestList.push(r); + const responsePromise = createDeferredPromise(); + fetchControllers.push(fetching({ + request: r, + dispatcher: getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "Received an invalid status code or the request failed." + })); + } else if (response.headersList.contains("vary")) { + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "invalid vary field value" + })); + for (const controller of fetchControllers) { + controller.abort(); + } + return; + } + } + } + }, + processResponseEndOfBody(response) { + if (response.aborted) { + responsePromise.reject(new DOMException("aborted", "AbortError")); + return; + } + responsePromise.resolve(response); + } + })); + responsePromises.push(responsePromise.promise); + } + const p = Promise.all(responsePromises); + const responses = await p; + const operations = []; + let index = 0; + for (const response of responses) { + const operation = { + type: "put", + // 7.3.2 + request: requestList[index], + // 7.3.3 + response + // 7.3.4 + }; + operations.push(operation); + index++; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(void 0); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async put(request, response) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 2, { header: "Cache.put" }); + request = webidl.converters.RequestInfo(request); + response = webidl.converters.Response(response); + let innerRequest = null; + if (request instanceof Request) { + innerRequest = request[kState]; + } else { + innerRequest = new Request(request)[kState]; + } + if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Expected an http/s scheme when method is not GET" + }); + } + const innerResponse = response[kState]; + if (innerResponse.status === 206) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got 206 status" + }); + } + if (innerResponse.headersList.contains("vary")) { + const fieldValues = getFieldValues(innerResponse.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got * vary field value" + }); + } + } + } + if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Response body is locked or disturbed" + }); + } + const clonedResponse = cloneResponse(innerResponse); + const bodyReadPromise = createDeferredPromise(); + if (innerResponse.body != null) { + const stream = innerResponse.body.stream; + const reader = stream.getReader(); + readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject); + } else { + bodyReadPromise.resolve(void 0); + } + const operations = []; + const operation = { + type: "put", + // 14. + request: innerRequest, + // 15. + response: clonedResponse + // 16. + }; + operations.push(operation); + const bytes = await bodyReadPromise.promise; + if (clonedResponse.body != null) { + clonedResponse.body.source = bytes; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async delete(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.delete" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return false; + } + } else { + assert(typeof request === "string"); + r = new Request(request)[kState]; + } + const operations = []; + const operation = { + type: "delete", + request: r, + options + }; + operations.push(operation); + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + let requestResponses; + try { + requestResponses = this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(!!requestResponses?.length); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys + * @param {any} request + * @param {import('../../types/cache').CacheQueryOptions} options + * @returns {readonly Request[]} + */ + async keys(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } + } + const promise = createDeferredPromise(); + const requests = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + requests.push(requestResponse[0]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + requests.push(requestResponse[0]); + } + } + queueMicrotask(() => { + const requestList = []; + for (const request2 of requests) { + const requestObject = new Request("https://a"); + requestObject[kState] = request2; + requestObject[kHeaders][kHeadersList] = request2.headersList; + requestObject[kHeaders][kGuard] = "immutable"; + requestObject[kRealm] = request2.client; + requestList.push(requestObject); + } + promise.resolve(Object.freeze(requestList)); + }); + return promise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm + * @param {CacheBatchOperation[]} operations + * @returns {requestResponseList} + */ + #batchCacheOperations(operations) { + const cache = this.#relevantRequestResponseList; + const backupCache = [...cache]; + const addedItems = []; + const resultList = []; + try { + for (const operation of operations) { + if (operation.type !== "delete" && operation.type !== "put") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: 'operation type does not match "delete" or "put"' + }); + } + if (operation.type === "delete" && operation.response != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "delete operation should not have an associated response" + }); + } + if (this.#queryCache(operation.request, operation.options, addedItems).length) { + throw new DOMException("???", "InvalidStateError"); + } + let requestResponses; + if (operation.type === "delete") { + requestResponses = this.#queryCache(operation.request, operation.options); + if (requestResponses.length === 0) { + return []; + } + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + } else if (operation.type === "put") { + if (operation.response == null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "put operation should have an associated response" + }); + } + const r = operation.request; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "expected http or https scheme" + }); + } + if (r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "not get method" + }); + } + if (operation.options != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "options must not be defined" + }); + } + requestResponses = this.#queryCache(operation.request); + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + cache.push([operation.request, operation.response]); + addedItems.push([operation.request, operation.response]); + } + resultList.push([operation.request, operation.response]); + } + return resultList; + } catch (e) { + this.#relevantRequestResponseList.length = 0; + this.#relevantRequestResponseList = backupCache; + throw e; + } + } + /** + * @see https://w3c.github.io/ServiceWorker/#query-cache + * @param {any} requestQuery + * @param {import('../../types/cache').CacheQueryOptions} options + * @param {requestResponseList} targetStorage + * @returns {requestResponseList} + */ + #queryCache(requestQuery, options, targetStorage) { + const resultList = []; + const storage = targetStorage ?? this.#relevantRequestResponseList; + for (const requestResponse of storage) { + const [cachedRequest, cachedResponse] = requestResponse; + if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) { + resultList.push(requestResponse); + } + } + return resultList; + } + /** + * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm + * @param {any} requestQuery + * @param {any} request + * @param {any | null} response + * @param {import('../../types/cache').CacheQueryOptions | undefined} options + * @returns {boolean} + */ + #requestMatchesCachedItem(requestQuery, request, response = null, options) { + const queryURL = new URL(requestQuery.url); + const cachedURL = new URL(request.url); + if (options?.ignoreSearch) { + cachedURL.search = ""; + queryURL.search = ""; + } + if (!urlEquals(queryURL, cachedURL, true)) { + return false; + } + if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) { + return true; + } + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + return false; + } + const requestValue = request.headersList.get(fieldValue); + const queryValue = requestQuery.headersList.get(fieldValue); + if (requestValue !== queryValue) { + return false; + } + } + return true; + } + }; + Object.defineProperties(Cache3.prototype, { + [Symbol.toStringTag]: { + value: "Cache", + configurable: true + }, + match: kEnumerableProperty, + matchAll: kEnumerableProperty, + add: kEnumerableProperty, + addAll: kEnumerableProperty, + put: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + var cacheQueryOptionConverters = [ + { + key: "ignoreSearch", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreMethod", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreVary", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters); + webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([ + ...cacheQueryOptionConverters, + { + key: "cacheName", + converter: webidl.converters.DOMString + } + ]); + webidl.converters.Response = webidl.interfaceConverter(Response2); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.RequestInfo + ); + module2.exports = { + Cache: Cache3 + }; + } +}); + +// node_modules/undici/lib/cache/cachestorage.js +var require_cachestorage = __commonJS({ + "node_modules/undici/lib/cache/cachestorage.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { Cache: Cache3 } = require_cache(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var CacheStorage = class _CacheStorage { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map + * @type {Map} + */ + async has(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.has" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.has(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open + * @param {string} cacheName + * @returns {Promise} + */ + async open(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.open" }); + cacheName = webidl.converters.DOMString(cacheName); + if (this.#caches.has(cacheName)) { + const cache2 = this.#caches.get(cacheName); + return new Cache3(kConstruct, cache2); + } + const cache = []; + this.#caches.set(cacheName, cache); + return new Cache3(kConstruct, cache); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete + * @param {string} cacheName + * @returns {Promise} + */ + async delete(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.delete" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.delete(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys + * @returns {string[]} + */ + async keys() { + webidl.brandCheck(this, _CacheStorage); + const keys = this.#caches.keys(); + return [...keys]; + } + }; + Object.defineProperties(CacheStorage.prototype, { + [Symbol.toStringTag]: { + value: "CacheStorage", + configurable: true + }, + match: kEnumerableProperty, + has: kEnumerableProperty, + open: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + module2.exports = { + CacheStorage + }; + } +}); + +// node_modules/undici/lib/cookies/constants.js +var require_constants4 = __commonJS({ + "node_modules/undici/lib/cookies/constants.js"(exports2, module2) { + "use strict"; + var maxAttributeValueSize = 1024; + var maxNameValuePairSize = 4096; + module2.exports = { + maxAttributeValueSize, + maxNameValuePairSize + }; + } +}); + +// node_modules/undici/lib/cookies/util.js +var require_util6 = __commonJS({ + "node_modules/undici/lib/cookies/util.js"(exports2, module2) { + "use strict"; + function isCTLExcludingHtab(value) { + if (value.length === 0) { + return false; + } + for (const char of value) { + const code = char.charCodeAt(0); + if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) { + return false; + } + } + } + function validateCookieName(name) { + for (const char of name) { + const code = char.charCodeAt(0); + if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") { + throw new Error("Invalid cookie name"); + } + } + } + function validateCookieValue(value) { + for (const char of value) { + const code = char.charCodeAt(0); + if (code < 33 || // exclude CTLs (0-31) + code === 34 || code === 44 || code === 59 || code === 92 || code > 126) { + throw new Error("Invalid header value"); + } + } + } + function validateCookiePath(path3) { + for (const char of path3) { + const code = char.charCodeAt(0); + if (code < 33 || char === ";") { + throw new Error("Invalid cookie path"); + } + } + } + function validateCookieDomain(domain) { + if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) { + throw new Error("Invalid cookie domain"); + } + } + function toIMFDate(date) { + if (typeof date === "number") { + date = new Date(date); + } + const days = [ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat" + ]; + const months = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + const dayName = days[date.getUTCDay()]; + const day = date.getUTCDate().toString().padStart(2, "0"); + const month = months[date.getUTCMonth()]; + const year = date.getUTCFullYear(); + const hour = date.getUTCHours().toString().padStart(2, "0"); + const minute = date.getUTCMinutes().toString().padStart(2, "0"); + const second = date.getUTCSeconds().toString().padStart(2, "0"); + return `${dayName}, ${day} ${month} ${year} ${hour}:${minute}:${second} GMT`; + } + function validateCookieMaxAge(maxAge) { + if (maxAge < 0) { + throw new Error("Invalid cookie max-age"); + } + } + function stringify3(cookie) { + if (cookie.name.length === 0) { + return null; + } + validateCookieName(cookie.name); + validateCookieValue(cookie.value); + const out = [`${cookie.name}=${cookie.value}`]; + if (cookie.name.startsWith("__Secure-")) { + cookie.secure = true; + } + if (cookie.name.startsWith("__Host-")) { + cookie.secure = true; + cookie.domain = null; + cookie.path = "/"; + } + if (cookie.secure) { + out.push("Secure"); + } + if (cookie.httpOnly) { + out.push("HttpOnly"); + } + if (typeof cookie.maxAge === "number") { + validateCookieMaxAge(cookie.maxAge); + out.push(`Max-Age=${cookie.maxAge}`); + } + if (cookie.domain) { + validateCookieDomain(cookie.domain); + out.push(`Domain=${cookie.domain}`); + } + if (cookie.path) { + validateCookiePath(cookie.path); + out.push(`Path=${cookie.path}`); + } + if (cookie.expires && cookie.expires.toString() !== "Invalid Date") { + out.push(`Expires=${toIMFDate(cookie.expires)}`); + } + if (cookie.sameSite) { + out.push(`SameSite=${cookie.sameSite}`); + } + for (const part of cookie.unparsed) { + if (!part.includes("=")) { + throw new Error("Invalid unparsed"); + } + const [key, ...value] = part.split("="); + out.push(`${key.trim()}=${value.join("=")}`); + } + return out.join("; "); + } + module2.exports = { + isCTLExcludingHtab, + validateCookieName, + validateCookiePath, + validateCookieValue, + toIMFDate, + stringify: stringify3 + }; + } +}); + +// node_modules/undici/lib/cookies/parse.js +var require_parse = __commonJS({ + "node_modules/undici/lib/cookies/parse.js"(exports2, module2) { + "use strict"; + var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4(); + var { isCTLExcludingHtab } = require_util6(); + var { collectASequenceOfCodePointsFast } = require_dataURL(); + var assert = require("assert"); + function parseSetCookie(header) { + if (isCTLExcludingHtab(header)) { + return null; + } + let nameValuePair = ""; + let unparsedAttributes = ""; + let name = ""; + let value = ""; + if (header.includes(";")) { + const position = { position: 0 }; + nameValuePair = collectASequenceOfCodePointsFast(";", header, position); + unparsedAttributes = header.slice(position.position); + } else { + nameValuePair = header; + } + if (!nameValuePair.includes("=")) { + value = nameValuePair; + } else { + const position = { position: 0 }; + name = collectASequenceOfCodePointsFast( + "=", + nameValuePair, + position + ); + value = nameValuePair.slice(position.position + 1); + } + name = name.trim(); + value = value.trim(); + if (name.length + value.length > maxNameValuePairSize) { + return null; + } + return { + name, + value, + ...parseUnparsedAttributes(unparsedAttributes) + }; + } + function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) { + if (unparsedAttributes.length === 0) { + return cookieAttributeList; + } + assert(unparsedAttributes[0] === ";"); + unparsedAttributes = unparsedAttributes.slice(1); + let cookieAv = ""; + if (unparsedAttributes.includes(";")) { + cookieAv = collectASequenceOfCodePointsFast( + ";", + unparsedAttributes, + { position: 0 } + ); + unparsedAttributes = unparsedAttributes.slice(cookieAv.length); + } else { + cookieAv = unparsedAttributes; + unparsedAttributes = ""; + } + let attributeName = ""; + let attributeValue = ""; + if (cookieAv.includes("=")) { + const position = { position: 0 }; + attributeName = collectASequenceOfCodePointsFast( + "=", + cookieAv, + position + ); + attributeValue = cookieAv.slice(position.position + 1); + } else { + attributeName = cookieAv; + } + attributeName = attributeName.trim(); + attributeValue = attributeValue.trim(); + if (attributeValue.length > maxAttributeValueSize) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const attributeNameLowercase = attributeName.toLowerCase(); + if (attributeNameLowercase === "expires") { + const expiryTime = new Date(attributeValue); + cookieAttributeList.expires = expiryTime; + } else if (attributeNameLowercase === "max-age") { + const charCode = attributeValue.charCodeAt(0); + if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + if (!/^\d+$/.test(attributeValue)) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const deltaSeconds = Number(attributeValue); + cookieAttributeList.maxAge = deltaSeconds; + } else if (attributeNameLowercase === "domain") { + let cookieDomain = attributeValue; + if (cookieDomain[0] === ".") { + cookieDomain = cookieDomain.slice(1); + } + cookieDomain = cookieDomain.toLowerCase(); + cookieAttributeList.domain = cookieDomain; + } else if (attributeNameLowercase === "path") { + let cookiePath = ""; + if (attributeValue.length === 0 || attributeValue[0] !== "/") { + cookiePath = "/"; + } else { + cookiePath = attributeValue; + } + cookieAttributeList.path = cookiePath; + } else if (attributeNameLowercase === "secure") { + cookieAttributeList.secure = true; + } else if (attributeNameLowercase === "httponly") { + cookieAttributeList.httpOnly = true; + } else if (attributeNameLowercase === "samesite") { + let enforcement = "Default"; + const attributeValueLowercase = attributeValue.toLowerCase(); + if (attributeValueLowercase.includes("none")) { + enforcement = "None"; + } + if (attributeValueLowercase.includes("strict")) { + enforcement = "Strict"; + } + if (attributeValueLowercase.includes("lax")) { + enforcement = "Lax"; + } + cookieAttributeList.sameSite = enforcement; + } else { + cookieAttributeList.unparsed ??= []; + cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`); + } + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + module2.exports = { + parseSetCookie, + parseUnparsedAttributes + }; + } +}); + +// node_modules/undici/lib/cookies/index.js +var require_cookies = __commonJS({ + "node_modules/undici/lib/cookies/index.js"(exports2, module2) { + "use strict"; + var { parseSetCookie } = require_parse(); + var { stringify: stringify3 } = require_util6(); + var { webidl } = require_webidl(); + var { Headers: Headers2 } = require_headers(); + function getCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookie = headers.get("cookie"); + const out = {}; + if (!cookie) { + return out; + } + for (const piece of cookie.split(";")) { + const [name, ...value] = piece.split("="); + out[name.trim()] = value.join("="); + } + return out; + } + function deleteCookie(headers, name, attributes) { + webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + name = webidl.converters.DOMString(name); + attributes = webidl.converters.DeleteCookieAttributes(attributes); + setCookie(headers, { + name, + value: "", + expires: /* @__PURE__ */ new Date(0), + ...attributes + }); + } + function getSetCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookies = headers.getSetCookie(); + if (!cookies) { + return []; + } + return cookies.map((pair) => parseSetCookie(pair)); + } + function setCookie(headers, cookie) { + webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + cookie = webidl.converters.Cookie(cookie); + const str = stringify3(cookie); + if (str) { + headers.append("Set-Cookie", stringify3(cookie)); + } + } + webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([ + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + } + ]); + webidl.converters.Cookie = webidl.dictionaryConverter([ + { + converter: webidl.converters.DOMString, + key: "name" + }, + { + converter: webidl.converters.DOMString, + key: "value" + }, + { + converter: webidl.nullableConverter((value) => { + if (typeof value === "number") { + return webidl.converters["unsigned long long"](value); + } + return new Date(value); + }), + key: "expires", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters["long long"]), + key: "maxAge", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "secure", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "httpOnly", + defaultValue: null + }, + { + converter: webidl.converters.USVString, + key: "sameSite", + allowedValues: ["Strict", "Lax", "None"] + }, + { + converter: webidl.sequenceConverter(webidl.converters.DOMString), + key: "unparsed", + defaultValue: [] + } + ]); + module2.exports = { + getCookies, + deleteCookie, + getSetCookies, + setCookie + }; + } +}); + +// node_modules/undici/lib/websocket/constants.js +var require_constants5 = __commonJS({ + "node_modules/undici/lib/websocket/constants.js"(exports2, module2) { + "use strict"; + var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + var states = { + CONNECTING: 0, + OPEN: 1, + CLOSING: 2, + CLOSED: 3 + }; + var opcodes = { + CONTINUATION: 0, + TEXT: 1, + BINARY: 2, + CLOSE: 8, + PING: 9, + PONG: 10 + }; + var maxUnsigned16Bit = 2 ** 16 - 1; + var parserStates = { + INFO: 0, + PAYLOADLENGTH_16: 2, + PAYLOADLENGTH_64: 3, + READ_DATA: 4 + }; + var emptyBuffer = Buffer.allocUnsafe(0); + module2.exports = { + uid, + staticPropertyDescriptors, + states, + opcodes, + maxUnsigned16Bit, + parserStates, + emptyBuffer + }; + } +}); + +// node_modules/undici/lib/websocket/symbols.js +var require_symbols5 = __commonJS({ + "node_modules/undici/lib/websocket/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kWebSocketURL: Symbol("url"), + kReadyState: Symbol("ready state"), + kController: Symbol("controller"), + kResponse: Symbol("response"), + kBinaryType: Symbol("binary type"), + kSentClose: Symbol("sent close"), + kReceivedClose: Symbol("received close"), + kByteParser: Symbol("byte parser") + }; + } +}); + +// node_modules/undici/lib/websocket/events.js +var require_events = __commonJS({ + "node_modules/undici/lib/websocket/events.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var { MessagePort } = require("worker_threads"); + var MessageEvent = class _MessageEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.MessageEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get data() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.data; + } + get origin() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.origin; + } + get lastEventId() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.lastEventId; + } + get source() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.source; + } + get ports() { + webidl.brandCheck(this, _MessageEvent); + if (!Object.isFrozen(this.#eventInit.ports)) { + Object.freeze(this.#eventInit.ports); + } + return this.#eventInit.ports; + } + initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) { + webidl.brandCheck(this, _MessageEvent); + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" }); + return new _MessageEvent(type, { + bubbles, + cancelable, + data, + origin, + lastEventId, + source, + ports + }); + } + }; + var CloseEvent = class _CloseEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.CloseEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get wasClean() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.wasClean; + } + get code() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.code; + } + get reason() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.reason; + } + }; + var ErrorEvent = class _ErrorEvent extends Event { + #eventInit; + constructor(type, eventInitDict) { + webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" }); + super(type, eventInitDict); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {}); + this.#eventInit = eventInitDict; + } + get message() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.message; + } + get filename() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.filename; + } + get lineno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.lineno; + } + get colno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.colno; + } + get error() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.error; + } + }; + Object.defineProperties(MessageEvent.prototype, { + [Symbol.toStringTag]: { + value: "MessageEvent", + configurable: true + }, + data: kEnumerableProperty, + origin: kEnumerableProperty, + lastEventId: kEnumerableProperty, + source: kEnumerableProperty, + ports: kEnumerableProperty, + initMessageEvent: kEnumerableProperty + }); + Object.defineProperties(CloseEvent.prototype, { + [Symbol.toStringTag]: { + value: "CloseEvent", + configurable: true + }, + reason: kEnumerableProperty, + code: kEnumerableProperty, + wasClean: kEnumerableProperty + }); + Object.defineProperties(ErrorEvent.prototype, { + [Symbol.toStringTag]: { + value: "ErrorEvent", + configurable: true + }, + message: kEnumerableProperty, + filename: kEnumerableProperty, + lineno: kEnumerableProperty, + colno: kEnumerableProperty, + error: kEnumerableProperty + }); + webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.MessagePort + ); + var eventInit = [ + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.MessageEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "data", + converter: webidl.converters.any, + defaultValue: null + }, + { + key: "origin", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lastEventId", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "source", + // Node doesn't implement WindowProxy or ServiceWorker, so the only + // valid value for source is a MessagePort. + converter: webidl.nullableConverter(webidl.converters.MessagePort), + defaultValue: null + }, + { + key: "ports", + converter: webidl.converters["sequence"], + get defaultValue() { + return []; + } + } + ]); + webidl.converters.CloseEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "wasClean", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "code", + converter: webidl.converters["unsigned short"], + defaultValue: 0 + }, + { + key: "reason", + converter: webidl.converters.USVString, + defaultValue: "" + } + ]); + webidl.converters.ErrorEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "message", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "filename", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lineno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "colno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "error", + converter: webidl.converters.any + } + ]); + module2.exports = { + MessageEvent, + CloseEvent, + ErrorEvent + }; + } +}); + +// node_modules/undici/lib/websocket/util.js +var require_util7 = __commonJS({ + "node_modules/undici/lib/websocket/util.js"(exports2, module2) { + "use strict"; + var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5(); + var { states, opcodes } = require_constants5(); + var { MessageEvent, ErrorEvent } = require_events(); + function isEstablished(ws) { + return ws[kReadyState] === states.OPEN; + } + function isClosing(ws) { + return ws[kReadyState] === states.CLOSING; + } + function isClosed(ws) { + return ws[kReadyState] === states.CLOSED; + } + function fireEvent(e, target, eventConstructor = Event, eventInitDict) { + const event = new eventConstructor(e, eventInitDict); + target.dispatchEvent(event); + } + function websocketMessageReceived(ws, type, data) { + if (ws[kReadyState] !== states.OPEN) { + return; + } + let dataForEvent; + if (type === opcodes.TEXT) { + try { + dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data); + } catch { + failWebsocketConnection(ws, "Received invalid UTF-8 in text frame."); + return; + } + } else if (type === opcodes.BINARY) { + if (ws[kBinaryType] === "blob") { + dataForEvent = new Blob([data]); + } else { + dataForEvent = new Uint8Array(data).buffer; + } + } + fireEvent("message", ws, MessageEvent, { + origin: ws[kWebSocketURL].origin, + data: dataForEvent + }); + } + function isValidSubprotocol(protocol) { + if (protocol.length === 0) { + return false; + } + for (const char of protocol) { + const code = char.charCodeAt(0); + if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP + code === 9) { + return false; + } + } + return true; + } + function isValidStatusCode(code) { + if (code >= 1e3 && code < 1015) { + return code !== 1004 && // reserved + code !== 1005 && // "MUST NOT be set as a status code" + code !== 1006; + } + return code >= 3e3 && code <= 4999; + } + function failWebsocketConnection(ws, reason) { + const { [kController]: controller, [kResponse]: response } = ws; + controller.abort(); + if (response?.socket && !response.socket.destroyed) { + response.socket.destroy(); + } + if (reason) { + fireEvent("error", ws, ErrorEvent, { + error: new Error(reason) + }); + } + } + module2.exports = { + isEstablished, + isClosing, + isClosed, + fireEvent, + isValidSubprotocol, + isValidStatusCode, + failWebsocketConnection, + websocketMessageReceived + }; + } +}); + +// node_modules/undici/lib/websocket/connection.js +var require_connection = __commonJS({ + "node_modules/undici/lib/websocket/connection.js"(exports2, module2) { + "use strict"; + var diagnosticsChannel = require("diagnostics_channel"); + var { uid, states } = require_constants5(); + var { + kReadyState, + kSentClose, + kByteParser, + kReceivedClose + } = require_symbols5(); + var { fireEvent, failWebsocketConnection } = require_util7(); + var { CloseEvent } = require_events(); + var { makeRequest } = require_request2(); + var { fetching } = require_fetch(); + var { Headers: Headers2 } = require_headers(); + var { getGlobalDispatcher } = require_global2(); + var { kHeadersList } = require_symbols(); + var channels = {}; + channels.open = diagnosticsChannel.channel("undici:websocket:open"); + channels.close = diagnosticsChannel.channel("undici:websocket:close"); + channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error"); + var crypto; + try { + crypto = require("crypto"); + } catch { + } + function establishWebSocketConnection(url, protocols, ws, onEstablish, options) { + const requestURL = url; + requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:"; + const request = makeRequest({ + urlList: [requestURL], + serviceWorkers: "none", + referrer: "no-referrer", + mode: "websocket", + credentials: "include", + cache: "no-store", + redirect: "error" + }); + if (options.headers) { + const headersList = new Headers2(options.headers)[kHeadersList]; + request.headersList = headersList; + } + const keyValue = crypto.randomBytes(16).toString("base64"); + request.headersList.append("sec-websocket-key", keyValue); + request.headersList.append("sec-websocket-version", "13"); + for (const protocol of protocols) { + request.headersList.append("sec-websocket-protocol", protocol); + } + const permessageDeflate = ""; + const controller = fetching({ + request, + useParallelQueue: true, + dispatcher: options.dispatcher ?? getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status !== 101) { + failWebsocketConnection(ws, "Received network error or non-101 status code."); + return; + } + if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Server did not respond with sent protocols."); + return; + } + if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") { + failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".'); + return; + } + if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") { + failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".'); + return; + } + const secWSAccept = response.headersList.get("Sec-WebSocket-Accept"); + const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64"); + if (secWSAccept !== digest) { + failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header."); + return; + } + const secExtension = response.headersList.get("Sec-WebSocket-Extensions"); + if (secExtension !== null && secExtension !== permessageDeflate) { + failWebsocketConnection(ws, "Received different permessage-deflate than the one set."); + return; + } + const secProtocol = response.headersList.get("Sec-WebSocket-Protocol"); + if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Protocol was not set in the opening handshake."); + return; + } + response.socket.on("data", onSocketData); + response.socket.on("close", onSocketClose); + response.socket.on("error", onSocketError); + if (channels.open.hasSubscribers) { + channels.open.publish({ + address: response.socket.address(), + protocol: secProtocol, + extensions: secExtension + }); + } + onEstablish(response); + } + }); + return controller; + } + function onSocketData(chunk) { + if (!this.ws[kByteParser].write(chunk)) { + this.pause(); + } + } + function onSocketClose() { + const { ws } = this; + const wasClean = ws[kSentClose] && ws[kReceivedClose]; + let code = 1005; + let reason = ""; + const result = ws[kByteParser].closingInfo; + if (result) { + code = result.code ?? 1005; + reason = result.reason; + } else if (!ws[kSentClose]) { + code = 1006; + } + ws[kReadyState] = states.CLOSED; + fireEvent("close", ws, CloseEvent, { + wasClean, + code, + reason + }); + if (channels.close.hasSubscribers) { + channels.close.publish({ + websocket: ws, + code, + reason + }); + } + } + function onSocketError(error) { + const { ws } = this; + ws[kReadyState] = states.CLOSING; + if (channels.socketError.hasSubscribers) { + channels.socketError.publish(error); + } + this.destroy(); + } + module2.exports = { + establishWebSocketConnection + }; + } +}); + +// node_modules/undici/lib/websocket/frame.js +var require_frame = __commonJS({ + "node_modules/undici/lib/websocket/frame.js"(exports2, module2) { + "use strict"; + var { maxUnsigned16Bit } = require_constants5(); + var crypto; + try { + crypto = require("crypto"); + } catch { + } + var WebsocketFrameSend = class { + /** + * @param {Buffer|undefined} data + */ + constructor(data) { + this.frameData = data; + this.maskKey = crypto.randomBytes(4); + } + createFrame(opcode) { + const bodyLength = this.frameData?.byteLength ?? 0; + let payloadLength = bodyLength; + let offset = 6; + if (bodyLength > maxUnsigned16Bit) { + offset += 8; + payloadLength = 127; + } else if (bodyLength > 125) { + offset += 2; + payloadLength = 126; + } + const buffer = Buffer.allocUnsafe(bodyLength + offset); + buffer[0] = buffer[1] = 0; + buffer[0] |= 128; + buffer[0] = (buffer[0] & 240) + opcode; + buffer[offset - 4] = this.maskKey[0]; + buffer[offset - 3] = this.maskKey[1]; + buffer[offset - 2] = this.maskKey[2]; + buffer[offset - 1] = this.maskKey[3]; + buffer[1] = payloadLength; + if (payloadLength === 126) { + buffer.writeUInt16BE(bodyLength, 2); + } else if (payloadLength === 127) { + buffer[2] = buffer[3] = 0; + buffer.writeUIntBE(bodyLength, 4, 6); + } + buffer[1] |= 128; + for (let i = 0; i < bodyLength; i++) { + buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4]; + } + return buffer; + } + }; + module2.exports = { + WebsocketFrameSend + }; + } +}); + +// node_modules/undici/lib/websocket/receiver.js +var require_receiver = __commonJS({ + "node_modules/undici/lib/websocket/receiver.js"(exports2, module2) { + "use strict"; + var { Writable } = require("stream"); + var diagnosticsChannel = require("diagnostics_channel"); + var { parserStates, opcodes, states, emptyBuffer } = require_constants5(); + var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5(); + var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util7(); + var { WebsocketFrameSend } = require_frame(); + var channels = {}; + channels.ping = diagnosticsChannel.channel("undici:websocket:ping"); + channels.pong = diagnosticsChannel.channel("undici:websocket:pong"); + var ByteParser = class extends Writable { + #buffers = []; + #byteOffset = 0; + #state = parserStates.INFO; + #info = {}; + #fragments = []; + constructor(ws) { + super(); + this.ws = ws; + } + /** + * @param {Buffer} chunk + * @param {() => void} callback + */ + _write(chunk, _, callback) { + this.#buffers.push(chunk); + this.#byteOffset += chunk.length; + this.run(callback); + } + /** + * Runs whenever a new chunk is received. + * Callback is called whenever there are no more chunks buffering, + * or not enough bytes are buffered to parse. + */ + run(callback) { + while (true) { + if (this.#state === parserStates.INFO) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.fin = (buffer[0] & 128) !== 0; + this.#info.opcode = buffer[0] & 15; + this.#info.originalOpcode ??= this.#info.opcode; + this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION; + if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) { + failWebsocketConnection(this.ws, "Invalid frame type was fragmented."); + return; + } + const payloadLength = buffer[1] & 127; + if (payloadLength <= 125) { + this.#info.payloadLength = payloadLength; + this.#state = parserStates.READ_DATA; + } else if (payloadLength === 126) { + this.#state = parserStates.PAYLOADLENGTH_16; + } else if (payloadLength === 127) { + this.#state = parserStates.PAYLOADLENGTH_64; + } + if (this.#info.fragmented && payloadLength > 125) { + failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes."); + return; + } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) { + failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes."); + return; + } else if (this.#info.opcode === opcodes.CLOSE) { + if (payloadLength === 1) { + failWebsocketConnection(this.ws, "Received close frame with a 1-byte body."); + return; + } + const body = this.consume(payloadLength); + this.#info.closeInfo = this.parseCloseBody(false, body); + if (!this.ws[kSentClose]) { + const body2 = Buffer.allocUnsafe(2); + body2.writeUInt16BE(this.#info.closeInfo.code, 0); + const closeFrame = new WebsocketFrameSend(body2); + this.ws[kResponse].socket.write( + closeFrame.createFrame(opcodes.CLOSE), + (err) => { + if (!err) { + this.ws[kSentClose] = true; + } + } + ); + } + this.ws[kReadyState] = states.CLOSING; + this.ws[kReceivedClose] = true; + this.end(); + return; + } else if (this.#info.opcode === opcodes.PING) { + const body = this.consume(payloadLength); + if (!this.ws[kReceivedClose]) { + const frame = new WebsocketFrameSend(body); + this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG)); + if (channels.ping.hasSubscribers) { + channels.ping.publish({ + payload: body + }); + } + } + this.#state = parserStates.INFO; + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } + } else if (this.#info.opcode === opcodes.PONG) { + const body = this.consume(payloadLength); + if (channels.pong.hasSubscribers) { + channels.pong.publish({ + payload: body + }); + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } + } + } else if (this.#state === parserStates.PAYLOADLENGTH_16) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.payloadLength = buffer.readUInt16BE(0); + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.PAYLOADLENGTH_64) { + if (this.#byteOffset < 8) { + return callback(); + } + const buffer = this.consume(8); + const upper = buffer.readUInt32BE(0); + if (upper > 2 ** 31 - 1) { + failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes."); + return; + } + const lower = buffer.readUInt32BE(4); + this.#info.payloadLength = (upper << 8) + lower; + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.READ_DATA) { + if (this.#byteOffset < this.#info.payloadLength) { + return callback(); + } else if (this.#byteOffset >= this.#info.payloadLength) { + const body = this.consume(this.#info.payloadLength); + this.#fragments.push(body); + if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) { + const fullMessage = Buffer.concat(this.#fragments); + websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage); + this.#info = {}; + this.#fragments.length = 0; + } + this.#state = parserStates.INFO; + } + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + break; + } + } + } + /** + * Take n bytes from the buffered Buffers + * @param {number} n + * @returns {Buffer|null} + */ + consume(n) { + if (n > this.#byteOffset) { + return null; + } else if (n === 0) { + return emptyBuffer; + } + if (this.#buffers[0].length === n) { + this.#byteOffset -= this.#buffers[0].length; + return this.#buffers.shift(); + } + const buffer = Buffer.allocUnsafe(n); + let offset = 0; + while (offset !== n) { + const next = this.#buffers[0]; + const { length } = next; + if (length + offset === n) { + buffer.set(this.#buffers.shift(), offset); + break; + } else if (length + offset > n) { + buffer.set(next.subarray(0, n - offset), offset); + this.#buffers[0] = next.subarray(n - offset); + break; + } else { + buffer.set(this.#buffers.shift(), offset); + offset += next.length; + } + } + this.#byteOffset -= n; + return buffer; + } + parseCloseBody(onlyCode, data) { + let code; + if (data.length >= 2) { + code = data.readUInt16BE(0); + } + if (onlyCode) { + if (!isValidStatusCode(code)) { + return null; + } + return { code }; + } + let reason = data.subarray(2); + if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) { + reason = reason.subarray(3); + } + if (code !== void 0 && !isValidStatusCode(code)) { + return null; + } + try { + reason = new TextDecoder("utf-8", { fatal: true }).decode(reason); + } catch { + return null; + } + return { code, reason }; + } + get closingInfo() { + return this.#info.closeInfo; + } + }; + module2.exports = { + ByteParser + }; + } +}); + +// node_modules/undici/lib/websocket/websocket.js +var require_websocket = __commonJS({ + "node_modules/undici/lib/websocket/websocket.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { DOMException: DOMException2 } = require_constants2(); + var { URLSerializer } = require_dataURL(); + var { getGlobalOrigin } = require_global(); + var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants5(); + var { + kWebSocketURL, + kReadyState, + kController, + kBinaryType, + kResponse, + kSentClose, + kByteParser + } = require_symbols5(); + var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util7(); + var { establishWebSocketConnection } = require_connection(); + var { WebsocketFrameSend } = require_frame(); + var { ByteParser } = require_receiver(); + var { kEnumerableProperty, isBlobLike: isBlobLike2 } = require_util(); + var { getGlobalDispatcher } = require_global2(); + var { types } = require("util"); + var experimentalWarned = false; + var WebSocket = class _WebSocket extends EventTarget { + #events = { + open: null, + error: null, + close: null, + message: null + }; + #bufferedAmount = 0; + #protocol = ""; + #extensions = ""; + /** + * @param {string} url + * @param {string|string[]} protocols + */ + constructor(url, protocols = []) { + super(); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" }); + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("WebSockets are experimental, expect them to change at any time.", { + code: "UNDICI-WS" + }); + } + const options = webidl.converters["DOMString or sequence or WebSocketInit"](protocols); + url = webidl.converters.USVString(url); + protocols = options.protocols; + const baseURL = getGlobalOrigin(); + let urlRecord; + try { + urlRecord = new URL(url, baseURL); + } catch (e) { + throw new DOMException2(e, "SyntaxError"); + } + if (urlRecord.protocol === "http:") { + urlRecord.protocol = "ws:"; + } else if (urlRecord.protocol === "https:") { + urlRecord.protocol = "wss:"; + } + if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") { + throw new DOMException2( + `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, + "SyntaxError" + ); + } + if (urlRecord.hash || urlRecord.href.endsWith("#")) { + throw new DOMException2("Got fragment", "SyntaxError"); + } + if (typeof protocols === "string") { + protocols = [protocols]; + } + if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + this[kWebSocketURL] = new URL(urlRecord.href); + this[kController] = establishWebSocketConnection( + urlRecord, + protocols, + this, + (response) => this.#onConnectionEstablished(response), + options + ); + this[kReadyState] = _WebSocket.CONNECTING; + this[kBinaryType] = "blob"; + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-close + * @param {number|undefined} code + * @param {string|undefined} reason + */ + close(code = void 0, reason = void 0) { + webidl.brandCheck(this, _WebSocket); + if (code !== void 0) { + code = webidl.converters["unsigned short"](code, { clamp: true }); + } + if (reason !== void 0) { + reason = webidl.converters.USVString(reason); + } + if (code !== void 0) { + if (code !== 1e3 && (code < 3e3 || code > 4999)) { + throw new DOMException2("invalid code", "InvalidAccessError"); + } + } + let reasonByteLength = 0; + if (reason !== void 0) { + reasonByteLength = Buffer.byteLength(reason); + if (reasonByteLength > 123) { + throw new DOMException2( + `Reason must be less than 123 bytes; received ${reasonByteLength}`, + "SyntaxError" + ); + } + } + if (this[kReadyState] === _WebSocket.CLOSING || this[kReadyState] === _WebSocket.CLOSED) { + } else if (!isEstablished(this)) { + failWebsocketConnection(this, "Connection was closed before it was established."); + this[kReadyState] = _WebSocket.CLOSING; + } else if (!isClosing(this)) { + const frame = new WebsocketFrameSend(); + if (code !== void 0 && reason === void 0) { + frame.frameData = Buffer.allocUnsafe(2); + frame.frameData.writeUInt16BE(code, 0); + } else if (code !== void 0 && reason !== void 0) { + frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength); + frame.frameData.writeUInt16BE(code, 0); + frame.frameData.write(reason, 2, "utf-8"); + } else { + frame.frameData = emptyBuffer; + } + const socket = this[kResponse].socket; + socket.write(frame.createFrame(opcodes.CLOSE), (err) => { + if (!err) { + this[kSentClose] = true; + } + }); + this[kReadyState] = states.CLOSING; + } else { + this[kReadyState] = _WebSocket.CLOSING; + } + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-send + * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data + */ + send(data) { + webidl.brandCheck(this, _WebSocket); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" }); + data = webidl.converters.WebSocketSendData(data); + if (this[kReadyState] === _WebSocket.CONNECTING) { + throw new DOMException2("Sent before connected.", "InvalidStateError"); + } + if (!isEstablished(this) || isClosing(this)) { + return; + } + const socket = this[kResponse].socket; + if (typeof data === "string") { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.TEXT); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (types.isArrayBuffer(data)) { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (ArrayBuffer.isView(data)) { + const ab = Buffer.from(data, data.byteOffset, data.byteLength); + const frame = new WebsocketFrameSend(ab); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += ab.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= ab.byteLength; + }); + } else if (isBlobLike2(data)) { + const frame = new WebsocketFrameSend(); + data.arrayBuffer().then((ab) => { + const value = Buffer.from(ab); + frame.frameData = value; + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + }); + } + } + get readyState() { + webidl.brandCheck(this, _WebSocket); + return this[kReadyState]; + } + get bufferedAmount() { + webidl.brandCheck(this, _WebSocket); + return this.#bufferedAmount; + } + get url() { + webidl.brandCheck(this, _WebSocket); + return URLSerializer(this[kWebSocketURL]); + } + get extensions() { + webidl.brandCheck(this, _WebSocket); + return this.#extensions; + } + get protocol() { + webidl.brandCheck(this, _WebSocket); + return this.#protocol; + } + get onopen() { + webidl.brandCheck(this, _WebSocket); + return this.#events.open; + } + set onopen(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.open) { + this.removeEventListener("open", this.#events.open); + } + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else { + this.#events.open = null; + } + } + get onerror() { + webidl.brandCheck(this, _WebSocket); + return this.#events.error; + } + set onerror(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.error) { + this.removeEventListener("error", this.#events.error); + } + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else { + this.#events.error = null; + } + } + get onclose() { + webidl.brandCheck(this, _WebSocket); + return this.#events.close; + } + set onclose(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.close) { + this.removeEventListener("close", this.#events.close); + } + if (typeof fn === "function") { + this.#events.close = fn; + this.addEventListener("close", fn); + } else { + this.#events.close = null; + } + } + get onmessage() { + webidl.brandCheck(this, _WebSocket); + return this.#events.message; + } + set onmessage(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.message) { + this.removeEventListener("message", this.#events.message); + } + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else { + this.#events.message = null; + } + } + get binaryType() { + webidl.brandCheck(this, _WebSocket); + return this[kBinaryType]; + } + set binaryType(type) { + webidl.brandCheck(this, _WebSocket); + if (type !== "blob" && type !== "arraybuffer") { + this[kBinaryType] = "blob"; + } else { + this[kBinaryType] = type; + } + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + */ + #onConnectionEstablished(response) { + this[kResponse] = response; + const parser = new ByteParser(this); + parser.on("drain", function onParserDrain() { + this.ws[kResponse].socket.resume(); + }); + response.socket.ws = this; + this[kByteParser] = parser; + this[kReadyState] = states.OPEN; + const extensions = response.headersList.get("sec-websocket-extensions"); + if (extensions !== null) { + this.#extensions = extensions; + } + const protocol = response.headersList.get("sec-websocket-protocol"); + if (protocol !== null) { + this.#protocol = protocol; + } + fireEvent("open", this); + } + }; + WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING; + WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN; + WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING; + WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED; + Object.defineProperties(WebSocket.prototype, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors, + url: kEnumerableProperty, + readyState: kEnumerableProperty, + bufferedAmount: kEnumerableProperty, + onopen: kEnumerableProperty, + onerror: kEnumerableProperty, + onclose: kEnumerableProperty, + close: kEnumerableProperty, + onmessage: kEnumerableProperty, + binaryType: kEnumerableProperty, + send: kEnumerableProperty, + extensions: kEnumerableProperty, + protocol: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "WebSocket", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(WebSocket, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors + }); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.DOMString + ); + webidl.converters["DOMString or sequence"] = function(V) { + if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) { + return webidl.converters["sequence"](V); + } + return webidl.converters.DOMString(V); + }; + webidl.converters.WebSocketInit = webidl.dictionaryConverter([ + { + key: "protocols", + converter: webidl.converters["DOMString or sequence"], + get defaultValue() { + return []; + } + }, + { + key: "dispatcher", + converter: (V) => V, + get defaultValue() { + return getGlobalDispatcher(); + } + }, + { + key: "headers", + converter: webidl.nullableConverter(webidl.converters.HeadersInit) + } + ]); + webidl.converters["DOMString or sequence or WebSocketInit"] = function(V) { + if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) { + return webidl.converters.WebSocketInit(V); + } + return { protocols: webidl.converters["DOMString or sequence"](V) }; + }; + webidl.converters.WebSocketSendData = function(V) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V); + } + } + return webidl.converters.USVString(V); + }; + module2.exports = { + WebSocket + }; + } +}); + +// node_modules/undici/index.js +var require_undici = __commonJS({ + "node_modules/undici/index.js"(exports2, module2) { + "use strict"; + var Client = require_client(); + var Dispatcher = require_dispatcher(); + var errors = require_errors(); + var Pool = require_pool(); + var BalancedPool = require_balanced_pool(); + var Agent = require_agent(); + var util = require_util(); + var { InvalidArgumentError } = errors; + var api = require_api(); + var buildConnector = require_connect(); + var MockClient = require_mock_client(); + var MockAgent = require_mock_agent(); + var MockPool = require_mock_pool(); + var mockErrors = require_mock_errors(); + var ProxyAgent = require_proxy_agent(); + var RetryHandler = require_RetryHandler(); + var { getGlobalDispatcher, setGlobalDispatcher } = require_global2(); + var DecoratorHandler = require_DecoratorHandler(); + var RedirectHandler = require_RedirectHandler(); + var createRedirectInterceptor = require_redirectInterceptor(); + var hasCrypto; + try { + require("crypto"); + hasCrypto = true; + } catch { + hasCrypto = false; + } + Object.assign(Dispatcher.prototype, api); + module2.exports.Dispatcher = Dispatcher; + module2.exports.Client = Client; + module2.exports.Pool = Pool; + module2.exports.BalancedPool = BalancedPool; + module2.exports.Agent = Agent; + module2.exports.ProxyAgent = ProxyAgent; + module2.exports.RetryHandler = RetryHandler; + module2.exports.DecoratorHandler = DecoratorHandler; + module2.exports.RedirectHandler = RedirectHandler; + module2.exports.createRedirectInterceptor = createRedirectInterceptor; + module2.exports.buildConnector = buildConnector; + module2.exports.errors = errors; + function makeDispatcher(fn) { + return (url, opts, handler) => { + if (typeof opts === "function") { + handler = opts; + opts = null; + } + if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) { + throw new InvalidArgumentError("invalid url"); + } + if (opts != null && typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (opts && opts.path != null) { + if (typeof opts.path !== "string") { + throw new InvalidArgumentError("invalid opts.path"); + } + let path3 = opts.path; + if (!opts.path.startsWith("/")) { + path3 = `/${path3}`; + } + url = new URL(util.parseOrigin(url).origin + path3); + } else { + if (!opts) { + opts = typeof url === "object" ? url : {}; + } + url = util.parseURL(url); + } + const { agent, dispatcher = getGlobalDispatcher() } = opts; + if (agent) { + throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?"); + } + return fn.call(dispatcher, { + ...opts, + origin: url.origin, + path: url.search ? `${url.pathname}${url.search}` : url.pathname, + method: opts.method || (opts.body ? "PUT" : "GET") + }, handler); + }; + } + module2.exports.setGlobalDispatcher = setGlobalDispatcher; + module2.exports.getGlobalDispatcher = getGlobalDispatcher; + if (util.nodeMajor > 16 || util.nodeMajor === 16 && util.nodeMinor >= 8) { + let fetchImpl = null; + module2.exports.fetch = async function fetch2(resource) { + if (!fetchImpl) { + fetchImpl = require_fetch().fetch; + } + try { + return await fetchImpl(...arguments); + } catch (err) { + if (typeof err === "object") { + Error.captureStackTrace(err, this); + } + throw err; + } + }; + module2.exports.Headers = require_headers().Headers; + module2.exports.Response = require_response().Response; + module2.exports.Request = require_request2().Request; + module2.exports.FormData = require_formdata().FormData; + module2.exports.File = require_file().File; + module2.exports.FileReader = require_filereader().FileReader; + const { setGlobalOrigin, getGlobalOrigin } = require_global(); + module2.exports.setGlobalOrigin = setGlobalOrigin; + module2.exports.getGlobalOrigin = getGlobalOrigin; + const { CacheStorage } = require_cachestorage(); + const { kConstruct } = require_symbols4(); + module2.exports.caches = new CacheStorage(kConstruct); + } + if (util.nodeMajor >= 16) { + const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies(); + module2.exports.deleteCookie = deleteCookie; + module2.exports.getCookies = getCookies; + module2.exports.getSetCookies = getSetCookies; + module2.exports.setCookie = setCookie; + const { parseMIMEType, serializeAMimeType } = require_dataURL(); + module2.exports.parseMIMEType = parseMIMEType; + module2.exports.serializeAMimeType = serializeAMimeType; + } + if (util.nodeMajor >= 18 && hasCrypto) { + const { WebSocket } = require_websocket(); + module2.exports.WebSocket = WebSocket; + } + module2.exports.request = makeDispatcher(api.request); + module2.exports.stream = makeDispatcher(api.stream); + module2.exports.pipeline = makeDispatcher(api.pipeline); + module2.exports.connect = makeDispatcher(api.connect); + module2.exports.upgrade = makeDispatcher(api.upgrade); + module2.exports.MockClient = MockClient; + module2.exports.MockPool = MockPool; + module2.exports.MockAgent = MockAgent; + module2.exports.mockErrors = mockErrors; + } +}); + +// node_modules/@actions/http-client/lib/index.js +var require_lib = __commonJS({ + "node_modules/@actions/http-client/lib/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.HttpClient = exports2.isHttps = exports2.HttpClientResponse = exports2.HttpClientError = exports2.getProxyUrl = exports2.MediaTypes = exports2.Headers = exports2.HttpCodes = void 0; + var http = __importStar(require("http")); + var https = __importStar(require("https")); + var pm = __importStar(require_proxy()); + var tunnel = __importStar(require_tunnel2()); + var undici_1 = require_undici(); + var HttpCodes; + (function(HttpCodes2) { + HttpCodes2[HttpCodes2["OK"] = 200] = "OK"; + HttpCodes2[HttpCodes2["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes2[HttpCodes2["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes2[HttpCodes2["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes2[HttpCodes2["SeeOther"] = 303] = "SeeOther"; + HttpCodes2[HttpCodes2["NotModified"] = 304] = "NotModified"; + HttpCodes2[HttpCodes2["UseProxy"] = 305] = "UseProxy"; + HttpCodes2[HttpCodes2["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes2[HttpCodes2["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes2[HttpCodes2["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes2[HttpCodes2["BadRequest"] = 400] = "BadRequest"; + HttpCodes2[HttpCodes2["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes2[HttpCodes2["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes2[HttpCodes2["Forbidden"] = 403] = "Forbidden"; + HttpCodes2[HttpCodes2["NotFound"] = 404] = "NotFound"; + HttpCodes2[HttpCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes2[HttpCodes2["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes2[HttpCodes2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes2[HttpCodes2["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes2[HttpCodes2["Conflict"] = 409] = "Conflict"; + HttpCodes2[HttpCodes2["Gone"] = 410] = "Gone"; + HttpCodes2[HttpCodes2["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes2[HttpCodes2["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes2[HttpCodes2["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes2[HttpCodes2["BadGateway"] = 502] = "BadGateway"; + HttpCodes2[HttpCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes2[HttpCodes2["GatewayTimeout"] = 504] = "GatewayTimeout"; + })(HttpCodes || (exports2.HttpCodes = HttpCodes = {})); + var Headers2; + (function(Headers3) { + Headers3["Accept"] = "accept"; + Headers3["ContentType"] = "content-type"; + })(Headers2 || (exports2.Headers = Headers2 = {})); + var MediaTypes; + (function(MediaTypes2) { + MediaTypes2["ApplicationJson"] = "application/json"; + })(MediaTypes || (exports2.MediaTypes = MediaTypes = {})); + function getProxyUrl(serverUrl) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ""; + } + exports2.getProxyUrl = getProxyUrl; + var HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect + ]; + var HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout + ]; + var RetryableHttpVerbs = ["OPTIONS", "GET", "DELETE", "HEAD"]; + var ExponentialBackoffCeiling = 10; + var ExponentialBackoffTimeSlice = 5; + var HttpClientError = class _HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = "HttpClientError"; + this.statusCode = statusCode; + Object.setPrototypeOf(this, _HttpClientError.prototype); + } + }; + exports2.HttpClientError = HttpClientError; + var HttpClientResponse = class { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + let output = Buffer.alloc(0); + this.message.on("data", (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on("end", () => { + resolve(output.toString()); + }); + })); + }); + } + readBodyBuffer() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + const chunks = []; + this.message.on("data", (chunk) => { + chunks.push(chunk); + }); + this.message.on("end", () => { + resolve(Buffer.concat(chunks)); + }); + })); + }); + } + }; + exports2.HttpClientResponse = HttpClientResponse; + function isHttps(requestUrl) { + const parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === "https:"; + } + exports2.isHttps = isHttps; + var HttpClient = class { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("OPTIONS", requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("GET", requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("DELETE", requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("POST", requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PATCH", requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PUT", requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("HEAD", requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request(verb, requestUrl, stream, additionalHeaders); + }); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + getJson(requestUrl, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error("Client has already been disposed."); + } + const parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info, data); + if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) { + if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } else { + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) { + const redirectUrl = response.message.headers["location"]; + if (!redirectUrl) { + break; + } + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) { + throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true."); + } + yield response.readBody(); + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) { + if (header.toLowerCase() === "authorization") { + delete headers[header]; + } + } + } + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) { + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) { + reject(err); + } else if (!res) { + reject(new Error("Unknown error")); + } else { + resolve(res); + } + } + this.requestRawWithCallback(info, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + if (typeof data === "string") { + if (!info.options.headers) { + info.options.headers = {}; + } + info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8"); + } + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + } + const req = info.httpModule.request(info.options, (msg) => { + const res = new HttpClientResponse(msg); + handleResult(void 0, res); + }); + let socket; + req.on("socket", (sock) => { + socket = sock; + }); + req.setTimeout(this._socketTimeout || 3 * 6e4, () => { + if (socket) { + socket.end(); + } + handleResult(new Error(`Request timeout: ${info.options.path}`)); + }); + req.on("error", function(err) { + handleResult(err); + }); + if (data && typeof data === "string") { + req.write(data, "utf8"); + } + if (data && typeof data !== "string") { + data.on("close", function() { + req.end(); + }); + data.pipe(req); + } else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + getAgentDispatcher(serverUrl) { + const parsedUrl = new URL(serverUrl); + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (!useProxy) { + return; + } + return this._getProxyAgentDispatcher(parsedUrl, proxyUrl); + } + _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); + if (this.handlers) { + for (const handler of this.handlers) { + handler.prepareRequest(info.options); + } + } + return info; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (!useProxy) { + agent = this._agent; + } + if (agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === "https:"; + let maxSockets = 100; + if (this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + }), { host: proxyUrl.hostname, port: proxyUrl.port }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === "https:"; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + if (!agent) { + const options = { keepAlive: this._keepAlive, maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + if (usingSsl && this._ignoreSslError) { + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _getProxyAgentDispatcher(parsedUrl, proxyUrl) { + let proxyAgent; + if (this._keepAlive) { + proxyAgent = this._proxyAgentDispatcher; + } + if (proxyAgent) { + return proxyAgent; + } + const usingSsl = parsedUrl.protocol === "https:"; + proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, (proxyUrl.username || proxyUrl.password) && { + token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}` + })); + this._proxyAgentDispatcher = proxyAgent; + if (usingSsl && this._ignoreSslError) { + proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { + rejectUnauthorized: false + }); + } + return proxyAgent; + } + _performExponentialBackoff(retryNumber) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise((resolve) => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + if (statusCode === HttpCodes.NotFound) { + resolve(response); + } + function dateTimeDeserializer(key, value) { + if (typeof value === "string") { + const a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, dateTimeDeserializer); + } else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } catch (err) { + } + if (statusCode > 299) { + let msg; + if (obj && obj.message) { + msg = obj.message; + } else if (contents && contents.length > 0) { + msg = contents; + } else { + msg = `Failed request: (${statusCode})`; + } + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } else { + resolve(response); + } + })); + }); + } + }; + exports2.HttpClient = HttpClient; + var lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); + } +}); + +// node_modules/@actions/http-client/lib/auth.js +var require_auth = __commonJS({ + "node_modules/@actions/http-client/lib/auth.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.PersonalAccessTokenCredentialHandler = exports2.BearerCredentialHandler = exports2.BasicCredentialHandler = void 0; + var BasicCredentialHandler = class { + constructor(username, password) { + this.username = username; + this.password = password; + } + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BasicCredentialHandler = BasicCredentialHandler; + var BearerCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Bearer ${this.token}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BearerCredentialHandler = BearerCredentialHandler; + var PersonalAccessTokenCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Basic ${Buffer.from(`PAT:${this.token}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; + } +}); + +// node_modules/@actions/core/lib/oidc-utils.js +var require_oidc_utils = __commonJS({ + "node_modules/@actions/core/lib/oidc-utils.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.OidcClient = void 0; + var http_client_1 = require_lib(); + var auth_1 = require_auth(); + var core_1 = require_core(); + var OidcClient = class _OidcClient { + static createHttpClient(allowRetry = true, maxRetry = 10) { + const requestOptions = { + allowRetries: allowRetry, + maxRetries: maxRetry + }; + return new http_client_1.HttpClient("actions/oidc-client", [new auth_1.BearerCredentialHandler(_OidcClient.getRequestToken())], requestOptions); + } + static getRequestToken() { + const token = process.env["ACTIONS_ID_TOKEN_REQUEST_TOKEN"]; + if (!token) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable"); + } + return token; + } + static getIDTokenUrl() { + const runtimeUrl = process.env["ACTIONS_ID_TOKEN_REQUEST_URL"]; + if (!runtimeUrl) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable"); + } + return runtimeUrl; + } + static getCall(id_token_url) { + var _a2; + return __awaiter(this, void 0, void 0, function* () { + const httpclient = _OidcClient.createHttpClient(); + const res = yield httpclient.getJson(id_token_url).catch((error) => { + throw new Error(`Failed to get ID Token. + + Error Code : ${error.statusCode} + + Error Message: ${error.message}`); + }); + const id_token = (_a2 = res.result) === null || _a2 === void 0 ? void 0 : _a2.value; + if (!id_token) { + throw new Error("Response json body do not have ID Token field"); + } + return id_token; + }); + } + static getIDToken(audience) { + return __awaiter(this, void 0, void 0, function* () { + try { + let id_token_url = _OidcClient.getIDTokenUrl(); + if (audience) { + const encodedAudience = encodeURIComponent(audience); + id_token_url = `${id_token_url}&audience=${encodedAudience}`; + } + (0, core_1.debug)(`ID token url is ${id_token_url}`); + const id_token = yield _OidcClient.getCall(id_token_url); + (0, core_1.setSecret)(id_token); + return id_token; + } catch (error) { + throw new Error(`Error message: ${error.message}`); + } + }); + } + }; + exports2.OidcClient = OidcClient; + } +}); + +// node_modules/@actions/core/lib/summary.js +var require_summary = __commonJS({ + "node_modules/@actions/core/lib/summary.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.summary = exports2.markdownSummary = exports2.SUMMARY_DOCS_URL = exports2.SUMMARY_ENV_VAR = void 0; + var os_1 = require("os"); + var fs_1 = require("fs"); + var { access, appendFile, writeFile } = fs_1.promises; + exports2.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY"; + exports2.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary"; + var Summary = class { + constructor() { + this._buffer = ""; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[exports2.SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${exports2.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); + } catch (_a2) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join(""); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance + */ + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: "utf8" }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ""; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(os_1.EOL); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, lang && { lang }); + const element = this.wrap("pre", this.wrap("code", code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? "ol" : "ul"; + const listItems = items.map((item) => this.wrap("li", item)).join(""); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows.map((row) => { + const cells = row.map((cell) => { + if (typeof cell === "string") { + return this.wrap("td", cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? "th" : "td"; + const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan }); + return this.wrap(tag, data, attrs); + }).join(""); + return this.wrap("tr", cells); + }).join(""); + const element = this.wrap("table", tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap("details", this.wrap("summary", label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, width && { width }), height && { height }); + const element = this.wrap("img", null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) ? tag : "h1"; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap("hr", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap("br", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, cite && { cite }); + const element = this.wrap("blockquote", text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap("a", text, { href }); + return this.addRaw(element).addEOL(); + } + }; + var _summary = new Summary(); + exports2.markdownSummary = _summary; + exports2.summary = _summary; + } +}); + +// node_modules/@actions/core/lib/path-utils.js +var require_path_utils = __commonJS({ + "node_modules/@actions/core/lib/path-utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = void 0; + var path3 = __importStar(require("path")); + function toPosixPath(pth) { + return pth.replace(/[\\]/g, "/"); + } + exports2.toPosixPath = toPosixPath; + function toWin32Path(pth) { + return pth.replace(/[/]/g, "\\"); + } + exports2.toWin32Path = toWin32Path; + function toPlatformPath(pth) { + return pth.replace(/[/\\]/g, path3.sep); + } + exports2.toPlatformPath = toPlatformPath; + } +}); + +// node_modules/@actions/io/lib/io-util.js +var require_io_util = __commonJS({ + "node_modules/@actions/io/lib/io-util.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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 _a2; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getCmdPath = exports2.tryGetExecutablePath = exports2.isRooted = exports2.isDirectory = exports2.exists = exports2.READONLY = exports2.UV_FS_O_EXLOCK = exports2.IS_WINDOWS = exports2.unlink = exports2.symlink = exports2.stat = exports2.rmdir = exports2.rm = exports2.rename = exports2.readlink = exports2.readdir = exports2.open = exports2.mkdir = exports2.lstat = exports2.copyFile = exports2.chmod = void 0; + var fs2 = __importStar(require("fs")); + var path3 = __importStar(require("path")); + _a2 = fs2.promises, exports2.chmod = _a2.chmod, exports2.copyFile = _a2.copyFile, exports2.lstat = _a2.lstat, exports2.mkdir = _a2.mkdir, exports2.open = _a2.open, exports2.readdir = _a2.readdir, exports2.readlink = _a2.readlink, exports2.rename = _a2.rename, exports2.rm = _a2.rm, exports2.rmdir = _a2.rmdir, exports2.stat = _a2.stat, exports2.symlink = _a2.symlink, exports2.unlink = _a2.unlink; + exports2.IS_WINDOWS = process.platform === "win32"; + exports2.UV_FS_O_EXLOCK = 268435456; + exports2.READONLY = fs2.constants.O_RDONLY; + function exists(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + try { + yield exports2.stat(fsPath); + } catch (err) { + if (err.code === "ENOENT") { + return false; + } + throw err; + } + return true; + }); + } + exports2.exists = exists; + function isDirectory(fsPath, useStat = false) { + return __awaiter(this, void 0, void 0, function* () { + const stats = useStat ? yield exports2.stat(fsPath) : yield exports2.lstat(fsPath); + return stats.isDirectory(); + }); + } + exports2.isDirectory = isDirectory; + function isRooted(p) { + p = normalizeSeparators(p); + if (!p) { + throw new Error('isRooted() parameter "p" cannot be empty'); + } + if (exports2.IS_WINDOWS) { + return p.startsWith("\\") || /^[A-Z]:/i.test(p); + } + return p.startsWith("/"); + } + exports2.isRooted = isRooted; + function tryGetExecutablePath(filePath, extensions) { + return __awaiter(this, void 0, void 0, function* () { + let stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + const upperExt = path3.extname(filePath).toUpperCase(); + if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) { + return filePath; + } + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + const originalFilePath = filePath; + for (const extension of extensions) { + filePath = originalFilePath + extension; + stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + try { + const directory = path3.dirname(filePath); + const upperName = path3.basename(filePath).toUpperCase(); + for (const actualName of yield exports2.readdir(directory)) { + if (upperName === actualName.toUpperCase()) { + filePath = path3.join(directory, actualName); + break; + } + } + } catch (err) { + console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); + } + return filePath; + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + } + return ""; + }); + } + exports2.tryGetExecutablePath = tryGetExecutablePath; + function normalizeSeparators(p) { + p = p || ""; + if (exports2.IS_WINDOWS) { + p = p.replace(/\//g, "\\"); + return p.replace(/\\\\+/g, "\\"); + } + return p.replace(/\/\/+/g, "/"); + } + function isUnixExecutable(stats) { + return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid(); + } + function getCmdPath() { + var _a3; + return (_a3 = process.env["COMSPEC"]) !== null && _a3 !== void 0 ? _a3 : `cmd.exe`; + } + exports2.getCmdPath = getCmdPath; + } +}); + +// node_modules/@actions/io/lib/io.js +var require_io = __commonJS({ + "node_modules/@actions/io/lib/io.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.findInPath = exports2.which = exports2.mkdirP = exports2.rmRF = exports2.mv = exports2.cp = void 0; + var assert_1 = require("assert"); + var path3 = __importStar(require("path")); + var ioUtil = __importStar(require_io_util()); + function cp(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + const { force, recursive, copySourceDirectory } = readCopyOptions(options); + const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; + if (destStat && destStat.isFile() && !force) { + return; + } + const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path3.join(dest, path3.basename(source)) : dest; + if (!(yield ioUtil.exists(source))) { + throw new Error(`no such file or directory: ${source}`); + } + const sourceStat = yield ioUtil.stat(source); + if (sourceStat.isDirectory()) { + if (!recursive) { + throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); + } else { + yield cpDirRecursive(source, newDest, 0, force); + } + } else { + if (path3.relative(source, newDest) === "") { + throw new Error(`'${newDest}' and '${source}' are the same file`); + } + yield copyFile(source, newDest, force); + } + }); + } + exports2.cp = cp; + function mv(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + if (yield ioUtil.exists(dest)) { + let destExists = true; + if (yield ioUtil.isDirectory(dest)) { + dest = path3.join(dest, path3.basename(source)); + destExists = yield ioUtil.exists(dest); + } + if (destExists) { + if (options.force == null || options.force) { + yield rmRF(dest); + } else { + throw new Error("Destination already exists"); + } + } + } + yield mkdirP(path3.dirname(dest)); + yield ioUtil.rename(source, dest); + }); + } + exports2.mv = mv; + function rmRF(inputPath) { + return __awaiter(this, void 0, void 0, function* () { + if (ioUtil.IS_WINDOWS) { + if (/[*"<>|]/.test(inputPath)) { + throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows'); + } + } + try { + yield ioUtil.rm(inputPath, { + force: true, + maxRetries: 3, + recursive: true, + retryDelay: 300 + }); + } catch (err) { + throw new Error(`File was unable to be removed ${err}`); + } + }); + } + exports2.rmRF = rmRF; + function mkdirP(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(fsPath, "a path argument must be provided"); + yield ioUtil.mkdir(fsPath, { recursive: true }); + }); + } + exports2.mkdirP = mkdirP; + function which(tool, check) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + if (check) { + const result = yield which(tool, false); + if (!result) { + if (ioUtil.IS_WINDOWS) { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); + } else { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); + } + } + return result; + } + const matches = yield findInPath(tool); + if (matches && matches.length > 0) { + return matches[0]; + } + return ""; + }); + } + exports2.which = which; + function findInPath(tool) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + const extensions = []; + if (ioUtil.IS_WINDOWS && process.env["PATHEXT"]) { + for (const extension of process.env["PATHEXT"].split(path3.delimiter)) { + if (extension) { + extensions.push(extension); + } + } + } + if (ioUtil.isRooted(tool)) { + const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); + if (filePath) { + return [filePath]; + } + return []; + } + if (tool.includes(path3.sep)) { + return []; + } + const directories = []; + if (process.env.PATH) { + for (const p of process.env.PATH.split(path3.delimiter)) { + if (p) { + directories.push(p); + } + } + } + const matches = []; + for (const directory of directories) { + const filePath = yield ioUtil.tryGetExecutablePath(path3.join(directory, tool), extensions); + if (filePath) { + matches.push(filePath); + } + } + return matches; + }); + } + exports2.findInPath = findInPath; + function readCopyOptions(options) { + const force = options.force == null ? true : options.force; + const recursive = Boolean(options.recursive); + const copySourceDirectory = options.copySourceDirectory == null ? true : Boolean(options.copySourceDirectory); + return { force, recursive, copySourceDirectory }; + } + function cpDirRecursive(sourceDir, destDir, currentDepth, force) { + return __awaiter(this, void 0, void 0, function* () { + if (currentDepth >= 255) + return; + currentDepth++; + yield mkdirP(destDir); + const files = yield ioUtil.readdir(sourceDir); + for (const fileName of files) { + const srcFile = `${sourceDir}/${fileName}`; + const destFile = `${destDir}/${fileName}`; + const srcFileStat = yield ioUtil.lstat(srcFile); + if (srcFileStat.isDirectory()) { + yield cpDirRecursive(srcFile, destFile, currentDepth, force); + } else { + yield copyFile(srcFile, destFile, force); + } + } + yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); + }); + } + function copyFile(srcFile, destFile, force) { + return __awaiter(this, void 0, void 0, function* () { + if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { + try { + yield ioUtil.lstat(destFile); + yield ioUtil.unlink(destFile); + } catch (e) { + if (e.code === "EPERM") { + yield ioUtil.chmod(destFile, "0666"); + yield ioUtil.unlink(destFile); + } + } + const symlinkFull = yield ioUtil.readlink(srcFile); + yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? "junction" : null); + } else if (!(yield ioUtil.exists(destFile)) || force) { + yield ioUtil.copyFile(srcFile, destFile); + } + }); + } + } +}); + +// node_modules/@actions/exec/lib/toolrunner.js +var require_toolrunner = __commonJS({ + "node_modules/@actions/exec/lib/toolrunner.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.argStringToArray = exports2.ToolRunner = void 0; + var os = __importStar(require("os")); + var events = __importStar(require("events")); + var child = __importStar(require("child_process")); + var path3 = __importStar(require("path")); + var io = __importStar(require_io()); + var ioUtil = __importStar(require_io_util()); + var timers_1 = require("timers"); + var IS_WINDOWS = process.platform === "win32"; + var ToolRunner = class extends events.EventEmitter { + constructor(toolPath, args, options) { + super(); + if (!toolPath) { + throw new Error("Parameter 'toolPath' cannot be null or empty."); + } + this.toolPath = toolPath; + this.args = args || []; + this.options = options || {}; + } + _debug(message) { + if (this.options.listeners && this.options.listeners.debug) { + this.options.listeners.debug(message); + } + } + _getCommandString(options, noPrefix) { + const toolPath = this._getSpawnFileName(); + const args = this._getSpawnArgs(options); + let cmd = noPrefix ? "" : "[command]"; + if (IS_WINDOWS) { + if (this._isCmdFile()) { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } else if (options.windowsVerbatimArguments) { + cmd += `"${toolPath}"`; + for (const a of args) { + cmd += ` ${a}`; + } + } else { + cmd += this._windowsQuoteCmdArg(toolPath); + for (const a of args) { + cmd += ` ${this._windowsQuoteCmdArg(a)}`; + } + } + } else { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } + return cmd; + } + _processLineBuffer(data, strBuffer, onLine) { + try { + let s = strBuffer + data.toString(); + let n = s.indexOf(os.EOL); + while (n > -1) { + const line = s.substring(0, n); + onLine(line); + s = s.substring(n + os.EOL.length); + n = s.indexOf(os.EOL); + } + return s; + } catch (err) { + this._debug(`error processing line. Failed with error ${err}`); + return ""; + } + } + _getSpawnFileName() { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + return process.env["COMSPEC"] || "cmd.exe"; + } + } + return this.toolPath; + } + _getSpawnArgs(options) { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; + for (const a of this.args) { + argline += " "; + argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a); + } + argline += '"'; + return [argline]; + } + } + return this.args; + } + _endsWith(str, end) { + return str.endsWith(end); + } + _isCmdFile() { + const upperToolPath = this.toolPath.toUpperCase(); + return this._endsWith(upperToolPath, ".CMD") || this._endsWith(upperToolPath, ".BAT"); + } + _windowsQuoteCmdArg(arg) { + if (!this._isCmdFile()) { + return this._uvQuoteCmdArg(arg); + } + if (!arg) { + return '""'; + } + const cmdSpecialChars = [ + " ", + " ", + "&", + "(", + ")", + "[", + "]", + "{", + "}", + "^", + "=", + ";", + "!", + "'", + "+", + ",", + "`", + "~", + "|", + "<", + ">", + '"' + ]; + let needsQuotes = false; + for (const char of arg) { + if (cmdSpecialChars.some((x) => x === char)) { + needsQuotes = true; + break; + } + } + if (!needsQuotes) { + return arg; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += '"'; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _uvQuoteCmdArg(arg) { + if (!arg) { + return '""'; + } + if (!arg.includes(" ") && !arg.includes(" ") && !arg.includes('"')) { + return arg; + } + if (!arg.includes('"') && !arg.includes("\\")) { + return `"${arg}"`; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += "\\"; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _cloneExecOptions(options) { + options = options || {}; + const result = { + cwd: options.cwd || process.cwd(), + env: options.env || process.env, + silent: options.silent || false, + windowsVerbatimArguments: options.windowsVerbatimArguments || false, + failOnStdErr: options.failOnStdErr || false, + ignoreReturnCode: options.ignoreReturnCode || false, + delay: options.delay || 1e4 + }; + result.outStream = options.outStream || process.stdout; + result.errStream = options.errStream || process.stderr; + return result; + } + _getSpawnOptions(options, toolPath) { + options = options || {}; + const result = {}; + result.cwd = options.cwd; + result.env = options.env; + result["windowsVerbatimArguments"] = options.windowsVerbatimArguments || this._isCmdFile(); + if (options.windowsVerbatimArguments) { + result.argv0 = `"${toolPath}"`; + } + return result; + } + /** + * Exec a tool. + * Output will be streamed to the live console. + * Returns promise with return code + * + * @param tool path to tool to exec + * @param options optional exec options. See ExecOptions + * @returns number + */ + exec() { + return __awaiter(this, void 0, void 0, function* () { + if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\"))) { + this.toolPath = path3.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); + } + this.toolPath = yield io.which(this.toolPath, true); + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + this._debug(`exec tool: ${this.toolPath}`); + this._debug("arguments:"); + for (const arg of this.args) { + this._debug(` ${arg}`); + } + const optionsNonNull = this._cloneExecOptions(this.options); + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); + } + const state = new ExecState(optionsNonNull, this.toolPath); + state.on("debug", (message) => { + this._debug(message); + }); + if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) { + return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); + } + const fileName = this._getSpawnFileName(); + const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); + let stdbuffer = ""; + if (cp.stdout) { + cp.stdout.on("data", (data) => { + if (this.options.listeners && this.options.listeners.stdout) { + this.options.listeners.stdout(data); + } + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(data); + } + stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { + if (this.options.listeners && this.options.listeners.stdline) { + this.options.listeners.stdline(line); + } + }); + }); + } + let errbuffer = ""; + if (cp.stderr) { + cp.stderr.on("data", (data) => { + state.processStderr = true; + if (this.options.listeners && this.options.listeners.stderr) { + this.options.listeners.stderr(data); + } + if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) { + const s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream; + s.write(data); + } + errbuffer = this._processLineBuffer(data, errbuffer, (line) => { + if (this.options.listeners && this.options.listeners.errline) { + this.options.listeners.errline(line); + } + }); + }); + } + cp.on("error", (err) => { + state.processError = err.message; + state.processExited = true; + state.processClosed = true; + state.CheckComplete(); + }); + cp.on("exit", (code) => { + state.processExitCode = code; + state.processExited = true; + this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); + state.CheckComplete(); + }); + cp.on("close", (code) => { + state.processExitCode = code; + state.processExited = true; + state.processClosed = true; + this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); + state.CheckComplete(); + }); + state.on("done", (error, exitCode) => { + if (stdbuffer.length > 0) { + this.emit("stdline", stdbuffer); + } + if (errbuffer.length > 0) { + this.emit("errline", errbuffer); + } + cp.removeAllListeners(); + if (error) { + reject(error); + } else { + resolve(exitCode); + } + }); + if (this.options.input) { + if (!cp.stdin) { + throw new Error("child process missing stdin"); + } + cp.stdin.end(this.options.input); + } + })); + }); + } + }; + exports2.ToolRunner = ToolRunner; + function argStringToArray(argString) { + const args = []; + let inQuotes = false; + let escaped = false; + let arg = ""; + function append(c) { + if (escaped && c !== '"') { + arg += "\\"; + } + arg += c; + escaped = false; + } + for (let i = 0; i < argString.length; i++) { + const c = argString.charAt(i); + if (c === '"') { + if (!escaped) { + inQuotes = !inQuotes; + } else { + append(c); + } + continue; + } + if (c === "\\" && escaped) { + append(c); + continue; + } + if (c === "\\" && inQuotes) { + escaped = true; + continue; + } + if (c === " " && !inQuotes) { + if (arg.length > 0) { + args.push(arg); + arg = ""; + } + continue; + } + append(c); + } + if (arg.length > 0) { + args.push(arg.trim()); + } + return args; + } + exports2.argStringToArray = argStringToArray; + var ExecState = class _ExecState extends events.EventEmitter { + constructor(options, toolPath) { + super(); + this.processClosed = false; + this.processError = ""; + this.processExitCode = 0; + this.processExited = false; + this.processStderr = false; + this.delay = 1e4; + this.done = false; + this.timeout = null; + if (!toolPath) { + throw new Error("toolPath must not be empty"); + } + this.options = options; + this.toolPath = toolPath; + if (options.delay) { + this.delay = options.delay; + } + } + CheckComplete() { + if (this.done) { + return; + } + if (this.processClosed) { + this._setResult(); + } else if (this.processExited) { + this.timeout = timers_1.setTimeout(_ExecState.HandleTimeout, this.delay, this); + } + } + _debug(message) { + this.emit("debug", message); + } + _setResult() { + let error; + if (this.processExited) { + if (this.processError) { + error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); + } else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { + error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); + } else if (this.processStderr && this.options.failOnStdErr) { + error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); + } + } + if (this.timeout) { + clearTimeout(this.timeout); + this.timeout = null; + } + this.done = true; + this.emit("done", error, this.processExitCode); + } + static HandleTimeout(state) { + if (state.done) { + return; + } + if (!state.processClosed && state.processExited) { + const message = `The STDIO streams did not close within ${state.delay / 1e3} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; + state._debug(message); + } + state._setResult(); + } + }; + } +}); + +// node_modules/@actions/exec/lib/exec.js +var require_exec = __commonJS({ + "node_modules/@actions/exec/lib/exec.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getExecOutput = exports2.exec = void 0; + var string_decoder_1 = require("string_decoder"); + var tr = __importStar(require_toolrunner()); + function exec3(commandLine, args, options) { + return __awaiter(this, void 0, void 0, function* () { + const commandArgs = tr.argStringToArray(commandLine); + if (commandArgs.length === 0) { + throw new Error(`Parameter 'commandLine' cannot be null or empty.`); + } + const toolPath = commandArgs[0]; + args = commandArgs.slice(1).concat(args || []); + const runner = new tr.ToolRunner(toolPath, args, options); + return runner.exec(); + }); + } + exports2.exec = exec3; + function getExecOutput2(commandLine, args, options) { + var _a2, _b; + return __awaiter(this, void 0, void 0, function* () { + let stdout = ""; + let stderr = ""; + const stdoutDecoder = new string_decoder_1.StringDecoder("utf8"); + const stderrDecoder = new string_decoder_1.StringDecoder("utf8"); + const originalStdoutListener = (_a2 = options === null || options === void 0 ? void 0 : options.listeners) === null || _a2 === void 0 ? void 0 : _a2.stdout; + const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr; + const stdErrListener = (data) => { + stderr += stderrDecoder.write(data); + if (originalStdErrListener) { + originalStdErrListener(data); + } + }; + const stdOutListener = (data) => { + stdout += stdoutDecoder.write(data); + if (originalStdoutListener) { + originalStdoutListener(data); + } + }; + const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener }); + const exitCode = yield exec3(commandLine, args, Object.assign(Object.assign({}, options), { listeners })); + stdout += stdoutDecoder.end(); + stderr += stderrDecoder.end(); + return { + exitCode, + stdout, + stderr + }; + }); + } + exports2.getExecOutput = getExecOutput2; + } +}); + +// node_modules/@actions/core/lib/platform.js +var require_platform = __commonJS({ + "node_modules/@actions/core/lib/platform.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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 = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getDetails = exports2.isLinux = exports2.isMacOS = exports2.isWindows = exports2.arch = exports2.platform = void 0; + var os_1 = __importDefault(require("os")); + var exec3 = __importStar(require_exec()); + var getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout: version } = yield exec3.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', void 0, { + silent: true + }); + const { stdout: name } = yield exec3.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', void 0, { + silent: true + }); + return { + name: name.trim(), + version: version.trim() + }; + }); + var getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + var _a2, _b, _c, _d; + const { stdout } = yield exec3.getExecOutput("sw_vers", void 0, { + silent: true + }); + const version = (_b = (_a2 = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a2 === void 0 ? void 0 : _a2[1]) !== null && _b !== void 0 ? _b : ""; + const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ""; + return { + name, + version + }; + }); + var getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout } = yield exec3.getExecOutput("lsb_release", ["-i", "-r", "-s"], { + silent: true + }); + const [name, version] = stdout.trim().split("\n"); + return { + name, + version + }; + }); + exports2.platform = os_1.default.platform(); + exports2.arch = os_1.default.arch(); + exports2.isWindows = exports2.platform === "win32"; + exports2.isMacOS = exports2.platform === "darwin"; + exports2.isLinux = exports2.platform === "linux"; + function getDetails2() { + return __awaiter(this, void 0, void 0, function* () { + return Object.assign(Object.assign({}, yield exports2.isWindows ? getWindowsInfo() : exports2.isMacOS ? getMacOsInfo() : getLinuxInfo()), { + platform: exports2.platform, + arch: exports2.arch, + isWindows: exports2.isWindows, + isMacOS: exports2.isMacOS, + isLinux: exports2.isLinux + }); + }); + } + exports2.getDetails = getDetails2; + } +}); + +// node_modules/@actions/core/lib/core.js +var require_core = __commonJS({ + "node_modules/@actions/core/lib/core.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.platform = exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = exports2.markdownSummary = exports2.summary = exports2.getIDToken = exports2.getState = exports2.saveState = exports2.group = exports2.endGroup = exports2.startGroup = exports2.info = exports2.notice = exports2.warning = exports2.error = exports2.debug = exports2.isDebug = exports2.setFailed = exports2.setCommandEcho = exports2.setOutput = exports2.getBooleanInput = exports2.getMultilineInput = exports2.getInput = exports2.addPath = exports2.setSecret = exports2.exportVariable = exports2.ExitCode = void 0; + var command_1 = require_command(); + var file_command_1 = require_file_command(); + var utils_1 = require_utils(); + var os = __importStar(require("os")); + var path3 = __importStar(require("path")); + var oidc_utils_1 = require_oidc_utils(); + var ExitCode; + (function(ExitCode2) { + ExitCode2[ExitCode2["Success"] = 0] = "Success"; + ExitCode2[ExitCode2["Failure"] = 1] = "Failure"; + })(ExitCode || (exports2.ExitCode = ExitCode = {})); + function exportVariable(name, val) { + const convertedVal = (0, utils_1.toCommandValue)(val); + process.env[name] = convertedVal; + const filePath = process.env["GITHUB_ENV"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("ENV", (0, file_command_1.prepareKeyValueMessage)(name, val)); + } + (0, command_1.issueCommand)("set-env", { name }, convertedVal); + } + exports2.exportVariable = exportVariable; + function setSecret(secret) { + (0, command_1.issueCommand)("add-mask", {}, secret); + } + exports2.setSecret = setSecret; + function addPath(inputPath) { + const filePath = process.env["GITHUB_PATH"] || ""; + if (filePath) { + (0, file_command_1.issueFileCommand)("PATH", inputPath); + } else { + (0, command_1.issueCommand)("add-path", {}, inputPath); + } + process.env["PATH"] = `${inputPath}${path3.delimiter}${process.env["PATH"]}`; + } + exports2.addPath = addPath; + function getInput2(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || ""; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); + } + exports2.getInput = getInput2; + function getMultilineInput(name, options) { + const inputs = getInput2(name, options).split("\n").filter((x) => x !== ""); + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map((input) => input.trim()); + } + exports2.getMultilineInput = getMultilineInput; + function getBooleanInput2(name, options) { + const trueValue = ["true", "True", "TRUE"]; + const falseValue = ["false", "False", "FALSE"]; + const val = getInput2(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} +Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); + } + exports2.getBooleanInput = getBooleanInput2; + function setOutput2(name, value) { + const filePath = process.env["GITHUB_OUTPUT"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("OUTPUT", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + process.stdout.write(os.EOL); + (0, command_1.issueCommand)("set-output", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.setOutput = setOutput2; + function setCommandEcho(enabled) { + (0, command_1.issue)("echo", enabled ? "on" : "off"); + } + exports2.setCommandEcho = setCommandEcho; + function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); + } + exports2.setFailed = setFailed; + function isDebug() { + return process.env["RUNNER_DEBUG"] === "1"; + } + exports2.isDebug = isDebug; + function debug(message) { + (0, command_1.issueCommand)("debug", {}, message); + } + exports2.debug = debug; + function error(message, properties = {}) { + (0, command_1.issueCommand)("error", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.error = error; + function warning(message, properties = {}) { + (0, command_1.issueCommand)("warning", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.warning = warning; + function notice(message, properties = {}) { + (0, command_1.issueCommand)("notice", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.notice = notice; + function info(message) { + process.stdout.write(message + os.EOL); + } + exports2.info = info; + function startGroup2(name) { + (0, command_1.issue)("group", name); + } + exports2.startGroup = startGroup2; + function endGroup2() { + (0, command_1.issue)("endgroup"); + } + exports2.endGroup = endGroup2; + function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup2(name); + let result; + try { + result = yield fn(); + } finally { + endGroup2(); + } + return result; + }); + } + exports2.group = group; + function saveState(name, value) { + const filePath = process.env["GITHUB_STATE"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("STATE", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + (0, command_1.issueCommand)("save-state", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.saveState = saveState; + function getState(name) { + return process.env[`STATE_${name}`] || ""; + } + exports2.getState = getState; + function getIDToken(aud) { + return __awaiter(this, void 0, void 0, function* () { + return yield oidc_utils_1.OidcClient.getIDToken(aud); + }); + } + exports2.getIDToken = getIDToken; + var summary_1 = require_summary(); + Object.defineProperty(exports2, "summary", { enumerable: true, get: function() { + return summary_1.summary; + } }); + var summary_2 = require_summary(); + Object.defineProperty(exports2, "markdownSummary", { enumerable: true, get: function() { + return summary_2.markdownSummary; + } }); + var path_utils_1 = require_path_utils(); + Object.defineProperty(exports2, "toPosixPath", { enumerable: true, get: function() { + return path_utils_1.toPosixPath; + } }); + Object.defineProperty(exports2, "toWin32Path", { enumerable: true, get: function() { + return path_utils_1.toWin32Path; + } }); + Object.defineProperty(exports2, "toPlatformPath", { enumerable: true, get: function() { + return path_utils_1.toPlatformPath; + } }); + exports2.platform = __importStar(require_platform()); + } +}); + +// node_modules/@actions/github/lib/context.js +var require_context = __commonJS({ + "node_modules/@actions/github/lib/context.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Context = void 0; + var fs_1 = require("fs"); + var os_1 = require("os"); + var Context = class { + /** + * Hydrate the context from the environment + */ + constructor() { + var _a2, _b, _c; + this.payload = {}; + if (process.env.GITHUB_EVENT_PATH) { + if ((0, fs_1.existsSync)(process.env.GITHUB_EVENT_PATH)) { + this.payload = JSON.parse((0, fs_1.readFileSync)(process.env.GITHUB_EVENT_PATH, { encoding: "utf8" })); + } else { + const path3 = process.env.GITHUB_EVENT_PATH; + process.stdout.write(`GITHUB_EVENT_PATH ${path3} 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.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT, 10); + this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10); + this.runId = parseInt(process.env.GITHUB_RUN_ID, 10); + this.apiUrl = (_a2 = process.env.GITHUB_API_URL) !== null && _a2 !== void 0 ? _a2 : `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'"); + } + }; + exports2.Context = Context; + } +}); + +// node_modules/@actions/github/lib/internal/utils.js +var require_utils3 = __commonJS({ + "node_modules/@actions/github/lib/internal/utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getApiBaseUrl = exports2.getProxyFetch = exports2.getProxyAgentDispatcher = exports2.getProxyAgent = exports2.getAuthString = void 0; + var httpClient = __importStar(require_lib()); + var undici_1 = require_undici(); + 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}`; + } + exports2.getAuthString = getAuthString; + function getProxyAgent(destinationUrl) { + const hc = new httpClient.HttpClient(); + return hc.getAgent(destinationUrl); + } + exports2.getProxyAgent = getProxyAgent; + function getProxyAgentDispatcher(destinationUrl) { + const hc = new httpClient.HttpClient(); + return hc.getAgentDispatcher(destinationUrl); + } + exports2.getProxyAgentDispatcher = getProxyAgentDispatcher; + function getProxyFetch(destinationUrl) { + const httpDispatcher = getProxyAgentDispatcher(destinationUrl); + const proxyFetch = (url, opts) => __awaiter(this, void 0, void 0, function* () { + return (0, undici_1.fetch)(url, Object.assign(Object.assign({}, opts), { dispatcher: httpDispatcher })); + }); + return proxyFetch; + } + exports2.getProxyFetch = getProxyFetch; + function getApiBaseUrl() { + return process.env["GITHUB_API_URL"] || "https://api.github.com"; + } + exports2.getApiBaseUrl = getApiBaseUrl; + } +}); + +// node_modules/universal-user-agent/dist-node/index.js +var require_dist_node = __commonJS({ + "node_modules/universal-user-agent/dist-node/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + function getUserAgent() { + if (typeof navigator === "object" && "userAgent" in navigator) { + return navigator.userAgent; + } + if (typeof process === "object" && process.version !== void 0) { + return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`; + } + return ""; + } + exports2.getUserAgent = getUserAgent; + } +}); + +// node_modules/before-after-hook/lib/register.js +var require_register = __commonJS({ + "node_modules/before-after-hook/lib/register.js"(exports2, module2) { + module2.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, name2) { + return register.bind(null, state, name2, callback, options); + }, method)(); + } + return Promise.resolve().then(function() { + if (!state.registry[name]) { + return method(options); + } + return state.registry[name].reduce(function(method2, registered) { + return registered.hook.bind(null, method2, options); + }, method)(); + }); + } + } +}); + +// node_modules/before-after-hook/lib/add.js +var require_add = __commonJS({ + "node_modules/before-after-hook/lib/add.js"(exports2, module2) { + module2.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, + orig + }); + } + } +}); + +// node_modules/before-after-hook/lib/remove.js +var require_remove = __commonJS({ + "node_modules/before-after-hook/lib/remove.js"(exports2, module2) { + module2.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); + } + } +}); + +// node_modules/before-after-hook/index.js +var require_before_after_hook = __commonJS({ + "node_modules/before-after-hook/index.js"(exports2, module2) { + var register = require_register(); + var addHook = require_add(); + var removeHook = require_remove(); + 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 Hook2() { + 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(); + } + Hook2.Singular = HookSingular.bind(); + Hook2.Collection = HookCollection.bind(); + module2.exports = Hook2; + module2.exports.Hook = Hook2; + module2.exports.Singular = Hook2.Singular; + module2.exports.Collection = Hook2.Collection; + } +}); + +// node_modules/@octokit/endpoint/dist-node/index.js +var require_dist_node2 = __commonJS({ + "node_modules/@octokit/endpoint/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + endpoint: () => endpoint + }); + module2.exports = __toCommonJS(dist_src_exports); + var import_universal_user_agent = require_dist_node(); + var VERSION3 = "9.0.6"; + var userAgent = `octokit-endpoint.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}`; + var DEFAULTS = { + method: "GET", + baseUrl: "https://api.github.com", + headers: { + accept: "application/vnd.github.v3+json", + "user-agent": userAgent + }, + mediaType: { + format: "" + } + }; + function lowercaseKeys(object) { + if (!object) { + return {}; + } + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); + } + function isPlainObject(value) { + if (typeof value !== "object" || value === null) + return false; + if (Object.prototype.toString.call(value) !== "[object Object]") + return false; + const proto = Object.getPrototypeOf(value); + if (proto === null) + return true; + const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor; + return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value); + } + function mergeDeep(defaults3, options) { + const result = Object.assign({}, defaults3); + Object.keys(options).forEach((key) => { + if (isPlainObject(options[key])) { + if (!(key in defaults3)) + Object.assign(result, { [key]: options[key] }); + else + result[key] = mergeDeep(defaults3[key], options[key]); + } else { + Object.assign(result, { [key]: options[key] }); + } + }); + return result; + } + function removeUndefinedProperties(obj) { + for (const key in obj) { + if (obj[key] === void 0) { + delete obj[key]; + } + } + return obj; + } + function merge(defaults3, 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); + } + options.headers = lowercaseKeys(options.headers); + removeUndefinedProperties(options); + removeUndefinedProperties(options.headers); + const mergedOptions = mergeDeep(defaults3 || {}, options); + if (options.url === "/graphql") { + if (defaults3 && defaults3.mediaType.previews?.length) { + mergedOptions.mediaType.previews = defaults3.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("&"); + } + var urlVariableRegex = /\{[^{}}]+\}/g; + function removeNonChars(variableName) { + return variableName.replace(/(?:^\W+)|(?:(? a.concat(b), []); + } + function omit(object, keysToOmit) { + const result = { __proto__: null }; + for (const key of Object.keys(object)) { + if (keysToOmit.indexOf(key) === -1) { + result[key] = object[key]; + } + } + return result; + } + 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 !== void 0 && value !== null; + } + function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; + } + function getValues(context2, operator, key, modifier) { + var value = context2[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(value2) { + result.push( + encodeValue(operator, value2, 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(value2) { + tmp.push(encodeValue(operator, value2)); + }); + } 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, context2) { + var operators = ["+", "#", ".", "/", ";", "?", "&"]; + template = 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(context2, 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); + } + } + ); + if (template === "/") { + return template; + } else { + return template.replace(/\/$/, ""); + } + } + function parse(options) { + let method = options.method.toUpperCase(); + 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" + ]); + 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) { + headers.accept = headers.accept.split(/,/).map( + (format) => format.replace( + /application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, + `application/vnd$1$2.${options.mediaType.format}` + ) + ).join(","); + } + if (url.endsWith("/graphql")) { + if (options.mediaType.previews?.length) { + const previewsFromAcceptHeader = headers.accept.match(/(? { + const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; + return `application/vnd.github.${preview}-preview${format}`; + }).join(","); + } + } + } + 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; + } + } + } + if (!headers["content-type"] && typeof body !== "undefined") { + headers["content-type"] = "application/json; charset=utf-8"; + } + if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") { + body = ""; + } + return Object.assign( + { method, url, headers }, + typeof body !== "undefined" ? { body } : null, + options.request ? { request: options.request } : null + ); + } + function endpointWithDefaults(defaults3, route, options) { + return parse(merge(defaults3, route, options)); + } + function withDefaults(oldDefaults, newDefaults) { + const DEFAULTS2 = merge(oldDefaults, newDefaults); + const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2); + return Object.assign(endpoint2, { + DEFAULTS: DEFAULTS2, + defaults: withDefaults.bind(null, DEFAULTS2), + merge: merge.bind(null, DEFAULTS2), + parse + }); + } + var endpoint = withDefaults(null, DEFAULTS); + } +}); + +// node_modules/deprecation/dist-node/index.js +var require_dist_node3 = __commonJS({ + "node_modules/deprecation/dist-node/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var Deprecation = class extends Error { + constructor(message) { + super(message); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + this.name = "Deprecation"; + } + }; + exports2.Deprecation = Deprecation; + } +}); + +// node_modules/wrappy/wrappy.js +var require_wrappy = __commonJS({ + "node_modules/wrappy/wrappy.js"(exports2, module2) { + module2.exports = wrappy; + function wrappy(fn, cb) { + if (fn && cb) return wrappy(fn)(cb); + if (typeof fn !== "function") + throw new TypeError("need wrapper function"); + Object.keys(fn).forEach(function(k) { + wrapper[k] = fn[k]; + }); + return wrapper; + function wrapper() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + var ret = fn.apply(this, args); + var cb2 = args[args.length - 1]; + if (typeof ret === "function" && ret !== cb2) { + Object.keys(cb2).forEach(function(k) { + ret[k] = cb2[k]; + }); + } + return ret; + } + } + } +}); + +// node_modules/once/once.js +var require_once = __commonJS({ + "node_modules/once/once.js"(exports2, module2) { + var wrappy = require_wrappy(); + module2.exports = wrappy(once); + module2.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; + } + } +}); + +// node_modules/@octokit/request-error/dist-node/index.js +var require_dist_node4 = __commonJS({ + "node_modules/@octokit/request-error/dist-node/index.js"(exports2, module2) { + "use strict"; + var __create2 = Object.create; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __getProtoOf2 = Object.getPrototypeOf; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target, + mod + )); + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + RequestError: () => RequestError + }); + module2.exports = __toCommonJS(dist_src_exports); + var import_deprecation = require_dist_node3(); + var import_once = __toESM2(require_once()); + var logOnceCode = (0, import_once.default)((deprecation) => console.warn(deprecation)); + var logOnceHeaders = (0, import_once.default)((deprecation) => console.warn(deprecation)); + var RequestError = class extends Error { + constructor(message, statusCode, options) { + super(message); + 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; + } + const requestCopy = Object.assign({}, options.request); + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace( + /(? { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + request: () => request + }); + module2.exports = __toCommonJS(dist_src_exports); + var import_endpoint = require_dist_node2(); + var import_universal_user_agent = require_dist_node(); + var VERSION3 = "8.4.1"; + function isPlainObject(value) { + if (typeof value !== "object" || value === null) + return false; + if (Object.prototype.toString.call(value) !== "[object Object]") + return false; + const proto = Object.getPrototypeOf(value); + if (proto === null) + return true; + const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor; + return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value); + } + var import_request_error = require_dist_node4(); + function getBufferResponse(response) { + return response.arrayBuffer(); + } + function fetchWrapper(requestOptions) { + var _a2, _b, _c, _d; + const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console; + const parseSuccessResponseBody = ((_a2 = requestOptions.request) == null ? void 0 : _a2.parseSuccessResponseBody) !== false; + if (isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { + requestOptions.body = JSON.stringify(requestOptions.body); + } + let headers = {}; + let status; + let url; + let { fetch: fetch2 } = globalThis; + if ((_b = requestOptions.request) == null ? void 0 : _b.fetch) { + fetch2 = requestOptions.request.fetch; + } + if (!fetch2) { + throw new Error( + "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing" + ); + } + return fetch2(requestOptions.url, { + method: requestOptions.method, + body: requestOptions.body, + redirect: (_c = requestOptions.request) == null ? void 0 : _c.redirect, + headers: requestOptions.headers, + signal: (_d = requestOptions.request) == null ? void 0 : _d.signal, + // duplex must be set if request.body is ReadableStream or Async Iterables. + // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex. + ...requestOptions.body && { duplex: "half" } + }).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; + } + if (requestOptions.method === "HEAD") { + if (status < 400) { + return; + } + throw new import_request_error.RequestError(response.statusText, status, { + response: { + url, + status, + headers, + data: void 0 + }, + request: requestOptions + }); + } + if (status === 304) { + throw new import_request_error.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 import_request_error.RequestError(toErrorMessage(data), status, { + response: { + url, + status, + headers, + data + }, + request: requestOptions + }); + throw error; + } + return parseSuccessResponseBody ? await getResponseData(response) : response.body; + }).then((data) => { + return { + status, + url, + headers, + data + }; + }).catch((error) => { + if (error instanceof import_request_error.RequestError) + throw error; + else if (error.name === "AbortError") + throw error; + let message = error.message; + if (error.name === "TypeError" && "cause" in error) { + if (error.cause instanceof Error) { + message = error.cause.message; + } else if (typeof error.cause === "string") { + message = error.cause; + } + } + throw new import_request_error.RequestError(message, 500, { + request: requestOptions + }); + }); + } + async function getResponseData(response) { + const contentType = response.headers.get("content-type"); + if (/application\/json/.test(contentType)) { + return response.json().catch(() => response.text()).catch(() => ""); + } + if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { + return response.text(); + } + return getBufferResponse(response); + } + function toErrorMessage(data) { + if (typeof data === "string") + return data; + let suffix; + if ("documentation_url" in data) { + suffix = ` - ${data.documentation_url}`; + } else { + suffix = ""; + } + if ("message" in data) { + if (Array.isArray(data.errors)) { + return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}${suffix}`; + } + return `${data.message}${suffix}`; + } + return `Unknown error: ${JSON.stringify(data)}`; + } + function withDefaults(oldEndpoint, newDefaults) { + const endpoint2 = oldEndpoint.defaults(newDefaults); + const newApi = function(route, parameters) { + const endpointOptions = endpoint2.merge(route, parameters); + if (!endpointOptions.request || !endpointOptions.request.hook) { + return fetchWrapper(endpoint2.parse(endpointOptions)); + } + const request2 = (route2, parameters2) => { + return fetchWrapper( + endpoint2.parse(endpoint2.merge(route2, parameters2)) + ); + }; + Object.assign(request2, { + endpoint: endpoint2, + defaults: withDefaults.bind(null, endpoint2) + }); + return endpointOptions.request.hook(request2, endpointOptions); + }; + return Object.assign(newApi, { + endpoint: endpoint2, + defaults: withDefaults.bind(null, endpoint2) + }); + } + var request = withDefaults(import_endpoint.endpoint, { + headers: { + "user-agent": `octokit-request.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}` + } + }); + } +}); + +// node_modules/@octokit/graphql/dist-node/index.js +var require_dist_node6 = __commonJS({ + "node_modules/@octokit/graphql/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var index_exports = {}; + __export(index_exports, { + GraphqlResponseError: () => GraphqlResponseError, + graphql: () => graphql2, + withCustomRequest: () => withCustomRequest + }); + module2.exports = __toCommonJS(index_exports); + var import_request3 = require_dist_node5(); + var import_universal_user_agent = require_dist_node(); + var VERSION3 = "7.1.1"; + var import_request2 = require_dist_node5(); + var import_request = require_dist_node5(); + function _buildMessageForResponseErrors(data) { + return `Request failed due to following response errors: +` + data.errors.map((e) => ` - ${e.message}`).join("\n"); + } + var GraphqlResponseError = class extends Error { + constructor(request2, headers, response) { + super(_buildMessageForResponseErrors(response)); + this.request = request2; + this.headers = headers; + this.response = response; + this.name = "GraphqlResponseError"; + this.errors = response.errors; + this.data = response.data; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } + }; + var NON_VARIABLE_OPTIONS = [ + "method", + "baseUrl", + "url", + "headers", + "request", + "query", + "mediaType" + ]; + var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"]; + var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; + function graphql(request2, 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; + }, {}); + const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl; + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { + requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + } + return request2(requestOptions).then((response) => { + if (response.data.errors) { + const headers = {}; + for (const key of Object.keys(response.headers)) { + headers[key] = response.headers[key]; + } + throw new GraphqlResponseError( + requestOptions, + headers, + response.data + ); + } + return response.data.data; + }); + } + function withDefaults(request2, newDefaults) { + const newRequest = request2.defaults(newDefaults); + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + return Object.assign(newApi, { + defaults: withDefaults.bind(null, newRequest), + endpoint: newRequest.endpoint + }); + } + var graphql2 = withDefaults(import_request3.request, { + headers: { + "user-agent": `octokit-graphql.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}` + }, + method: "POST", + url: "/graphql" + }); + function withCustomRequest(customRequest) { + return withDefaults(customRequest, { + method: "POST", + url: "/graphql" + }); + } + } +}); + +// node_modules/@octokit/auth-token/dist-node/index.js +var require_dist_node7 = __commonJS({ + "node_modules/@octokit/auth-token/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + createTokenAuth: () => createTokenAuth + }); + module2.exports = __toCommonJS(dist_src_exports); + var REGEX_IS_INSTALLATION_LEGACY = /^v1\./; + var REGEX_IS_INSTALLATION = /^ghs_/; + var REGEX_IS_USER_TO_SERVER = /^ghu_/; + async function auth(token) { + const isApp = token.split(/\./).length === 3; + const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token); + const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token); + const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth"; + return { + type: "token", + token, + tokenType + }; + } + 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); + } + var createTokenAuth = function createTokenAuth2(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) + }); + }; + } +}); + +// node_modules/@octokit/core/dist-node/index.js +var require_dist_node8 = __commonJS({ + "node_modules/@octokit/core/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var index_exports = {}; + __export(index_exports, { + Octokit: () => Octokit + }); + module2.exports = __toCommonJS(index_exports); + var import_universal_user_agent = require_dist_node(); + var import_before_after_hook = require_before_after_hook(); + var import_request = require_dist_node5(); + var import_graphql = require_dist_node6(); + var import_auth_token = require_dist_node7(); + var VERSION3 = "5.2.1"; + var noop3 = () => { + }; + var consoleWarn = console.warn.bind(console); + var consoleError = console.error.bind(console); + var userAgentTrail = `octokit-core.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}`; + var Octokit = class { + static { + this.VERSION = VERSION3; + } + static defaults(defaults3) { + const OctokitWithDefaults = class extends this { + constructor(...args) { + const options = args[0] || {}; + if (typeof defaults3 === "function") { + super(defaults3(options)); + return; + } + super( + Object.assign( + {}, + defaults3, + options, + options.userAgent && defaults3.userAgent ? { + userAgent: `${options.userAgent} ${defaults3.userAgent}` + } : null + ) + ); + } + }; + return OctokitWithDefaults; + } + static { + this.plugins = []; + } + /** + * Attach a plugin (or many) to your Octokit instance. + * + * @example + * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...) + */ + static plugin(...newPlugins) { + const currentPlugins = this.plugins; + const NewOctokit = class extends this { + static { + this.plugins = currentPlugins.concat( + newPlugins.filter((plugin) => !currentPlugins.includes(plugin)) + ); + } + }; + return NewOctokit; + } + constructor(options = {}) { + const hook = new import_before_after_hook.Collection(); + const requestDefaults = { + baseUrl: import_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: "" + } + }; + requestDefaults.headers["user-agent"] = options.userAgent ? `${options.userAgent} ${userAgentTrail}` : userAgentTrail; + 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 = import_request.request.defaults(requestDefaults); + this.graphql = (0, import_graphql.withCustomRequest)(this.request).defaults(requestDefaults); + this.log = Object.assign( + { + debug: noop3, + info: noop3, + warn: consoleWarn, + error: consoleError + }, + options.log + ); + this.hook = hook; + if (!options.authStrategy) { + if (!options.auth) { + this.auth = async () => ({ + type: "unauthenticated" + }); + } else { + const auth = (0, import_auth_token.createTokenAuth)(options.auth); + hook.wrap("request", auth.hook); + this.auth = auth; + } + } else { + const { authStrategy, ...otherOptions } = options; + const auth = authStrategy( + Object.assign( + { + request: this.request, + log: this.log, + // we pass the current octokit instance as well as its constructor options + // to allow for authentication strategies that return a new octokit instance + // that shares the same internal state as the current one. The original + // requirement for this was the "event-octokit" authentication strategy + // of https://github.com/probot/octokit-auth-probot. + octokit: this, + octokitOptions: otherOptions + }, + options.auth + ) + ); + hook.wrap("request", auth.hook); + this.auth = auth; + } + const classConstructor = this.constructor; + for (let i = 0; i < classConstructor.plugins.length; ++i) { + Object.assign(this, classConstructor.plugins[i](this, options)); + } + } + }; + } +}); + +// node_modules/@octokit/plugin-rest-endpoint-methods/dist-node/index.js +var require_dist_node9 = __commonJS({ + "node_modules/@octokit/plugin-rest-endpoint-methods/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + legacyRestEndpointMethods: () => legacyRestEndpointMethods, + restEndpointMethods: () => restEndpointMethods + }); + module2.exports = __toCommonJS(dist_src_exports); + var VERSION3 = "10.4.1"; + var Endpoints = { + actions: { + addCustomLabelsToSelfHostedRunnerForOrg: [ + "POST /orgs/{org}/actions/runners/{runner_id}/labels" + ], + addCustomLabelsToSelfHostedRunnerForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + addSelectedRepoToOrgSecret: [ + "PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}" + ], + addSelectedRepoToOrgVariable: [ + "PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}" + ], + approveWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve" + ], + cancelWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel" + ], + createEnvironmentVariable: [ + "POST /repositories/{repository_id}/environments/{environment_name}/variables" + ], + createOrUpdateEnvironmentSecret: [ + "PUT /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}" + ], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"], + createOrUpdateRepoSecret: [ + "PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}" + ], + createOrgVariable: ["POST /orgs/{org}/actions/variables"], + createRegistrationTokenForOrg: [ + "POST /orgs/{org}/actions/runners/registration-token" + ], + createRegistrationTokenForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/registration-token" + ], + createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"], + createRemoveTokenForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/remove-token" + ], + createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"], + createWorkflowDispatch: [ + "POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches" + ], + deleteActionsCacheById: [ + "DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}" + ], + deleteActionsCacheByKey: [ + "DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}" + ], + deleteArtifact: [ + "DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}" + ], + deleteEnvironmentSecret: [ + "DELETE /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}" + ], + deleteEnvironmentVariable: [ + "DELETE /repositories/{repository_id}/environments/{environment_name}/variables/{name}" + ], + deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"], + deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"], + deleteRepoSecret: [ + "DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}" + ], + deleteRepoVariable: [ + "DELETE /repos/{owner}/{repo}/actions/variables/{name}" + ], + deleteSelfHostedRunnerFromOrg: [ + "DELETE /orgs/{org}/actions/runners/{runner_id}" + ], + deleteSelfHostedRunnerFromRepo: [ + "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}" + ], + deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"], + deleteWorkflowRunLogs: [ + "DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs" + ], + disableSelectedRepositoryGithubActionsOrganization: [ + "DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}" + ], + disableWorkflow: [ + "PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable" + ], + downloadArtifact: [ + "GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}" + ], + downloadJobLogsForWorkflowRun: [ + "GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs" + ], + downloadWorkflowRunAttemptLogs: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs" + ], + downloadWorkflowRunLogs: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs" + ], + enableSelectedRepositoryGithubActionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/repositories/{repository_id}" + ], + enableWorkflow: [ + "PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable" + ], + forceCancelWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel" + ], + generateRunnerJitconfigForOrg: [ + "POST /orgs/{org}/actions/runners/generate-jitconfig" + ], + generateRunnerJitconfigForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig" + ], + getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"], + getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"], + getActionsCacheUsageByRepoForOrg: [ + "GET /orgs/{org}/actions/cache/usage-by-repository" + ], + getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"], + getAllowedActionsOrganization: [ + "GET /orgs/{org}/actions/permissions/selected-actions" + ], + getAllowedActionsRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions/selected-actions" + ], + getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + getCustomOidcSubClaimForRepo: [ + "GET /repos/{owner}/{repo}/actions/oidc/customization/sub" + ], + getEnvironmentPublicKey: [ + "GET /repositories/{repository_id}/environments/{environment_name}/secrets/public-key" + ], + getEnvironmentSecret: [ + "GET /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}" + ], + getEnvironmentVariable: [ + "GET /repositories/{repository_id}/environments/{environment_name}/variables/{name}" + ], + getGithubActionsDefaultWorkflowPermissionsOrganization: [ + "GET /orgs/{org}/actions/permissions/workflow" + ], + getGithubActionsDefaultWorkflowPermissionsRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions/workflow" + ], + getGithubActionsPermissionsOrganization: [ + "GET /orgs/{org}/actions/permissions" + ], + getGithubActionsPermissionsRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions" + ], + getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"], + getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"], + getOrgVariable: ["GET /orgs/{org}/actions/variables/{name}"], + getPendingDeploymentsForRun: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments" + ], + getRepoPermissions: [ + "GET /repos/{owner}/{repo}/actions/permissions", + {}, + { renamed: ["actions", "getGithubActionsPermissionsRepository"] } + ], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + getRepoVariable: ["GET /repos/{owner}/{repo}/actions/variables/{name}"], + getReviewsForRun: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals" + ], + getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"], + getSelfHostedRunnerForRepo: [ + "GET /repos/{owner}/{repo}/actions/runners/{runner_id}" + ], + getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"], + getWorkflowAccessToRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions/access" + ], + getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], + getWorkflowRunAttempt: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}" + ], + getWorkflowRunUsage: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing" + ], + getWorkflowUsage: [ + "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing" + ], + listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], + listEnvironmentSecrets: [ + "GET /repositories/{repository_id}/environments/{environment_name}/secrets" + ], + listEnvironmentVariables: [ + "GET /repositories/{repository_id}/environments/{environment_name}/variables" + ], + listJobsForWorkflowRun: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs" + ], + listJobsForWorkflowRunAttempt: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs" + ], + listLabelsForSelfHostedRunnerForOrg: [ + "GET /orgs/{org}/actions/runners/{runner_id}/labels" + ], + listLabelsForSelfHostedRunnerForRepo: [ + "GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + listOrgSecrets: ["GET /orgs/{org}/actions/secrets"], + listOrgVariables: ["GET /orgs/{org}/actions/variables"], + listRepoOrganizationSecrets: [ + "GET /repos/{owner}/{repo}/actions/organization-secrets" + ], + listRepoOrganizationVariables: [ + "GET /repos/{owner}/{repo}/actions/organization-variables" + ], + listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"], + listRepoVariables: ["GET /repos/{owner}/{repo}/actions/variables"], + 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" + ], + listSelectedReposForOrgVariable: [ + "GET /orgs/{org}/actions/variables/{name}/repositories" + ], + listSelectedRepositoriesEnabledGithubActionsOrganization: [ + "GET /orgs/{org}/actions/permissions/repositories" + ], + listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"], + listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"], + listWorkflowRunArtifacts: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts" + ], + listWorkflowRuns: [ + "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs" + ], + listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"], + reRunJobForWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun" + ], + reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], + reRunWorkflowFailedJobs: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs" + ], + removeAllCustomLabelsFromSelfHostedRunnerForOrg: [ + "DELETE /orgs/{org}/actions/runners/{runner_id}/labels" + ], + removeAllCustomLabelsFromSelfHostedRunnerForRepo: [ + "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + removeCustomLabelFromSelfHostedRunnerForOrg: [ + "DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}" + ], + removeCustomLabelFromSelfHostedRunnerForRepo: [ + "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}" + ], + removeSelectedRepoFromOrgSecret: [ + "DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}" + ], + removeSelectedRepoFromOrgVariable: [ + "DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}" + ], + reviewCustomGatesForRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule" + ], + reviewPendingDeploymentsForRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments" + ], + setAllowedActionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/selected-actions" + ], + setAllowedActionsRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions/selected-actions" + ], + setCustomLabelsForSelfHostedRunnerForOrg: [ + "PUT /orgs/{org}/actions/runners/{runner_id}/labels" + ], + setCustomLabelsForSelfHostedRunnerForRepo: [ + "PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + setCustomOidcSubClaimForRepo: [ + "PUT /repos/{owner}/{repo}/actions/oidc/customization/sub" + ], + setGithubActionsDefaultWorkflowPermissionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/workflow" + ], + setGithubActionsDefaultWorkflowPermissionsRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions/workflow" + ], + setGithubActionsPermissionsOrganization: [ + "PUT /orgs/{org}/actions/permissions" + ], + setGithubActionsPermissionsRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions" + ], + setSelectedReposForOrgSecret: [ + "PUT /orgs/{org}/actions/secrets/{secret_name}/repositories" + ], + setSelectedReposForOrgVariable: [ + "PUT /orgs/{org}/actions/variables/{name}/repositories" + ], + setSelectedRepositoriesEnabledGithubActionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/repositories" + ], + setWorkflowAccessToRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions/access" + ], + updateEnvironmentVariable: [ + "PATCH /repositories/{repository_id}/environments/{environment_name}/variables/{name}" + ], + updateOrgVariable: ["PATCH /orgs/{org}/actions/variables/{name}"], + updateRepoVariable: [ + "PATCH /repos/{owner}/{repo}/actions/variables/{name}" + ] + }, + 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"], + markThreadAsDone: ["DELETE /notifications/threads/{thread_id}"], + markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"], + setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"], + setThreadSubscription: [ + "PUT /notifications/threads/{thread_id}/subscription" + ], + starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"], + unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"] + }, + apps: { + addRepoToInstallation: [ + "PUT /user/installations/{installation_id}/repositories/{repository_id}", + {}, + { renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] } + ], + addRepoToInstallationForAuthenticatedUser: [ + "PUT /user/installations/{installation_id}/repositories/{repository_id}" + ], + checkToken: ["POST /applications/{client_id}/token"], + createFromManifest: ["POST /app-manifests/{code}/conversions"], + createInstallationAccessToken: [ + "POST /app/installations/{installation_id}/access_tokens" + ], + deleteAuthorization: ["DELETE /applications/{client_id}/grant"], + deleteInstallation: ["DELETE /app/installations/{installation_id}"], + deleteToken: ["DELETE /applications/{client_id}/token"], + getAuthenticated: ["GET /app"], + getBySlug: ["GET /apps/{app_slug}"], + getInstallation: ["GET /app/installations/{installation_id}"], + getOrgInstallation: ["GET /orgs/{org}/installation"], + getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"], + getSubscriptionPlanForAccount: [ + "GET /marketplace_listing/accounts/{account_id}" + ], + getSubscriptionPlanForAccountStubbed: [ + "GET /marketplace_listing/stubbed/accounts/{account_id}" + ], + getUserInstallation: ["GET /users/{username}/installation"], + getWebhookConfigForApp: ["GET /app/hook/config"], + getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"], + listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"], + listAccountsForPlanStubbed: [ + "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts" + ], + listInstallationReposForAuthenticatedUser: [ + "GET /user/installations/{installation_id}/repositories" + ], + listInstallationRequestsForAuthenticatedApp: [ + "GET /app/installation-requests" + ], + listInstallations: ["GET /app/installations"], + listInstallationsForAuthenticatedUser: ["GET /user/installations"], + listPlans: ["GET /marketplace_listing/plans"], + listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"], + listReposAccessibleToInstallation: ["GET /installation/repositories"], + listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"], + listSubscriptionsForAuthenticatedUserStubbed: [ + "GET /user/marketplace_purchases/stubbed" + ], + listWebhookDeliveries: ["GET /app/hook/deliveries"], + redeliverWebhookDelivery: [ + "POST /app/hook/deliveries/{delivery_id}/attempts" + ], + removeRepoFromInstallation: [ + "DELETE /user/installations/{installation_id}/repositories/{repository_id}", + {}, + { renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] } + ], + removeRepoFromInstallationForAuthenticatedUser: [ + "DELETE /user/installations/{installation_id}/repositories/{repository_id}" + ], + resetToken: ["PATCH /applications/{client_id}/token"], + revokeInstallationAccessToken: ["DELETE /installation/token"], + scopeToken: ["POST /applications/{client_id}/token/scoped"], + suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"], + unsuspendInstallation: [ + "DELETE /app/installations/{installation_id}/suspended" + ], + updateWebhookConfigForApp: ["PATCH /app/hook/config"] + }, + billing: { + getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"], + getGithubActionsBillingUser: [ + "GET /users/{username}/settings/billing/actions" + ], + getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"], + getGithubPackagesBillingUser: [ + "GET /users/{username}/settings/billing/packages" + ], + getSharedStorageBillingOrg: [ + "GET /orgs/{org}/settings/billing/shared-storage" + ], + getSharedStorageBillingUser: [ + "GET /users/{username}/settings/billing/shared-storage" + ] + }, + checks: { + create: ["POST /repos/{owner}/{repo}/check-runs"], + createSuite: ["POST /repos/{owner}/{repo}/check-suites"], + get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"], + getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"], + listAnnotations: [ + "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations" + ], + listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"], + listForSuite: [ + "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs" + ], + listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"], + rerequestRun: [ + "POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest" + ], + rerequestSuite: [ + "POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest" + ], + setSuitesPreferences: [ + "PATCH /repos/{owner}/{repo}/check-suites/preferences" + ], + update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"] + }, + codeScanning: { + deleteAnalysis: [ + "DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}" + ], + getAlert: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", + {}, + { renamedParameters: { alert_id: "alert_number" } } + ], + getAnalysis: [ + "GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}" + ], + getCodeqlDatabase: [ + "GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}" + ], + getDefaultSetup: ["GET /repos/{owner}/{repo}/code-scanning/default-setup"], + getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"], + listAlertInstances: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances" + ], + listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"], + listAlertsInstances: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", + {}, + { renamed: ["codeScanning", "listAlertInstances"] } + ], + listCodeqlDatabases: [ + "GET /repos/{owner}/{repo}/code-scanning/codeql/databases" + ], + listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"], + updateAlert: [ + "PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}" + ], + updateDefaultSetup: [ + "PATCH /repos/{owner}/{repo}/code-scanning/default-setup" + ], + uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"] + }, + codesOfConduct: { + getAllCodesOfConduct: ["GET /codes_of_conduct"], + getConductCode: ["GET /codes_of_conduct/{key}"] + }, + codespaces: { + addRepositoryForSecretForAuthenticatedUser: [ + "PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + addSelectedRepoToOrgSecret: [ + "PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + checkPermissionsForDevcontainer: [ + "GET /repos/{owner}/{repo}/codespaces/permissions_check" + ], + codespaceMachinesForAuthenticatedUser: [ + "GET /user/codespaces/{codespace_name}/machines" + ], + createForAuthenticatedUser: ["POST /user/codespaces"], + createOrUpdateOrgSecret: [ + "PUT /orgs/{org}/codespaces/secrets/{secret_name}" + ], + createOrUpdateRepoSecret: [ + "PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}" + ], + createOrUpdateSecretForAuthenticatedUser: [ + "PUT /user/codespaces/secrets/{secret_name}" + ], + createWithPrForAuthenticatedUser: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces" + ], + createWithRepoForAuthenticatedUser: [ + "POST /repos/{owner}/{repo}/codespaces" + ], + deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"], + deleteFromOrganization: [ + "DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}" + ], + deleteOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"], + deleteRepoSecret: [ + "DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}" + ], + deleteSecretForAuthenticatedUser: [ + "DELETE /user/codespaces/secrets/{secret_name}" + ], + exportForAuthenticatedUser: [ + "POST /user/codespaces/{codespace_name}/exports" + ], + getCodespacesForUserInOrg: [ + "GET /orgs/{org}/members/{username}/codespaces" + ], + getExportDetailsForAuthenticatedUser: [ + "GET /user/codespaces/{codespace_name}/exports/{export_id}" + ], + getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"], + getOrgPublicKey: ["GET /orgs/{org}/codespaces/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}"], + getPublicKeyForAuthenticatedUser: [ + "GET /user/codespaces/secrets/public-key" + ], + getRepoPublicKey: [ + "GET /repos/{owner}/{repo}/codespaces/secrets/public-key" + ], + getRepoSecret: [ + "GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}" + ], + getSecretForAuthenticatedUser: [ + "GET /user/codespaces/secrets/{secret_name}" + ], + listDevcontainersInRepositoryForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces/devcontainers" + ], + listForAuthenticatedUser: ["GET /user/codespaces"], + listInOrganization: [ + "GET /orgs/{org}/codespaces", + {}, + { renamedParameters: { org_id: "org" } } + ], + listInRepositoryForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces" + ], + listOrgSecrets: ["GET /orgs/{org}/codespaces/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"], + listRepositoriesForSecretForAuthenticatedUser: [ + "GET /user/codespaces/secrets/{secret_name}/repositories" + ], + listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"], + listSelectedReposForOrgSecret: [ + "GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories" + ], + preFlightWithRepoForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces/new" + ], + publishForAuthenticatedUser: [ + "POST /user/codespaces/{codespace_name}/publish" + ], + removeRepositoryForSecretForAuthenticatedUser: [ + "DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + removeSelectedRepoFromOrgSecret: [ + "DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + repoMachinesForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces/machines" + ], + setRepositoriesForSecretForAuthenticatedUser: [ + "PUT /user/codespaces/secrets/{secret_name}/repositories" + ], + setSelectedReposForOrgSecret: [ + "PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories" + ], + startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"], + stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"], + stopInOrganization: [ + "POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop" + ], + updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"] + }, + copilot: { + addCopilotSeatsForTeams: [ + "POST /orgs/{org}/copilot/billing/selected_teams" + ], + addCopilotSeatsForUsers: [ + "POST /orgs/{org}/copilot/billing/selected_users" + ], + cancelCopilotSeatAssignmentForTeams: [ + "DELETE /orgs/{org}/copilot/billing/selected_teams" + ], + cancelCopilotSeatAssignmentForUsers: [ + "DELETE /orgs/{org}/copilot/billing/selected_users" + ], + getCopilotOrganizationDetails: ["GET /orgs/{org}/copilot/billing"], + getCopilotSeatDetailsForUser: [ + "GET /orgs/{org}/members/{username}/copilot" + ], + listCopilotSeats: ["GET /orgs/{org}/copilot/billing/seats"] + }, + dependabot: { + addSelectedRepoToOrgSecret: [ + "PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}" + ], + createOrUpdateOrgSecret: [ + "PUT /orgs/{org}/dependabot/secrets/{secret_name}" + ], + createOrUpdateRepoSecret: [ + "PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}" + ], + deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"], + deleteRepoSecret: [ + "DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}" + ], + getAlert: ["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"], + getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"], + getRepoPublicKey: [ + "GET /repos/{owner}/{repo}/dependabot/secrets/public-key" + ], + getRepoSecret: [ + "GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}" + ], + listAlertsForEnterprise: [ + "GET /enterprises/{enterprise}/dependabot/alerts" + ], + listAlertsForOrg: ["GET /orgs/{org}/dependabot/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/dependabot/alerts"], + listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"], + listSelectedReposForOrgSecret: [ + "GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories" + ], + removeSelectedRepoFromOrgSecret: [ + "DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}" + ], + setSelectedReposForOrgSecret: [ + "PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories" + ], + updateAlert: [ + "PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}" + ] + }, + dependencyGraph: { + createRepositorySnapshot: [ + "POST /repos/{owner}/{repo}/dependency-graph/snapshots" + ], + diffRange: [ + "GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}" + ], + exportSbom: ["GET /repos/{owner}/{repo}/dependency-graph/sbom"] + }, + emojis: { get: ["GET /emojis"] }, + gists: { + checkIsStarred: ["GET /gists/{gist_id}/star"], + create: ["POST /gists"], + createComment: ["POST /gists/{gist_id}/comments"], + delete: ["DELETE /gists/{gist_id}"], + deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"], + fork: ["POST /gists/{gist_id}/forks"], + get: ["GET /gists/{gist_id}"], + getComment: ["GET /gists/{gist_id}/comments/{comment_id}"], + getRevision: ["GET /gists/{gist_id}/{sha}"], + list: ["GET /gists"], + listComments: ["GET /gists/{gist_id}/comments"], + listCommits: ["GET /gists/{gist_id}/commits"], + listForUser: ["GET /users/{username}/gists"], + listForks: ["GET /gists/{gist_id}/forks"], + listPublic: ["GET /gists/public"], + listStarred: ["GET /gists/starred"], + star: ["PUT /gists/{gist_id}/star"], + unstar: ["DELETE /gists/{gist_id}/star"], + update: ["PATCH /gists/{gist_id}"], + updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"] + }, + git: { + createBlob: ["POST /repos/{owner}/{repo}/git/blobs"], + createCommit: ["POST /repos/{owner}/{repo}/git/commits"], + createRef: ["POST /repos/{owner}/{repo}/git/refs"], + createTag: ["POST /repos/{owner}/{repo}/git/tags"], + createTree: ["POST /repos/{owner}/{repo}/git/trees"], + deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"], + getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"], + getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"], + getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"], + getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"], + getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"], + listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"], + updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"] + }, + gitignore: { + getAllTemplates: ["GET /gitignore/templates"], + getTemplate: ["GET /gitignore/templates/{name}"] + }, + interactions: { + getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"], + getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"], + getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"], + getRestrictionsForYourPublicRepos: [ + "GET /user/interaction-limits", + {}, + { renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] } + ], + removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"], + removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"], + removeRestrictionsForRepo: [ + "DELETE /repos/{owner}/{repo}/interaction-limits" + ], + removeRestrictionsForYourPublicRepos: [ + "DELETE /user/interaction-limits", + {}, + { renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] } + ], + setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"], + setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"], + setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"], + setRestrictionsForYourPublicRepos: [ + "PUT /user/interaction-limits", + {}, + { renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] } + ] + }, + issues: { + addAssignees: [ + "POST /repos/{owner}/{repo}/issues/{issue_number}/assignees" + ], + addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"], + checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"], + checkUserCanBeAssignedToIssue: [ + "GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}" + ], + create: ["POST /repos/{owner}/{repo}/issues"], + createComment: [ + "POST /repos/{owner}/{repo}/issues/{issue_number}/comments" + ], + createLabel: ["POST /repos/{owner}/{repo}/labels"], + createMilestone: ["POST /repos/{owner}/{repo}/milestones"], + deleteComment: [ + "DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}" + ], + deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"], + deleteMilestone: [ + "DELETE /repos/{owner}/{repo}/milestones/{milestone_number}" + ], + get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"], + getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"], + getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"], + getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"], + getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"], + list: ["GET /issues"], + listAssignees: ["GET /repos/{owner}/{repo}/assignees"], + listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"], + listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"], + listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"], + listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"], + listEventsForTimeline: [ + "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline" + ], + listForAuthenticatedUser: ["GET /user/issues"], + listForOrg: ["GET /orgs/{org}/issues"], + listForRepo: ["GET /repos/{owner}/{repo}/issues"], + listLabelsForMilestone: [ + "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels" + ], + listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], + listLabelsOnIssue: [ + "GET /repos/{owner}/{repo}/issues/{issue_number}/labels" + ], + listMilestones: ["GET /repos/{owner}/{repo}/milestones"], + lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"], + removeAllLabels: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels" + ], + removeAssignees: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees" + ], + removeLabel: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}" + ], + setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"], + unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"], + update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"], + updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"], + updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"], + updateMilestone: [ + "PATCH /repos/{owner}/{repo}/milestones/{milestone_number}" + ] + }, + licenses: { + get: ["GET /licenses/{license}"], + getAllCommonlyUsed: ["GET /licenses"], + getForRepo: ["GET /repos/{owner}/{repo}/license"] + }, + markdown: { + render: ["POST /markdown"], + renderRaw: [ + "POST /markdown/raw", + { headers: { "content-type": "text/plain; charset=utf-8" } } + ] + }, + meta: { + get: ["GET /meta"], + getAllVersions: ["GET /versions"], + getOctocat: ["GET /octocat"], + getZen: ["GET /zen"], + root: ["GET /"] + }, + migrations: { + cancelImport: [ + "DELETE /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.cancelImport() is deprecated, see https://docs.github.com/rest/migrations/source-imports#cancel-an-import" + } + ], + deleteArchiveForAuthenticatedUser: [ + "DELETE /user/migrations/{migration_id}/archive" + ], + deleteArchiveForOrg: [ + "DELETE /orgs/{org}/migrations/{migration_id}/archive" + ], + downloadArchiveForOrg: [ + "GET /orgs/{org}/migrations/{migration_id}/archive" + ], + getArchiveForAuthenticatedUser: [ + "GET /user/migrations/{migration_id}/archive" + ], + getCommitAuthors: [ + "GET /repos/{owner}/{repo}/import/authors", + {}, + { + deprecated: "octokit.rest.migrations.getCommitAuthors() is deprecated, see https://docs.github.com/rest/migrations/source-imports#get-commit-authors" + } + ], + getImportStatus: [ + "GET /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.getImportStatus() is deprecated, see https://docs.github.com/rest/migrations/source-imports#get-an-import-status" + } + ], + getLargeFiles: [ + "GET /repos/{owner}/{repo}/import/large_files", + {}, + { + deprecated: "octokit.rest.migrations.getLargeFiles() is deprecated, see https://docs.github.com/rest/migrations/source-imports#get-large-files" + } + ], + getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"], + getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"], + listForAuthenticatedUser: ["GET /user/migrations"], + listForOrg: ["GET /orgs/{org}/migrations"], + listReposForAuthenticatedUser: [ + "GET /user/migrations/{migration_id}/repositories" + ], + listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"], + listReposForUser: [ + "GET /user/migrations/{migration_id}/repositories", + {}, + { renamed: ["migrations", "listReposForAuthenticatedUser"] } + ], + mapCommitAuthor: [ + "PATCH /repos/{owner}/{repo}/import/authors/{author_id}", + {}, + { + deprecated: "octokit.rest.migrations.mapCommitAuthor() is deprecated, see https://docs.github.com/rest/migrations/source-imports#map-a-commit-author" + } + ], + setLfsPreference: [ + "PATCH /repos/{owner}/{repo}/import/lfs", + {}, + { + deprecated: "octokit.rest.migrations.setLfsPreference() is deprecated, see https://docs.github.com/rest/migrations/source-imports#update-git-lfs-preference" + } + ], + startForAuthenticatedUser: ["POST /user/migrations"], + startForOrg: ["POST /orgs/{org}/migrations"], + startImport: [ + "PUT /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.startImport() is deprecated, see https://docs.github.com/rest/migrations/source-imports#start-an-import" + } + ], + unlockRepoForAuthenticatedUser: [ + "DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock" + ], + unlockRepoForOrg: [ + "DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock" + ], + updateImport: [ + "PATCH /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.updateImport() is deprecated, see https://docs.github.com/rest/migrations/source-imports#update-an-import" + } + ] + }, + oidc: { + getOidcCustomSubTemplateForOrg: [ + "GET /orgs/{org}/actions/oidc/customization/sub" + ], + updateOidcCustomSubTemplateForOrg: [ + "PUT /orgs/{org}/actions/oidc/customization/sub" + ] + }, + orgs: { + addSecurityManagerTeam: [ + "PUT /orgs/{org}/security-managers/teams/{team_slug}" + ], + assignTeamToOrgRole: [ + "PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}" + ], + assignUserToOrgRole: [ + "PUT /orgs/{org}/organization-roles/users/{username}/{role_id}" + ], + 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}" + ], + createCustomOrganizationRole: ["POST /orgs/{org}/organization-roles"], + createInvitation: ["POST /orgs/{org}/invitations"], + createOrUpdateCustomProperties: ["PATCH /orgs/{org}/properties/schema"], + createOrUpdateCustomPropertiesValuesForRepos: [ + "PATCH /orgs/{org}/properties/values" + ], + createOrUpdateCustomProperty: [ + "PUT /orgs/{org}/properties/schema/{custom_property_name}" + ], + createWebhook: ["POST /orgs/{org}/hooks"], + delete: ["DELETE /orgs/{org}"], + deleteCustomOrganizationRole: [ + "DELETE /orgs/{org}/organization-roles/{role_id}" + ], + deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"], + enableOrDisableSecurityProductOnAllOrgRepos: [ + "POST /orgs/{org}/{security_product}/{enablement}" + ], + get: ["GET /orgs/{org}"], + getAllCustomProperties: ["GET /orgs/{org}/properties/schema"], + getCustomProperty: [ + "GET /orgs/{org}/properties/schema/{custom_property_name}" + ], + getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"], + getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"], + getOrgRole: ["GET /orgs/{org}/organization-roles/{role_id}"], + 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"], + listCustomPropertiesValuesForRepos: ["GET /orgs/{org}/properties/values"], + 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"], + listOrgRoleTeams: ["GET /orgs/{org}/organization-roles/{role_id}/teams"], + listOrgRoleUsers: ["GET /orgs/{org}/organization-roles/{role_id}/users"], + listOrgRoles: ["GET /orgs/{org}/organization-roles"], + listOrganizationFineGrainedPermissions: [ + "GET /orgs/{org}/organization-fine-grained-permissions" + ], + listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"], + listPatGrantRepositories: [ + "GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories" + ], + listPatGrantRequestRepositories: [ + "GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories" + ], + listPatGrantRequests: ["GET /orgs/{org}/personal-access-token-requests"], + listPatGrants: ["GET /orgs/{org}/personal-access-tokens"], + listPendingInvitations: ["GET /orgs/{org}/invitations"], + listPublicMembers: ["GET /orgs/{org}/public_members"], + listSecurityManagerTeams: ["GET /orgs/{org}/security-managers"], + listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /orgs/{org}/hooks"], + patchCustomOrganizationRole: [ + "PATCH /orgs/{org}/organization-roles/{role_id}" + ], + pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: [ + "POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts" + ], + removeCustomProperty: [ + "DELETE /orgs/{org}/properties/schema/{custom_property_name}" + ], + removeMember: ["DELETE /orgs/{org}/members/{username}"], + removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"], + removeOutsideCollaborator: [ + "DELETE /orgs/{org}/outside_collaborators/{username}" + ], + removePublicMembershipForAuthenticatedUser: [ + "DELETE /orgs/{org}/public_members/{username}" + ], + removeSecurityManagerTeam: [ + "DELETE /orgs/{org}/security-managers/teams/{team_slug}" + ], + reviewPatGrantRequest: [ + "POST /orgs/{org}/personal-access-token-requests/{pat_request_id}" + ], + reviewPatGrantRequestsInBulk: [ + "POST /orgs/{org}/personal-access-token-requests" + ], + revokeAllOrgRolesTeam: [ + "DELETE /orgs/{org}/organization-roles/teams/{team_slug}" + ], + revokeAllOrgRolesUser: [ + "DELETE /orgs/{org}/organization-roles/users/{username}" + ], + revokeOrgRoleTeam: [ + "DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}" + ], + revokeOrgRoleUser: [ + "DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}" + ], + 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}" + ], + updatePatAccess: ["POST /orgs/{org}/personal-access-tokens/{pat_id}"], + updatePatAccesses: ["POST /orgs/{org}/personal-access-tokens"], + updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"], + updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"] + }, + packages: { + deletePackageForAuthenticatedUser: [ + "DELETE /user/packages/{package_type}/{package_name}" + ], + deletePackageForOrg: [ + "DELETE /orgs/{org}/packages/{package_type}/{package_name}" + ], + deletePackageForUser: [ + "DELETE /users/{username}/packages/{package_type}/{package_name}" + ], + deletePackageVersionForAuthenticatedUser: [ + "DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + deletePackageVersionForOrg: [ + "DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + deletePackageVersionForUser: [ + "DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + getAllPackageVersionsForAPackageOwnedByAnOrg: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions", + {}, + { renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] } + ], + getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}/versions", + {}, + { + renamed: [ + "packages", + "getAllPackageVersionsForPackageOwnedByAuthenticatedUser" + ] + } + ], + getAllPackageVersionsForPackageOwnedByAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}/versions" + ], + getAllPackageVersionsForPackageOwnedByOrg: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions" + ], + getAllPackageVersionsForPackageOwnedByUser: [ + "GET /users/{username}/packages/{package_type}/{package_name}/versions" + ], + getPackageForAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}" + ], + getPackageForOrganization: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}" + ], + getPackageForUser: [ + "GET /users/{username}/packages/{package_type}/{package_name}" + ], + getPackageVersionForAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + getPackageVersionForOrganization: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + getPackageVersionForUser: [ + "GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + listDockerMigrationConflictingPackagesForAuthenticatedUser: [ + "GET /user/docker/conflicts" + ], + listDockerMigrationConflictingPackagesForOrganization: [ + "GET /orgs/{org}/docker/conflicts" + ], + listDockerMigrationConflictingPackagesForUser: [ + "GET /users/{username}/docker/conflicts" + ], + listPackagesForAuthenticatedUser: ["GET /user/packages"], + listPackagesForOrganization: ["GET /orgs/{org}/packages"], + listPackagesForUser: ["GET /users/{username}/packages"], + restorePackageForAuthenticatedUser: [ + "POST /user/packages/{package_type}/{package_name}/restore{?token}" + ], + restorePackageForOrg: [ + "POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}" + ], + restorePackageForUser: [ + "POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}" + ], + restorePackageVersionForAuthenticatedUser: [ + "POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore" + ], + restorePackageVersionForOrg: [ + "POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore" + ], + restorePackageVersionForUser: [ + "POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore" + ] + }, + projects: { + addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}"], + createCard: ["POST /projects/columns/{column_id}/cards"], + createColumn: ["POST /projects/{project_id}/columns"], + createForAuthenticatedUser: ["POST /user/projects"], + createForOrg: ["POST /orgs/{org}/projects"], + createForRepo: ["POST /repos/{owner}/{repo}/projects"], + delete: ["DELETE /projects/{project_id}"], + deleteCard: ["DELETE /projects/columns/cards/{card_id}"], + deleteColumn: ["DELETE /projects/columns/{column_id}"], + get: ["GET /projects/{project_id}"], + getCard: ["GET /projects/columns/cards/{card_id}"], + getColumn: ["GET /projects/columns/{column_id}"], + getPermissionForUser: [ + "GET /projects/{project_id}/collaborators/{username}/permission" + ], + listCards: ["GET /projects/columns/{column_id}/cards"], + listCollaborators: ["GET /projects/{project_id}/collaborators"], + listColumns: ["GET /projects/{project_id}/columns"], + listForOrg: ["GET /orgs/{org}/projects"], + listForRepo: ["GET /repos/{owner}/{repo}/projects"], + listForUser: ["GET /users/{username}/projects"], + moveCard: ["POST /projects/columns/cards/{card_id}/moves"], + moveColumn: ["POST /projects/columns/{column_id}/moves"], + removeCollaborator: [ + "DELETE /projects/{project_id}/collaborators/{username}" + ], + update: ["PATCH /projects/{project_id}"], + updateCard: ["PATCH /projects/columns/cards/{card_id}"], + updateColumn: ["PATCH /projects/columns/{column_id}"] + }, + pulls: { + checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + create: ["POST /repos/{owner}/{repo}/pulls"], + createReplyForReviewComment: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies" + ], + createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + createReviewComment: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/comments" + ], + deletePendingReview: [ + "DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}" + ], + deleteReviewComment: [ + "DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}" + ], + dismissReview: [ + "PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals" + ], + get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"], + getReview: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}" + ], + getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + list: ["GET /repos/{owner}/{repo}/pulls"], + listCommentsForReview: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments" + ], + listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"], + listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"], + listRequestedReviewers: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers" + ], + listReviewComments: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments" + ], + listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"], + listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + removeRequestedReviewers: [ + "DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers" + ], + requestReviewers: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers" + ], + submitReview: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events" + ], + update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"], + updateBranch: [ + "PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch" + ], + updateReview: [ + "PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}" + ], + updateReviewComment: [ + "PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}" + ] + }, + rateLimit: { get: ["GET /rate_limit"] }, + reactions: { + createForCommitComment: [ + "POST /repos/{owner}/{repo}/comments/{comment_id}/reactions" + ], + createForIssue: [ + "POST /repos/{owner}/{repo}/issues/{issue_number}/reactions" + ], + createForIssueComment: [ + "POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions" + ], + createForPullRequestReviewComment: [ + "POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions" + ], + createForRelease: [ + "POST /repos/{owner}/{repo}/releases/{release_id}/reactions" + ], + createForTeamDiscussionCommentInOrg: [ + "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions" + ], + createForTeamDiscussionInOrg: [ + "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions" + ], + deleteForCommitComment: [ + "DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}" + ], + deleteForIssue: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}" + ], + deleteForIssueComment: [ + "DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}" + ], + deleteForPullRequestComment: [ + "DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}" + ], + deleteForRelease: [ + "DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}" + ], + deleteForTeamDiscussion: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}" + ], + deleteForTeamDiscussionComment: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}" + ], + listForCommitComment: [ + "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions" + ], + listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + listForIssueComment: [ + "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions" + ], + listForPullRequestReviewComment: [ + "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions" + ], + listForRelease: [ + "GET /repos/{owner}/{repo}/releases/{release_id}/reactions" + ], + listForTeamDiscussionCommentInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions" + ], + listForTeamDiscussionInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions" + ] + }, + repos: { + acceptInvitation: [ + "PATCH /user/repository_invitations/{invitation_id}", + {}, + { renamed: ["repos", "acceptInvitationForAuthenticatedUser"] } + ], + acceptInvitationForAuthenticatedUser: [ + "PATCH /user/repository_invitations/{invitation_id}" + ], + addAppAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], + addStatusCheckContexts: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + addTeamAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + addUserAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + cancelPagesDeployment: [ + "POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel" + ], + checkAutomatedSecurityFixes: [ + "GET /repos/{owner}/{repo}/automated-security-fixes" + ], + checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], + checkVulnerabilityAlerts: [ + "GET /repos/{owner}/{repo}/vulnerability-alerts" + ], + codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"], + compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], + compareCommitsWithBasehead: [ + "GET /repos/{owner}/{repo}/compare/{basehead}" + ], + createAutolink: ["POST /repos/{owner}/{repo}/autolinks"], + createCommitComment: [ + "POST /repos/{owner}/{repo}/commits/{commit_sha}/comments" + ], + createCommitSignatureProtection: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures" + ], + createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], + createDeployKey: ["POST /repos/{owner}/{repo}/keys"], + createDeployment: ["POST /repos/{owner}/{repo}/deployments"], + createDeploymentBranchPolicy: [ + "POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies" + ], + createDeploymentProtectionRule: [ + "POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules" + ], + 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"], + createOrUpdateCustomPropertiesValues: [ + "PATCH /repos/{owner}/{repo}/properties/values" + ], + createOrUpdateEnvironment: [ + "PUT /repos/{owner}/{repo}/environments/{environment_name}" + ], + createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"], + createOrgRuleset: ["POST /orgs/{org}/rulesets"], + createPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments"], + createPagesSite: ["POST /repos/{owner}/{repo}/pages"], + createRelease: ["POST /repos/{owner}/{repo}/releases"], + createRepoRuleset: ["POST /repos/{owner}/{repo}/rulesets"], + createTagProtection: ["POST /repos/{owner}/{repo}/tags/protection"], + createUsingTemplate: [ + "POST /repos/{template_owner}/{template_repo}/generate" + ], + createWebhook: ["POST /repos/{owner}/{repo}/hooks"], + declineInvitation: [ + "DELETE /user/repository_invitations/{invitation_id}", + {}, + { renamed: ["repos", "declineInvitationForAuthenticatedUser"] } + ], + declineInvitationForAuthenticatedUser: [ + "DELETE /user/repository_invitations/{invitation_id}" + ], + delete: ["DELETE /repos/{owner}/{repo}"], + deleteAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions" + ], + deleteAdminBranchProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins" + ], + deleteAnEnvironment: [ + "DELETE /repos/{owner}/{repo}/environments/{environment_name}" + ], + deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"], + deleteBranchProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection" + ], + deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"], + deleteCommitSignatureProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures" + ], + deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"], + deleteDeployment: [ + "DELETE /repos/{owner}/{repo}/deployments/{deployment_id}" + ], + deleteDeploymentBranchPolicy: [ + "DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}" + ], + deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"], + deleteInvitation: [ + "DELETE /repos/{owner}/{repo}/invitations/{invitation_id}" + ], + deleteOrgRuleset: ["DELETE /orgs/{org}/rulesets/{ruleset_id}"], + deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"], + deletePullRequestReviewProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews" + ], + deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], + deleteReleaseAsset: [ + "DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}" + ], + deleteRepoRuleset: ["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + deleteTagProtection: [ + "DELETE /repos/{owner}/{repo}/tags/protection/{tag_protection_id}" + ], + deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], + disableAutomatedSecurityFixes: [ + "DELETE /repos/{owner}/{repo}/automated-security-fixes" + ], + disableDeploymentProtectionRule: [ + "DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}" + ], + disablePrivateVulnerabilityReporting: [ + "DELETE /repos/{owner}/{repo}/private-vulnerability-reporting" + ], + disableVulnerabilityAlerts: [ + "DELETE /repos/{owner}/{repo}/vulnerability-alerts" + ], + downloadArchive: [ + "GET /repos/{owner}/{repo}/zipball/{ref}", + {}, + { renamed: ["repos", "downloadZipballArchive"] } + ], + downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"], + downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"], + enableAutomatedSecurityFixes: [ + "PUT /repos/{owner}/{repo}/automated-security-fixes" + ], + enablePrivateVulnerabilityReporting: [ + "PUT /repos/{owner}/{repo}/private-vulnerability-reporting" + ], + enableVulnerabilityAlerts: [ + "PUT /repos/{owner}/{repo}/vulnerability-alerts" + ], + generateReleaseNotes: [ + "POST /repos/{owner}/{repo}/releases/generate-notes" + ], + get: ["GET /repos/{owner}/{repo}"], + getAccessRestrictions: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions" + ], + getAdminBranchProtection: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins" + ], + getAllDeploymentProtectionRules: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules" + ], + getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"], + getAllStatusCheckContexts: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts" + ], + getAllTopics: ["GET /repos/{owner}/{repo}/topics"], + getAppsWithAccessToProtectedBranch: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps" + ], + getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"], + getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"], + getBranchProtection: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection" + ], + getBranchRules: ["GET /repos/{owner}/{repo}/rules/branches/{branch}"], + getClones: ["GET /repos/{owner}/{repo}/traffic/clones"], + getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"], + getCollaboratorPermissionLevel: [ + "GET /repos/{owner}/{repo}/collaborators/{username}/permission" + ], + getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"], + getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"], + getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"], + getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"], + getCommitSignatureProtection: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures" + ], + getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"], + getContent: ["GET /repos/{owner}/{repo}/contents/{path}"], + getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"], + getCustomDeploymentProtectionRule: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}" + ], + getCustomPropertiesValues: ["GET /repos/{owner}/{repo}/properties/values"], + getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"], + getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"], + getDeploymentBranchPolicy: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}" + ], + getDeploymentStatus: [ + "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}" + ], + getEnvironment: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}" + ], + getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"], + getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"], + getOrgRuleSuite: ["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"], + getOrgRuleSuites: ["GET /orgs/{org}/rulesets/rule-suites"], + getOrgRuleset: ["GET /orgs/{org}/rulesets/{ruleset_id}"], + getOrgRulesets: ["GET /orgs/{org}/rulesets"], + getPages: ["GET /repos/{owner}/{repo}/pages"], + getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"], + getPagesDeployment: [ + "GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_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}"], + getRepoRuleSuite: [ + "GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}" + ], + getRepoRuleSuites: ["GET /repos/{owner}/{repo}/rulesets/rule-suites"], + getRepoRuleset: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + getRepoRulesets: ["GET /repos/{owner}/{repo}/rulesets"], + 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}" + ], + listActivities: ["GET /repos/{owner}/{repo}/activity"], + listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"], + listBranches: ["GET /repos/{owner}/{repo}/branches"], + listBranchesForHeadCommit: [ + "GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head" + ], + listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"], + listCommentsForCommit: [ + "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments" + ], + listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"], + listCommitStatusesForRef: [ + "GET /repos/{owner}/{repo}/commits/{ref}/statuses" + ], + listCommits: ["GET /repos/{owner}/{repo}/commits"], + listContributors: ["GET /repos/{owner}/{repo}/contributors"], + listCustomDeploymentRuleIntegrations: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps" + ], + listDeployKeys: ["GET /repos/{owner}/{repo}/keys"], + listDeploymentBranchPolicies: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies" + ], + listDeploymentStatuses: [ + "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses" + ], + listDeployments: ["GET /repos/{owner}/{repo}/deployments"], + listForAuthenticatedUser: ["GET /user/repos"], + listForOrg: ["GET /orgs/{org}/repos"], + listForUser: ["GET /users/{username}/repos"], + listForks: ["GET /repos/{owner}/{repo}/forks"], + listInvitations: ["GET /repos/{owner}/{repo}/invitations"], + listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"], + listLanguages: ["GET /repos/{owner}/{repo}/languages"], + listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"], + listPublic: ["GET /repositories"], + listPullRequestsAssociatedWithCommit: [ + "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls" + ], + listReleaseAssets: [ + "GET /repos/{owner}/{repo}/releases/{release_id}/assets" + ], + listReleases: ["GET /repos/{owner}/{repo}/releases"], + listTagProtection: ["GET /repos/{owner}/{repo}/tags/protection"], + listTags: ["GET /repos/{owner}/{repo}/tags"], + listTeams: ["GET /repos/{owner}/{repo}/teams"], + listWebhookDeliveries: [ + "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries" + ], + listWebhooks: ["GET /repos/{owner}/{repo}/hooks"], + merge: ["POST /repos/{owner}/{repo}/merges"], + mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"], + pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: [ + "POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts" + ], + removeAppAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + removeCollaborator: [ + "DELETE /repos/{owner}/{repo}/collaborators/{username}" + ], + removeStatusCheckContexts: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + removeStatusCheckProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks" + ], + removeTeamAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + removeUserAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"], + replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"], + requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"], + setAdminBranchProtection: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins" + ], + setAppAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + setStatusCheckContexts: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + setTeamAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + setUserAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"], + transfer: ["POST /repos/{owner}/{repo}/transfer"], + update: ["PATCH /repos/{owner}/{repo}"], + updateBranchProtection: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection" + ], + updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"], + updateDeploymentBranchPolicy: [ + "PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}" + ], + updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"], + updateInvitation: [ + "PATCH /repos/{owner}/{repo}/invitations/{invitation_id}" + ], + updateOrgRuleset: ["PUT /orgs/{org}/rulesets/{ruleset_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}" + ], + updateRepoRuleset: ["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + updateStatusCheckPotection: [ + "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", + {}, + { renamed: ["repos", "updateStatusCheckProtection"] } + ], + updateStatusCheckProtection: [ + "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks" + ], + updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"], + updateWebhookConfigForRepo: [ + "PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config" + ], + uploadReleaseAsset: [ + "POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", + { baseUrl: "https://uploads.github.com" } + ] + }, + search: { + code: ["GET /search/code"], + commits: ["GET /search/commits"], + issuesAndPullRequests: ["GET /search/issues"], + labels: ["GET /search/labels"], + repos: ["GET /search/repositories"], + topics: ["GET /search/topics"], + users: ["GET /search/users"] + }, + secretScanning: { + getAlert: [ + "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}" + ], + listAlertsForEnterprise: [ + "GET /enterprises/{enterprise}/secret-scanning/alerts" + ], + listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"], + listLocationsForAlert: [ + "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations" + ], + updateAlert: [ + "PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}" + ] + }, + securityAdvisories: { + createFork: [ + "POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks" + ], + createPrivateVulnerabilityReport: [ + "POST /repos/{owner}/{repo}/security-advisories/reports" + ], + createRepositoryAdvisory: [ + "POST /repos/{owner}/{repo}/security-advisories" + ], + createRepositoryAdvisoryCveRequest: [ + "POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve" + ], + getGlobalAdvisory: ["GET /advisories/{ghsa_id}"], + getRepositoryAdvisory: [ + "GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}" + ], + listGlobalAdvisories: ["GET /advisories"], + listOrgRepositoryAdvisories: ["GET /orgs/{org}/security-advisories"], + listRepositoryAdvisories: ["GET /repos/{owner}/{repo}/security-advisories"], + updateRepositoryAdvisory: [ + "PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}" + ] + }, + teams: { + addOrUpdateMembershipForUserInOrg: [ + "PUT /orgs/{org}/teams/{team_slug}/memberships/{username}" + ], + addOrUpdateProjectPermissionsInOrg: [ + "PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}" + ], + addOrUpdateRepoPermissionsInOrg: [ + "PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}" + ], + checkPermissionsForProjectInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/projects/{project_id}" + ], + checkPermissionsForRepoInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}" + ], + create: ["POST /orgs/{org}/teams"], + createDiscussionCommentInOrg: [ + "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments" + ], + createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], + deleteDiscussionCommentInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}" + ], + deleteDiscussionInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}" + ], + deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], + getByName: ["GET /orgs/{org}/teams/{team_slug}"], + getDiscussionCommentInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}" + ], + getDiscussionInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}" + ], + getMembershipForUserInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/memberships/{username}" + ], + list: ["GET /orgs/{org}/teams"], + listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], + listDiscussionCommentsInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments" + ], + listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], + listForAuthenticatedUser: ["GET /user/teams"], + listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], + listPendingInvitationsInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/invitations" + ], + listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects"], + listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], + removeMembershipForUserInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}" + ], + removeProjectInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}" + ], + removeRepoInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}" + ], + updateDiscussionCommentInOrg: [ + "PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}" + ], + updateDiscussionInOrg: [ + "PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}" + ], + updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"] + }, + users: { + addEmailForAuthenticated: [ + "POST /user/emails", + {}, + { renamed: ["users", "addEmailForAuthenticatedUser"] } + ], + addEmailForAuthenticatedUser: ["POST /user/emails"], + addSocialAccountForAuthenticatedUser: ["POST /user/social_accounts"], + block: ["PUT /user/blocks/{username}"], + checkBlocked: ["GET /user/blocks/{username}"], + checkFollowingForUser: ["GET /users/{username}/following/{target_user}"], + checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"], + createGpgKeyForAuthenticated: [ + "POST /user/gpg_keys", + {}, + { renamed: ["users", "createGpgKeyForAuthenticatedUser"] } + ], + createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"], + createPublicSshKeyForAuthenticated: [ + "POST /user/keys", + {}, + { renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] } + ], + createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"], + createSshSigningKeyForAuthenticatedUser: ["POST /user/ssh_signing_keys"], + deleteEmailForAuthenticated: [ + "DELETE /user/emails", + {}, + { renamed: ["users", "deleteEmailForAuthenticatedUser"] } + ], + deleteEmailForAuthenticatedUser: ["DELETE /user/emails"], + deleteGpgKeyForAuthenticated: [ + "DELETE /user/gpg_keys/{gpg_key_id}", + {}, + { renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] } + ], + deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"], + deletePublicSshKeyForAuthenticated: [ + "DELETE /user/keys/{key_id}", + {}, + { renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] } + ], + deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"], + deleteSocialAccountForAuthenticatedUser: ["DELETE /user/social_accounts"], + deleteSshSigningKeyForAuthenticatedUser: [ + "DELETE /user/ssh_signing_keys/{ssh_signing_key_id}" + ], + follow: ["PUT /user/following/{username}"], + getAuthenticated: ["GET /user"], + getByUsername: ["GET /users/{username}"], + getContextForUser: ["GET /users/{username}/hovercard"], + getGpgKeyForAuthenticated: [ + "GET /user/gpg_keys/{gpg_key_id}", + {}, + { renamed: ["users", "getGpgKeyForAuthenticatedUser"] } + ], + getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"], + getPublicSshKeyForAuthenticated: [ + "GET /user/keys/{key_id}", + {}, + { renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] } + ], + getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"], + getSshSigningKeyForAuthenticatedUser: [ + "GET /user/ssh_signing_keys/{ssh_signing_key_id}" + ], + list: ["GET /users"], + listBlockedByAuthenticated: [ + "GET /user/blocks", + {}, + { renamed: ["users", "listBlockedByAuthenticatedUser"] } + ], + listBlockedByAuthenticatedUser: ["GET /user/blocks"], + listEmailsForAuthenticated: [ + "GET /user/emails", + {}, + { renamed: ["users", "listEmailsForAuthenticatedUser"] } + ], + listEmailsForAuthenticatedUser: ["GET /user/emails"], + listFollowedByAuthenticated: [ + "GET /user/following", + {}, + { renamed: ["users", "listFollowedByAuthenticatedUser"] } + ], + listFollowedByAuthenticatedUser: ["GET /user/following"], + listFollowersForAuthenticatedUser: ["GET /user/followers"], + listFollowersForUser: ["GET /users/{username}/followers"], + listFollowingForUser: ["GET /users/{username}/following"], + listGpgKeysForAuthenticated: [ + "GET /user/gpg_keys", + {}, + { renamed: ["users", "listGpgKeysForAuthenticatedUser"] } + ], + listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"], + listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], + listPublicEmailsForAuthenticated: [ + "GET /user/public_emails", + {}, + { renamed: ["users", "listPublicEmailsForAuthenticatedUser"] } + ], + listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"], + listPublicKeysForUser: ["GET /users/{username}/keys"], + listPublicSshKeysForAuthenticated: [ + "GET /user/keys", + {}, + { renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] } + ], + listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"], + listSocialAccountsForAuthenticatedUser: ["GET /user/social_accounts"], + listSocialAccountsForUser: ["GET /users/{username}/social_accounts"], + listSshSigningKeysForAuthenticatedUser: ["GET /user/ssh_signing_keys"], + listSshSigningKeysForUser: ["GET /users/{username}/ssh_signing_keys"], + setPrimaryEmailVisibilityForAuthenticated: [ + "PATCH /user/email/visibility", + {}, + { renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] } + ], + setPrimaryEmailVisibilityForAuthenticatedUser: [ + "PATCH /user/email/visibility" + ], + unblock: ["DELETE /user/blocks/{username}"], + unfollow: ["DELETE /user/following/{username}"], + updateAuthenticated: ["PATCH /user"] + } + }; + var endpoints_default = Endpoints; + var endpointMethodsMap = /* @__PURE__ */ new Map(); + for (const [scope, endpoints] of Object.entries(endpoints_default)) { + for (const [methodName, endpoint] of Object.entries(endpoints)) { + const [route, defaults3, decorations] = endpoint; + const [method, url] = route.split(/ /); + const endpointDefaults = Object.assign( + { + method, + url + }, + defaults3 + ); + if (!endpointMethodsMap.has(scope)) { + endpointMethodsMap.set(scope, /* @__PURE__ */ new Map()); + } + endpointMethodsMap.get(scope).set(methodName, { + scope, + methodName, + endpointDefaults, + decorations + }); + } + } + var handler = { + has({ scope }, methodName) { + return endpointMethodsMap.get(scope).has(methodName); + }, + getOwnPropertyDescriptor(target, methodName) { + return { + value: this.get(target, methodName), + // ensures method is in the cache + configurable: true, + writable: true, + enumerable: true + }; + }, + defineProperty(target, methodName, descriptor) { + Object.defineProperty(target.cache, methodName, descriptor); + return true; + }, + deleteProperty(target, methodName) { + delete target.cache[methodName]; + return true; + }, + ownKeys({ scope }) { + return [...endpointMethodsMap.get(scope).keys()]; + }, + set(target, methodName, value) { + return target.cache[methodName] = value; + }, + get({ octokit, scope, cache }, methodName) { + if (cache[methodName]) { + return cache[methodName]; + } + const method = endpointMethodsMap.get(scope).get(methodName); + if (!method) { + return void 0; + } + const { endpointDefaults, decorations } = method; + if (decorations) { + cache[methodName] = decorate( + octokit, + scope, + methodName, + endpointDefaults, + decorations + ); + } else { + cache[methodName] = octokit.request.defaults(endpointDefaults); + } + return cache[methodName]; + } + }; + function endpointsToMethods(octokit) { + const newMethods = {}; + for (const scope of endpointMethodsMap.keys()) { + newMethods[scope] = new Proxy({ octokit, scope, cache: {} }, handler); + } + return newMethods; + } + function decorate(octokit, scope, methodName, defaults3, decorations) { + const requestWithDefaults = octokit.request.defaults(defaults3); + function withDecorations(...args) { + let options = requestWithDefaults.endpoint.merge(...args); + if (decorations.mapToData) { + options = Object.assign({}, options, { + data: options[decorations.mapToData], + [decorations.mapToData]: void 0 + }); + 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) { + const options2 = requestWithDefaults.endpoint.merge(...args); + for (const [name, alias] of Object.entries( + decorations.renamedParameters + )) { + if (name in options2) { + octokit.log.warn( + `"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead` + ); + if (!(alias in options2)) { + options2[alias] = options2[name]; + } + delete options2[name]; + } + } + return requestWithDefaults(options2); + } + return requestWithDefaults(...args); + } + return Object.assign(withDecorations, requestWithDefaults); + } + function restEndpointMethods(octokit) { + const api = endpointsToMethods(octokit); + return { + rest: api + }; + } + restEndpointMethods.VERSION = VERSION3; + function legacyRestEndpointMethods(octokit) { + const api = endpointsToMethods(octokit); + return { + ...api, + rest: api + }; + } + legacyRestEndpointMethods.VERSION = VERSION3; + } +}); + +// node_modules/@octokit/plugin-paginate-rest/dist-node/index.js +var require_dist_node10 = __commonJS({ + "node_modules/@octokit/plugin-paginate-rest/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + composePaginateRest: () => composePaginateRest, + isPaginatingEndpoint: () => isPaginatingEndpoint, + paginateRest: () => paginateRest, + paginatingEndpoints: () => paginatingEndpoints + }); + module2.exports = __toCommonJS(dist_src_exports); + var VERSION3 = "9.2.2"; + function normalizePaginatedListResponse(response) { + if (!response.data) { + return { + ...response, + data: [] + }; + } + const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data); + if (!responseNeedsNormalization) + return response; + 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); + 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 = void 0; + } + return gather( + octokit, + [], + iterator(octokit, route, parameters)[Symbol.asyncIterator](), + mapFn + ); + } + function gather(octokit, results, iterator2, mapFn) { + return iterator2.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, iterator2, mapFn); + }); + } + var composePaginateRest = Object.assign(paginate, { + iterator + }); + var paginatingEndpoints = [ + "GET /advisories", + "GET /app/hook/deliveries", + "GET /app/installation-requests", + "GET /app/installations", + "GET /assignments/{assignment_id}/accepted_assignments", + "GET /classrooms", + "GET /classrooms/{classroom_id}/assignments", + "GET /enterprises/{enterprise}/dependabot/alerts", + "GET /enterprises/{enterprise}/secret-scanning/alerts", + "GET /events", + "GET /gists", + "GET /gists/public", + "GET /gists/starred", + "GET /gists/{gist_id}/comments", + "GET /gists/{gist_id}/commits", + "GET /gists/{gist_id}/forks", + "GET /installation/repositories", + "GET /issues", + "GET /licenses", + "GET /marketplace_listing/plans", + "GET /marketplace_listing/plans/{plan_id}/accounts", + "GET /marketplace_listing/stubbed/plans", + "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", + "GET /networks/{owner}/{repo}/events", + "GET /notifications", + "GET /organizations", + "GET /orgs/{org}/actions/cache/usage-by-repository", + "GET /orgs/{org}/actions/permissions/repositories", + "GET /orgs/{org}/actions/runners", + "GET /orgs/{org}/actions/secrets", + "GET /orgs/{org}/actions/secrets/{secret_name}/repositories", + "GET /orgs/{org}/actions/variables", + "GET /orgs/{org}/actions/variables/{name}/repositories", + "GET /orgs/{org}/blocks", + "GET /orgs/{org}/code-scanning/alerts", + "GET /orgs/{org}/codespaces", + "GET /orgs/{org}/codespaces/secrets", + "GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories", + "GET /orgs/{org}/copilot/billing/seats", + "GET /orgs/{org}/dependabot/alerts", + "GET /orgs/{org}/dependabot/secrets", + "GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories", + "GET /orgs/{org}/events", + "GET /orgs/{org}/failed_invitations", + "GET /orgs/{org}/hooks", + "GET /orgs/{org}/hooks/{hook_id}/deliveries", + "GET /orgs/{org}/installations", + "GET /orgs/{org}/invitations", + "GET /orgs/{org}/invitations/{invitation_id}/teams", + "GET /orgs/{org}/issues", + "GET /orgs/{org}/members", + "GET /orgs/{org}/members/{username}/codespaces", + "GET /orgs/{org}/migrations", + "GET /orgs/{org}/migrations/{migration_id}/repositories", + "GET /orgs/{org}/organization-roles/{role_id}/teams", + "GET /orgs/{org}/organization-roles/{role_id}/users", + "GET /orgs/{org}/outside_collaborators", + "GET /orgs/{org}/packages", + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions", + "GET /orgs/{org}/personal-access-token-requests", + "GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories", + "GET /orgs/{org}/personal-access-tokens", + "GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories", + "GET /orgs/{org}/projects", + "GET /orgs/{org}/properties/values", + "GET /orgs/{org}/public_members", + "GET /orgs/{org}/repos", + "GET /orgs/{org}/rulesets", + "GET /orgs/{org}/rulesets/rule-suites", + "GET /orgs/{org}/secret-scanning/alerts", + "GET /orgs/{org}/security-advisories", + "GET /orgs/{org}/teams", + "GET /orgs/{org}/teams/{team_slug}/discussions", + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", + "GET /orgs/{org}/teams/{team_slug}/invitations", + "GET /orgs/{org}/teams/{team_slug}/members", + "GET /orgs/{org}/teams/{team_slug}/projects", + "GET /orgs/{org}/teams/{team_slug}/repos", + "GET /orgs/{org}/teams/{team_slug}/teams", + "GET /projects/columns/{column_id}/cards", + "GET /projects/{project_id}/collaborators", + "GET /projects/{project_id}/columns", + "GET /repos/{owner}/{repo}/actions/artifacts", + "GET /repos/{owner}/{repo}/actions/caches", + "GET /repos/{owner}/{repo}/actions/organization-secrets", + "GET /repos/{owner}/{repo}/actions/organization-variables", + "GET /repos/{owner}/{repo}/actions/runners", + "GET /repos/{owner}/{repo}/actions/runs", + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts", + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs", + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs", + "GET /repos/{owner}/{repo}/actions/secrets", + "GET /repos/{owner}/{repo}/actions/variables", + "GET /repos/{owner}/{repo}/actions/workflows", + "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs", + "GET /repos/{owner}/{repo}/activity", + "GET /repos/{owner}/{repo}/assignees", + "GET /repos/{owner}/{repo}/branches", + "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", + "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", + "GET /repos/{owner}/{repo}/code-scanning/alerts", + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", + "GET /repos/{owner}/{repo}/code-scanning/analyses", + "GET /repos/{owner}/{repo}/codespaces", + "GET /repos/{owner}/{repo}/codespaces/devcontainers", + "GET /repos/{owner}/{repo}/codespaces/secrets", + "GET /repos/{owner}/{repo}/collaborators", + "GET /repos/{owner}/{repo}/comments", + "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", + "GET /repos/{owner}/{repo}/commits", + "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments", + "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", + "GET /repos/{owner}/{repo}/commits/{ref}/check-runs", + "GET /repos/{owner}/{repo}/commits/{ref}/check-suites", + "GET /repos/{owner}/{repo}/commits/{ref}/status", + "GET /repos/{owner}/{repo}/commits/{ref}/statuses", + "GET /repos/{owner}/{repo}/contributors", + "GET /repos/{owner}/{repo}/dependabot/alerts", + "GET /repos/{owner}/{repo}/dependabot/secrets", + "GET /repos/{owner}/{repo}/deployments", + "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses", + "GET /repos/{owner}/{repo}/environments", + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies", + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps", + "GET /repos/{owner}/{repo}/events", + "GET /repos/{owner}/{repo}/forks", + "GET /repos/{owner}/{repo}/hooks", + "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries", + "GET /repos/{owner}/{repo}/invitations", + "GET /repos/{owner}/{repo}/issues", + "GET /repos/{owner}/{repo}/issues/comments", + "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", + "GET /repos/{owner}/{repo}/issues/events", + "GET /repos/{owner}/{repo}/issues/{issue_number}/comments", + "GET /repos/{owner}/{repo}/issues/{issue_number}/events", + "GET /repos/{owner}/{repo}/issues/{issue_number}/labels", + "GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", + "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", + "GET /repos/{owner}/{repo}/keys", + "GET /repos/{owner}/{repo}/labels", + "GET /repos/{owner}/{repo}/milestones", + "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels", + "GET /repos/{owner}/{repo}/notifications", + "GET /repos/{owner}/{repo}/pages/builds", + "GET /repos/{owner}/{repo}/projects", + "GET /repos/{owner}/{repo}/pulls", + "GET /repos/{owner}/{repo}/pulls/comments", + "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/files", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", + "GET /repos/{owner}/{repo}/releases", + "GET /repos/{owner}/{repo}/releases/{release_id}/assets", + "GET /repos/{owner}/{repo}/releases/{release_id}/reactions", + "GET /repos/{owner}/{repo}/rules/branches/{branch}", + "GET /repos/{owner}/{repo}/rulesets", + "GET /repos/{owner}/{repo}/rulesets/rule-suites", + "GET /repos/{owner}/{repo}/secret-scanning/alerts", + "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations", + "GET /repos/{owner}/{repo}/security-advisories", + "GET /repos/{owner}/{repo}/stargazers", + "GET /repos/{owner}/{repo}/subscribers", + "GET /repos/{owner}/{repo}/tags", + "GET /repos/{owner}/{repo}/teams", + "GET /repos/{owner}/{repo}/topics", + "GET /repositories", + "GET /repositories/{repository_id}/environments/{environment_name}/secrets", + "GET /repositories/{repository_id}/environments/{environment_name}/variables", + "GET /search/code", + "GET /search/commits", + "GET /search/issues", + "GET /search/labels", + "GET /search/repositories", + "GET /search/topics", + "GET /search/users", + "GET /teams/{team_id}/discussions", + "GET /teams/{team_id}/discussions/{discussion_number}/comments", + "GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions", + "GET /teams/{team_id}/discussions/{discussion_number}/reactions", + "GET /teams/{team_id}/invitations", + "GET /teams/{team_id}/members", + "GET /teams/{team_id}/projects", + "GET /teams/{team_id}/repos", + "GET /teams/{team_id}/teams", + "GET /user/blocks", + "GET /user/codespaces", + "GET /user/codespaces/secrets", + "GET /user/emails", + "GET /user/followers", + "GET /user/following", + "GET /user/gpg_keys", + "GET /user/installations", + "GET /user/installations/{installation_id}/repositories", + "GET /user/issues", + "GET /user/keys", + "GET /user/marketplace_purchases", + "GET /user/marketplace_purchases/stubbed", + "GET /user/memberships/orgs", + "GET /user/migrations", + "GET /user/migrations/{migration_id}/repositories", + "GET /user/orgs", + "GET /user/packages", + "GET /user/packages/{package_type}/{package_name}/versions", + "GET /user/public_emails", + "GET /user/repos", + "GET /user/repository_invitations", + "GET /user/social_accounts", + "GET /user/ssh_signing_keys", + "GET /user/starred", + "GET /user/subscriptions", + "GET /user/teams", + "GET /users", + "GET /users/{username}/events", + "GET /users/{username}/events/orgs/{org}", + "GET /users/{username}/events/public", + "GET /users/{username}/followers", + "GET /users/{username}/following", + "GET /users/{username}/gists", + "GET /users/{username}/gpg_keys", + "GET /users/{username}/keys", + "GET /users/{username}/orgs", + "GET /users/{username}/packages", + "GET /users/{username}/projects", + "GET /users/{username}/received_events", + "GET /users/{username}/received_events/public", + "GET /users/{username}/repos", + "GET /users/{username}/social_accounts", + "GET /users/{username}/ssh_signing_keys", + "GET /users/{username}/starred", + "GET /users/{username}/subscriptions" + ]; + function isPaginatingEndpoint(arg) { + if (typeof arg === "string") { + return paginatingEndpoints.includes(arg); + } else { + return false; + } + } + function paginateRest(octokit) { + return { + paginate: Object.assign(paginate.bind(null, octokit), { + iterator: iterator.bind(null, octokit) + }) + }; + } + paginateRest.VERSION = VERSION3; + } +}); + +// node_modules/@actions/github/lib/utils.js +var require_utils4 = __commonJS({ + "node_modules/@actions/github/lib/utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getOctokitOptions = exports2.GitHub = exports2.defaults = exports2.context = void 0; + var Context = __importStar(require_context()); + var Utils = __importStar(require_utils3()); + var core_1 = require_dist_node8(); + var plugin_rest_endpoint_methods_1 = require_dist_node9(); + var plugin_paginate_rest_1 = require_dist_node10(); + exports2.context = new Context.Context(); + var baseUrl = Utils.getApiBaseUrl(); + exports2.defaults = { + baseUrl, + request: { + agent: Utils.getProxyAgent(baseUrl), + fetch: Utils.getProxyFetch(baseUrl) + } + }; + exports2.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(exports2.defaults); + function getOctokitOptions(token, options) { + const opts = Object.assign({}, options || {}); + const auth = Utils.getAuthString(token, opts); + if (auth) { + opts.auth = auth; + } + return opts; + } + exports2.getOctokitOptions = getOctokitOptions; + } +}); + +// node_modules/@actions/github/lib/github.js +var require_github = __commonJS({ + "node_modules/@actions/github/lib/github.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getOctokit = exports2.context = void 0; + var Context = __importStar(require_context()); + var utils_1 = require_utils4(); + exports2.context = new Context.Context(); + function getOctokit(token, options, ...additionalPlugins) { + const GitHubWithPlugins = utils_1.GitHub.plugin(...additionalPlugins); + return new GitHubWithPlugins((0, utils_1.getOctokitOptions)(token, options)); + } + exports2.getOctokit = getOctokit; + } +}); + +// node_modules/libsodium/dist/modules/libsodium.js +var require_libsodium = __commonJS({ + "node_modules/libsodium/dist/modules/libsodium.js"(exports2, module2) { + !function(A) { + function I(A2) { + "use strict"; + var I2; + void 0 === (I2 = A2) && (I2 = {}); + var g = I2; + "object" != typeof g.sodium && ("object" == typeof global ? g = global : "object" == typeof window && (g = window)); + var C = I2; + return I2.ready = new Promise(function(A3, I3) { + (B = C).onAbort = I3, B.print = function(A4) { + }, B.printErr = function(A4) { + }, B.onRuntimeInitialized = function() { + try { + B._crypto_secretbox_keybytes(), A3(); + } catch (A4) { + I3(A4); + } + }, B.useBackupModule = function() { + return new Promise(function(A4, I4) { + (B2 = {}).onAbort = I4, B2.onRuntimeInitialized = function() { + Object.keys(C).forEach(function(A5) { + "getRandomValue" !== A5 && delete C[A5]; + }), Object.keys(B2).forEach(function(A5) { + C[A5] = B2[A5]; + }), A4(); + }; + var g3, B2 = void 0 !== B2 ? B2 : {}, Q2 = "object" == typeof window, E2 = "function" == typeof importScripts, i2 = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, o2 = Object.assign({}, B2), c2 = ""; + if (i2) { + var D2 = require("fs"), a2 = require("path"); + c2 = __dirname + "/", g3 = (A5) => (A5 = U2(A5) ? new URL(A5) : a2.normalize(A5), D2.readFileSync(A5)), !B2.thisProgram && process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2), "undefined" != typeof module2 && (module2.exports = B2); + } else (Q2 || E2) && (E2 ? c2 = self.location.href : "undefined" != typeof document && document.currentScript && (c2 = document.currentScript.src), c2 = c2.startsWith("blob:") ? "" : c2.substr(0, c2.replace(/[?#].*/, "").lastIndexOf("/") + 1), E2 && (g3 = (A5) => { + var I5 = new XMLHttpRequest(); + return I5.open("GET", A5, false), I5.responseType = "arraybuffer", I5.send(null), new Uint8Array(I5.response); + })); + B2.print; + var y2, f2 = B2.printErr || void 0; + Object.assign(B2, o2), o2 = null, B2.arguments && B2.arguments, B2.thisProgram && B2.thisProgram, B2.quit && B2.quit, B2.wasmBinary && (y2 = B2.wasmBinary); + var e2, w2 = { Memory: function(A5) { + this.buffer = new ArrayBuffer(65536 * A5.initial); + }, Module: function(A5) { + }, Instance: function(A5, I5) { + this.exports = function(A6) { + for (var I6, g4 = new Uint8Array(123), C2 = 25; C2 >= 0; --C2) g4[48 + C2] = 52 + C2, g4[65 + C2] = C2, g4[97 + C2] = 26 + C2; + function B3(A7, I7, C3) { + for (var B4, Q4, E3 = 0, i3 = I7, o3 = C3.length, c3 = I7 + (3 * o3 >> 2) - ("=" == C3[o3 - 2]) - ("=" == C3[o3 - 1]); E3 < o3; E3 += 4) B4 = g4[C3.charCodeAt(E3 + 1)], Q4 = g4[C3.charCodeAt(E3 + 2)], A7[i3++] = g4[C3.charCodeAt(E3)] << 2 | B4 >> 4, i3 < c3 && (A7[i3++] = B4 << 4 | Q4 >> 2), i3 < c3 && (A7[i3++] = Q4 << 6 | g4[C3.charCodeAt(E3 + 3)]); + } + function Q3() { + throw new Error("abort"); + } + return g4[43] = 62, g4[47] = 63, function(A7) { + var g5 = new ArrayBuffer(16777216), C3 = new Int8Array(g5), E3 = (new Int16Array(g5), new Int32Array(g5)), i3 = new Uint8Array(g5), o3 = (new Uint16Array(g5), new Uint32Array(g5)), c3 = (new Float32Array(g5), new Float64Array(g5), Math.imul), D3 = (Math.fround, Math.abs, Math.clz32), a3 = (Math.min, Math.max, Math.floor, Math.ceil, Math.trunc, Math.sqrt, A7.a), y3 = a3.a, f3 = a3.b, e3 = a3.c, w3 = a3.d, r3 = 103200, t3 = 0; + function h3(A8, I7) { + var g6, B4, Q4, E4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, eA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, SA2 = 0, MA2 = 0, NA2 = 0, KA2 = 0, pA2 = 0, HA2 = 0, GA2 = 0; + fA2 = i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24, wA2 = c4 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, gA2 = i3[I7 + 104 | 0] | i3[I7 + 105 | 0] << 8 | i3[I7 + 106 | 0] << 16 | i3[I7 + 107 | 0] << 24, rA2 = c4 = i3[I7 + 108 | 0] | i3[I7 + 109 | 0] << 8 | i3[I7 + 110 | 0] << 16 | i3[I7 + 111 | 0] << 24, c4 = i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24, j2 = i3[I7 + 64 | 0] | i3[I7 + 65 | 0] << 8 | i3[I7 + 66 | 0] << 16 | i3[I7 + 67 | 0] << 24, BA2 = c4, KA2 = c4 = i3[I7 + 36 | 0] | i3[I7 + 37 | 0] << 8 | i3[I7 + 38 | 0] << 16 | i3[I7 + 39 | 0] << 24, K4 = c4, oA2 = i3[I7 + 120 | 0] | i3[I7 + 121 | 0] << 8 | i3[I7 + 122 | 0] << 16 | i3[I7 + 123 | 0] << 24, nA2 = c4 = i3[I7 + 124 | 0] | i3[I7 + 125 | 0] << 8 | i3[I7 + 126 | 0] << 16 | i3[I7 + 127 | 0] << 24, Q4 = c4 = i3[I7 + 92 | 0] | i3[I7 + 93 | 0] << 8 | i3[I7 + 94 | 0] << 16 | i3[I7 + 95 | 0] << 24, g6 = i3[I7 + 88 | 0] | i3[I7 + 89 | 0] << 8 | i3[I7 + 90 | 0] << 16 | i3[I7 + 91 | 0] << 24, z2 = c4, iA2 = i3[I7 + 80 | 0] | i3[I7 + 81 | 0] << 8 | i3[I7 + 82 | 0] << 16 | i3[I7 + 83 | 0] << 24, hA2 = c4 = i3[I7 + 84 | 0] | i3[I7 + 85 | 0] << 8 | i3[I7 + 86 | 0] << 16 | i3[I7 + 87 | 0] << 24, X2 = c4, QA2 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, c4 = (DA2 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24) + K4 | 0, q4 = (cA2 = i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24) + (aA2 = i3[I7 + 32 | 0] | i3[I7 + 33 | 0] << 8 | i3[I7 + 34 | 0] << 16 | i3[I7 + 35 | 0] << 24) | 0, c4 = (i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24) + (cA2 >>> 0 > q4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (QA2 = (D4 = q4) >>> 0 > (q4 = q4 + QA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, EA2 = eA2 = q4 + fA2 | 0, eA2 = c4 = eA2 >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, q4 = _A(q4 ^ (i3[A8 + 80 | 0] | i3[A8 + 81 | 0] << 8 | i3[A8 + 82 | 0] << 16 | i3[A8 + 83 | 0] << 24) ^ -79577749, QA2 ^ (i3[A8 + 84 | 0] | i3[A8 + 85 | 0] << 8 | i3[A8 + 86 | 0] << 16 | i3[A8 + 87 | 0] << 24) ^ 528734635, 32), SA2 = c4 = t3, c4 = c4 + 1013904242 | 0, QA2 = q4, V2 = c4 = (q4 = q4 - 23791573 | 0) >>> 0 < 4271175723 ? c4 + 1 | 0 : c4, DA2 = _A(q4 ^ cA2, c4 ^ DA2, 40), c4 = (c4 = eA2) + (eA2 = t3) | 0, cA2 = _A(QA2 ^ (h4 = cA2 = DA2 + EA2 | 0), SA2 ^ (k4 = h4 >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = V2 + (u4 = t3) | 0, S4 = c4 = (cA2 = q4 + (n4 = cA2) | 0) >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, cA2 = c4 = _A(DA2 ^ (F4 = cA2), eA2 ^ c4, 1), V2 = q4 = t3, eA2 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, SA2 = c4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, yA2 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, q4 = (DA2 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24) + (QA2 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24) | 0, c4 = (pA2 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24) + (GA2 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24) | 0, c4 = (i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24) + (q4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = SA2 + (EA2 = (D4 = q4) >>> 0 > (q4 = q4 + yA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (yA2 = q4 + eA2 | 0) >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(q4 ^ (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) ^ 725511199, EA2 ^ (i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24) ^ -1694144372, 32), e4 = _A(QA2 ^ (a4 = D4 - 2067093701 | 0), GA2 ^ (L4 = (d4 = q4 = t3) - ((D4 >>> 0 < 2067093701) + 1150833018 | 0) | 0), 40), c4 = (m4 = t3) + c4 | 0, c4 = (U4 = (M4 = q4 = e4 + yA2 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4) + V2 | 0, c4 = (M4 >>> 0 > (q4 = M4 + cA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + X2 | 0, c4 = (QA2 = (y4 = q4) >>> 0 > (q4 = q4 + iA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + z2 | 0, v4 = z2 = q4 + g6 | 0, r4 = c4 = z2 >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, s4 = cA2, sA2 = V2, V2 = q4, EA2 = QA2, cA2 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, q4 = c4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, GA2 = c4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E4 = QA2 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, X2 = c4, c4 = (MA2 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) + (f4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24) | 0, c4 = E4 + ((z2 = i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24) >>> 0 > (y4 = z2 + (QA2 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (yA2 = (X2 = y4 + X2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, kA2 = y4 = X2 + cA2 | 0, y4 = c4 = y4 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, w4 = z2, z2 = _A(X2 ^ (i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) ^ -1377402159, yA2 ^ (i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24) ^ 1359893119, 32), yA2 = c4 = t3, c4 = c4 + 1779033703 | 0, X2 = z2, G4 = c4 = (z2 = z2 - 205731576 | 0) >>> 0 < 4089235720 ? c4 + 1 | 0 : c4, f4 = _A(w4 ^ (N4 = z2), c4 ^ f4, 40), c4 = (P4 = t3) + y4 | 0, w4 = _A(X2 ^ (y4 = z2 = f4 + kA2 | 0), yA2 ^ (_4 = f4 >>> 0 > y4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(w4 ^ V2, (W2 = t3) ^ EA2, 32), T2 = z2 = t3, R4 = c4, B4 = c4 = i3[I7 + 60 | 0] | i3[I7 + 61 | 0] << 8 | i3[I7 + 62 | 0] << 16 | i3[I7 + 63 | 0] << 24, yA2 = kA2 = i3[I7 + 56 | 0] | i3[I7 + 57 | 0] << 8 | i3[I7 + 58 | 0] << 16 | i3[I7 + 59 | 0] << 24, H4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, z2 = (EA2 = i3[I7 + 48 | 0] | i3[I7 + 49 | 0] << 8 | i3[I7 + 50 | 0] << 16 | i3[I7 + 51 | 0] << 24) + (X2 = i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24) | 0, c4 = (NA2 = i3[I7 + 52 | 0] | i3[I7 + 53 | 0] << 8 | i3[I7 + 54 | 0] << 16 | i3[I7 + 55 | 0] << 24) + (b4 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24) | 0, c4 = (i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24) + (z2 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = B4 + (V2 = (p4 = z2) >>> 0 > (z2 = H4 + z2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (H4 = z2 + yA2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, V2 = _A(z2 ^ (i3[A8 + 88 | 0] | i3[A8 + 89 | 0] << 8 | i3[A8 + 90 | 0] << 16 | i3[A8 + 91 | 0] << 24) ^ 327033209, V2 ^ (i3[A8 + 92 | 0] | i3[A8 + 93 | 0] << 8 | i3[A8 + 94 | 0] << 16 | i3[A8 + 95 | 0] << 24) ^ 1541459225, 32), X2 = _A(X2 ^ (yA2 = V2 + 1595750129 | 0), (p4 = b4) ^ (b4 = (J4 = z2 = t3) - ((V2 >>> 0 < 2699217167) + 1521486533 | 0) | 0), 40), c4 = (IA2 = t3) + c4 | 0, z2 = _A((H4 = z2 = X2 + H4 | 0) ^ V2, J4 ^ (p4 = H4 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = b4 + ($2 = t3) | 0, Y4 = c4 = (z2 = yA2 + (b4 = z2) | 0) >>> 0 < yA2 >>> 0 ? c4 + 1 | 0 : c4, c4 = T2 + c4 | 0, O2 = s4 ^ (V2 = R4 + (J4 = z2) | 0), s4 = c4 = V2 >>> 0 < J4 >>> 0 ? c4 + 1 | 0 : c4, yA2 = _A(O2, c4 ^ sA2, 40), c4 = (sA2 = t3) + r4 | 0, z2 = _A(v4 = R4 ^ (r4 = z2 = yA2 + v4 | 0), T2 ^ (R4 = r4 >>> 0 < yA2 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = s4 + (CA2 = t3) | 0, T2 = c4 = (s4 = V2 + (v4 = z2) | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, z2 = (x4 = _A(s4 ^ yA2, sA2 ^ c4, 1)) + (V2 = i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) | 0, c4 = (tA2 = t3) + (sA2 = i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) | 0, FA2 = z2, l3 = z2 >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, Z2 = rA2, z2 = i3[I7 + 96 | 0] | i3[I7 + 97 | 0] << 8 | i3[I7 + 98 | 0] << 16 | i3[I7 + 99 | 0] << 24, yA2 = c4 = i3[I7 + 100 | 0] | i3[I7 + 101 | 0] << 8 | i3[I7 + 102 | 0] << 16 | i3[I7 + 103 | 0] << 24, X2 = (c4 = h4) + (h4 = _A(J4 ^ X2, Y4 ^ IA2, 1)) | 0, c4 = (J4 = t3) + k4 | 0, c4 = (h4 >>> 0 > X2 >>> 0 ? c4 + 1 | 0 : c4) + yA2 | 0, c4 = (k4 = (k4 = X2) >>> 0 > (X2 = z2 + X2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + Z2 | 0, O2 = Y4 = X2 + gA2 | 0, Y4 = c4 = Y4 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, M4 = _A(D4 ^ M4, U4 ^ d4, 48), U4 = c4 = _A(M4 ^ X2, (d4 = t3) ^ k4, 32), c4 = G4 + W2 | 0, c4 = (IA2 = X2 = t3) + (N4 = (X2 = w4 + N4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = c4 = (k4 = X2) >>> 0 > (w4 = k4 + U4 | 0) >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(w4 ^ h4, J4 ^ c4, 40), c4 = (W2 = t3) + Y4 | 0, c4 = (J4 = h4 >>> 0 > (Y4 = X2 = h4 + O2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + l3 | 0, c4 = (D4 = Y4 >>> 0 > (X2 = Y4 + FA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + nA2 | 0, FA2 = l3 = X2 + oA2 | 0, l3 = c4 = l3 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, O2 = X2, Z2 = D4, X2 = i3[I7 + 116 | 0] | i3[I7 + 117 | 0] << 8 | i3[I7 + 118 | 0] << 16 | i3[I7 + 119 | 0] << 24, I7 = i3[I7 + 112 | 0] | i3[I7 + 113 | 0] << 8 | i3[I7 + 114 | 0] << 16 | i3[I7 + 115 | 0] << 24, f4 = _A(f4 ^ k4, N4 ^ P4, 1), c4 = (P4 = t3) + p4 | 0, c4 = ((D4 = f4 + H4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) + X2 | 0, c4 = (k4 = (N4 = D4) >>> 0 > (D4 = I7 + D4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + nA2 | 0, HA2 = N4 = D4 + oA2 | 0, N4 = c4 = N4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ n4, k4 ^ u4, 32), AA2 = D4 = t3, n4 = c4, k4 = D4, c4 = d4 + L4 | 0, M4 = D4 = a4 + M4 | 0, H4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + k4 | 0, p4 = D4 = D4 + n4 | 0, u4 = c4 = M4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, k4 = _A(D4 ^ f4, P4 ^ c4, 40), c4 = (P4 = t3) + N4 | 0, n4 = _A((D4 = k4 + HA2 | 0) ^ n4, AA2 ^ (a4 = D4 >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(n4 ^ O2, (HA2 = t3) ^ Z2, 32), AA2 = f4 = t3, N4 = c4, O2 = f4, e4 = _A(e4 ^ M4, H4 ^ m4, 1), c4 = _4 + (M4 = t3) | 0, c4 = ((f4 = y4) >>> 0 > (y4 = y4 + e4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + BA2 | 0, c4 = (y4 = (f4 = y4 + j2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + sA2 | 0, Z2 = _4 = f4 + V2 | 0, _4 = c4 = _4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, H4 = e4, f4 = _A(f4 ^ b4, y4 ^ $2, 32), c4 = (b4 = t3) + S4 | 0, F4 = _A(H4 ^ (y4 = e4 = f4 + F4 | 0), (S4 = f4 >>> 0 > y4 >>> 0 ? c4 + 1 | 0 : c4) ^ M4, 40), c4 = ($2 = t3) + _4 | 0, M4 = e4 = F4 + Z2 | 0, e4 = _A(f4 ^ e4, b4 ^ (_4 = e4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = S4 + (o4 = t3) | 0, S4 = e4, b4 = c4 = (e4 = y4 + e4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + O2 | 0, c4 = (H4 = e4) >>> 0 > (e4 = e4 + N4 | 0) >>> 0 ? c4 + 1 | 0 : c4, O2 = e4, e4 ^= x4, x4 = c4, f4 = _A(e4, tA2 ^ c4, 40), c4 = (tA2 = t3) + l3 | 0, l3 = e4 = f4 + FA2 | 0, c4 = Q4 + (Z2 = f4 >>> 0 > e4 >>> 0 ? c4 + 1 | 0 : c4) | 0, FA2 = e4 = e4 + g6 | 0, d4 = c4 = e4 >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4, e4 = D4, L4 = gA2, m4 = rA2, D4 = _A(U4 ^ Y4, J4 ^ IA2, 48), c4 = G4 + (IA2 = t3) | 0, U4 = D4, G4 = c4 = (y4 = w4 + D4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(y4 ^ h4, W2 ^ c4, 1), c4 = (w4 = t3) + m4 | 0, c4 = ((h4 = D4 + L4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = NA2 + (e4 = (a4 = e4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) | 0, Y4 = h4 = a4 + EA2 | 0, h4 = c4 = h4 >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ S4, e4 ^ o4, 32), c4 = T2 + (J4 = t3) | 0, S4 = a4, s4 = c4 = (a4 = s4 + a4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(D4 ^ a4, c4 ^ w4, 40), c4 = (c4 = h4) + (h4 = t3) | 0, w4 = D4 = e4 + Y4 | 0, D4 = _A(D4 ^ S4, J4 ^ (Y4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = s4 + (W2 = t3) | 0, J4 = D4, T2 = c4 = (s4 = a4 + D4 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ s4, h4 ^ c4, 1), c4 = (h4 = t3) + d4 | 0, c4 = B4 + (e4 = (a4 = D4 + FA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, FA2 = S4 = a4 + kA2 | 0, S4 = c4 = S4 >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4, d4 = D4, L4 = h4, c4 = u4 + HA2 | 0, c4 = (D4 = n4 + p4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, n4 = D4, p4 = c4, c4 = _A(D4 ^ k4, P4 ^ c4, 1), k4 = h4 = t3, D4 = c4, c4 = _4 + X2 | 0, c4 = ((M4 = I7 + M4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) + h4 | 0, c4 = hA2 + (M4 = (h4 = D4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4) | 0, u4 = _4 = h4 + iA2 | 0, _4 = c4 = _4 >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ v4, M4 ^ CA2, 32), c4 = G4 + (v4 = t3) | 0, M4 = h4, G4 = c4 = (G4 = y4) >>> 0 > (y4 = y4 + h4 | 0) >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(D4 ^ y4, c4 ^ k4, 40), c4 = (P4 = t3) + _4 | 0, k4 = D4 = h4 + u4 | 0, D4 = _A(_4 = D4 ^ M4, v4 ^ (M4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = G4 + (CA2 = t3) | 0, G4 = D4, _4 = D4 = y4 + D4 | 0, v4 = c4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, u4 = a4, m4 = e4, D4 = _A(F4 ^ H4, b4 ^ $2, 1), c4 = (y4 = t3) + K4 | 0, c4 = R4 + ((a4 = D4 + aA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = BA2 + (e4 = (a4 = a4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) | 0, R4 = r4 = a4 + j2 | 0, r4 = c4 = r4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, F4 = D4, D4 = (a4 = _A(a4 ^ U4, e4 ^ IA2, 32)) + n4 | 0, c4 = (n4 = t3) + p4 | 0, e4 = D4, y4 = _A(D4 ^ F4, (U4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ y4, 40), c4 = (IA2 = t3) + r4 | 0, r4 = D4 = y4 + R4 | 0, H4 = _A(D4 ^ a4, n4 ^ (R4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4), 48), a4 = _A(H4 ^ u4, (c4 = m4) ^ (m4 = t3), 32), c4 = (u4 = t3) + v4 | 0, n4 = D4 = a4 + _4 | 0, F4 = _A(D4 ^ d4, (p4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ L4, 40), c4 = (d4 = t3) + S4 | 0, S4 = D4 = F4 + FA2 | 0, D4 = _A(D4 ^ a4, u4 ^ (b4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = p4 + ($2 = t3) | 0, p4 = D4, u4 = c4 = (a4 = n4) >>> 0 > (n4 = n4 + D4 | 0) >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(n4 ^ F4, d4 ^ c4, 1), c4 = nA2 + (FA2 = t3) | 0, d4 = D4, HA2 = D4 = oA2 + D4 | 0, F4 = c4 = D4 >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = fA2, D4 = _A(h4 ^ _4, P4 ^ v4, 1), c4 = Y4 + (h4 = t3) | 0, c4 = ((_4 = w4) >>> 0 > (w4 = D4 + w4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, c4 = (_4 = (a4 = a4 + w4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) + SA2 | 0, L4 = w4 = a4 + eA2 | 0, Y4 = c4 = w4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, v4 = D4, w4 = _A(N4 ^ l3, Z2 ^ AA2, 48), c4 = _A(w4 ^ a4, (P4 = t3) ^ _4, 32), AA2 = D4 = t3, N4 = c4, a4 = D4, c4 = U4 + m4 | 0, c4 = (D4 = e4 + H4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = D4, U4 = c4, c4 = c4 + a4 | 0, _4 = D4 = D4 + N4 | 0, H4 = c4 = e4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(D4 ^ v4, c4 ^ h4, 40), c4 = (c4 = Y4) + (Y4 = t3) | 0, v4 = D4 = a4 + L4 | 0, l3 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + F4 | 0, Z2 = c4 = (h4 = D4 + HA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, F4 = c4, D4 = _A(y4 ^ e4, U4 ^ IA2, 1), c4 = q4 + (y4 = t3) | 0, c4 = M4 + ((e4 = D4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = yA2 + (k4 = (e4 = e4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4) | 0, L4 = M4 = e4 + z2 | 0, M4 = c4 = M4 >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, U4 = D4, c4 = _A(e4 ^ J4, k4 ^ W2, 32), m4 = D4 = t3, e4 = c4, k4 = D4, c4 = P4 + x4 | 0, J4 = D4 = w4 + O2 | 0, x4 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + k4 | 0, c4 = (w4 = D4 + e4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = w4 ^ U4, U4 = c4, k4 = _A(D4, c4 ^ y4, 40), c4 = (W2 = t3) + M4 | 0, y4 = D4 = k4 + L4 | 0, O2 = _A(D4 ^ e4, m4 ^ (M4 = D4 >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(O2 ^ h4, (IA2 = t3) ^ F4, 32), HA2 = D4 = t3, L4 = c4, F4 = D4, D4 = _A(f4 ^ J4, x4 ^ tA2, 1), c4 = R4 + (f4 = t3) | 0, c4 = MA2 + ((e4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (e4 = e4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) + pA2 | 0, J4 = R4 = e4 + DA2 | 0, R4 = c4 = R4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(e4 ^ G4, r4 ^ CA2, 32), c4 = T2 + (x4 = t3) | 0, G4 = e4, r4 = f4, f4 = c4 = (e4 = s4 + e4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ e4, r4 ^ c4, 40), c4 = (CA2 = t3) + R4 | 0, s4 = D4 = r4 + J4 | 0, D4 = _A(J4 = D4 ^ G4, x4 ^ (G4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = f4 + (P4 = t3) | 0, f4 = D4, R4 = D4 = e4 + D4 | 0, J4 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + F4 | 0, T2 = c4 = (F4 = D4 + L4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(F4 ^ d4, FA2 ^ c4, 40), c4 = Z2 + (x4 = t3) | 0, c4 = ((D4 = e4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) + rA2 | 0, h4 = D4, Z2 = D4 = D4 + gA2 | 0, d4 = c4 = h4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, m4 = BA2, h4 = _A(N4 ^ v4, l3 ^ AA2, 48), c4 = (tA2 = t3) + H4 | 0, N4 = D4 = h4 + _4 | 0, c4 = _A(D4 ^ a4, (_4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) ^ Y4, 1), Y4 = a4 = t3, D4 = c4, c4 = M4 + Q4 | 0, c4 = ((y4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = (y4 = (a4 = D4 + y4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + m4 | 0, H4 = M4 = a4 + j2 | 0, M4 = c4 = M4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ f4, y4 ^ P4, 32), c4 = u4 + (v4 = t3) | 0, n4 = c4 = (f4 = a4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ f4, c4 ^ Y4, 40), c4 = (l3 = t3) + M4 | 0, M4 = D4 = y4 + H4 | 0, a4 = _A(D4 ^ a4, v4 ^ (Y4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + (H4 = t3) | 0, v4 = c4 = (n4 = a4 + f4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(y4 ^ n4, l3 ^ c4, 1), c4 = (l3 = t3) + d4 | 0, c4 = sA2 + ((f4 = D4 + Z2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (y4 = (f4 = f4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) + K4 | 0, FA2 = K4 = f4 + aA2 | 0, K4 = c4 = K4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, u4 = D4, m4 = f4, P4 = y4, f4 = fA2, D4 = _A(r4 ^ R4, J4 ^ CA2, 1), c4 = b4 + (r4 = t3) | 0, c4 = ((y4 = S4) >>> 0 > (S4 = D4 + S4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, c4 = pA2 + (y4 = (f4 = f4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4) | 0, b4 = S4 = f4 + DA2 | 0, R4 = c4 = S4 >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4, S4 = D4, y4 = c4 = _A(f4 ^ h4, y4 ^ tA2, 32), c4 = U4 + IA2 | 0, c4 = (J4 = D4 = t3) + (w4 = (D4 = w4 + O2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (h4 = D4 + y4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(h4 ^ S4, c4 ^ r4, 40), c4 = (IA2 = t3) + R4 | 0, R4 = _A(b4 = (f4 = S4 + b4 | 0) ^ y4, J4 ^ (y4 = f4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(R4 ^ m4, (CA2 = t3) ^ P4, 32), tA2 = r4 = t3, b4 = c4, J4 = r4, D4 = _A(D4 ^ k4, w4 ^ W2, 1), c4 = yA2 + (r4 = t3) | 0, c4 = G4 + ((w4 = D4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = MA2 + (s4 = (w4 = w4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, m4 = k4 = w4 + QA2 | 0, k4 = c4 = k4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, G4 = D4, O2 = r4, w4 = _A(w4 ^ p4, s4 ^ $2, 32), c4 = (p4 = t3) + _4 | 0, r4 = D4 = w4 + N4 | 0, s4 = _A(D4 ^ G4, (N4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) ^ O2, 40), c4 = (W2 = t3) + k4 | 0, G4 = D4 = s4 + m4 | 0, D4 = _A(D4 ^ w4, p4 ^ (_4 = D4 >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = N4 + (m4 = t3) | 0, k4 = D4, N4 = D4 = r4 + D4 | 0, p4 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + J4 | 0, J4 = D4 = D4 + b4 | 0, w4 = l3, l3 = c4 = N4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ u4, w4 ^ c4, 40), c4 = (c4 = K4) + (K4 = t3) | 0, O2 = D4 = w4 + FA2 | 0, u4 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = y4, D4 = _A(L4 ^ Z2, d4 ^ HA2, 48), c4 = T2 + ($2 = t3) | 0, T2 = D4, y4 = (D4 = F4 + D4 | 0) ^ e4, e4 = c4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(y4, c4 ^ x4, 1), c4 = (x4 = t3) + r4 | 0, c4 = B4 + ((f4 = y4 + f4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (f4 = f4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, Z2 = F4 = f4 + cA2 | 0, F4 = c4 = F4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(f4 ^ k4, r4 ^ m4, 32), c4 = v4 + (d4 = t3) | 0, v4 = f4, n4 = c4 = (r4 = n4 + f4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(y4 ^ r4, x4 ^ c4, 40), c4 = (c4 = F4) + (F4 = t3) | 0, k4 = f4 = y4 + Z2 | 0, f4 = _A(L4 = f4 ^ v4, d4 ^ (v4 = f4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + (FA2 = t3) | 0, x4 = f4, Z2 = c4 = (n4 = r4 + f4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(y4 ^ n4, F4 ^ c4, 1), c4 = (F4 = t3) + u4 | 0, c4 = Q4 + ((y4 = f4 + O2 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = X2 + (r4 = (y4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, HA2 = d4 = I7 + y4 | 0, d4 = c4 = d4 >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, L4 = f4, m4 = F4, F4 = y4, P4 = r4, f4 = _A(s4 ^ N4, p4 ^ W2, 1), c4 = (r4 = t3) + Y4 | 0, c4 = hA2 + ((y4 = f4 + M4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (s4 = (y4 = y4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + X2 | 0, Y4 = M4 = I7 + y4 | 0, M4 = c4 = M4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, N4 = f4, y4 = c4 = _A(y4 ^ T2, s4 ^ $2, 32), s4 = f4 = t3, c4 = U4 + CA2 | 0, U4 = c4 = (f4 = h4 + R4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + s4 | 0, c4 = (h4 = f4) >>> 0 > (f4 = f4 + y4 | 0) >>> 0 ? c4 + 1 | 0 : c4, R4 = f4, f4 ^= N4, N4 = c4, r4 = _A(f4, c4 ^ r4, 40), c4 = (W2 = t3) + M4 | 0, s4 = _A(M4 = (f4 = r4 + Y4 | 0) ^ y4, s4 ^ (y4 = f4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(s4 ^ F4, (c4 = P4) ^ (P4 = t3), 32), $2 = F4 = t3, M4 = c4, Y4 = e4, e4 = a4, c4 = _A(h4 ^ S4, U4 ^ IA2, 1), p4 = a4 = t3, h4 = c4, c4 = _4 + SA2 | 0, c4 = ((S4 = G4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, S4 = c4 = (a4 = h4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(a4 ^ e4, c4 ^ H4, 32), c4 = (c4 = Y4) + (Y4 = t3) | 0, h4 = _A((D4 = e4 + D4 | 0) ^ h4, p4 ^ (U4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = S4 + (IA2 = t3) | 0, G4 = h4, c4 = NA2 + ((_4 = a4) >>> 0 > (a4 = a4 + h4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, _4 = c4 = (h4 = a4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(e4 ^ h4, Y4 ^ c4, 48), c4 = U4 + (CA2 = t3) | 0, H4 = D4, e4 = a4, U4 = D4 = D4 + a4 | 0, Y4 = c4 = H4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + F4 | 0, H4 = c4 = (F4 = D4 + M4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = (S4 = _A(F4 ^ L4, c4 ^ m4, 40)) + HA2 | 0, c4 = (HA2 = t3) + d4 | 0, p4 = D4, T2 = D4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(b4 ^ O2, u4 ^ tA2, 48), c4 = (b4 = t3) + l3 | 0, J4 = a4 = D4 + J4 | 0, L4 = K4, K4 = c4 = a4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(a4 ^ w4, L4 ^ c4, 1), O2 = a4 = t3, w4 = c4, c4 = y4 + B4 | 0, c4 = ((f4 = f4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = sA2 + (f4 = (a4 = f4 + w4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, u4 = y4 = a4 + V2 | 0, y4 = c4 = y4 >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ e4, f4 ^ CA2, 32), c4 = Z2 + (d4 = t3) | 0, l3 = a4, a4 = (e4 = n4 + a4 | 0) ^ w4, w4 = c4 = e4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(a4, O2 ^ c4, 40), c4 = (c4 = y4) + (y4 = t3) | 0, O2 = a4 = f4 + u4 | 0, a4 = _A(n4 = a4 ^ l3, d4 ^ (l3 = a4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = w4 + (CA2 = t3) | 0, Z2 = a4, e4 = c4 = (a4 = e4 + a4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(a4 ^ f4, y4 ^ c4, 1), c4 = (n4 = t3) + T2 | 0, c4 = nA2 + ((y4 = f4 + p4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (w4 = (y4 = y4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) + BA2 | 0, AA2 = u4 = y4 + j2 | 0, u4 = c4 = u4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, d4 = f4, L4 = y4, m4 = w4, f4 = _A(G4 ^ U4, Y4 ^ IA2, 1), c4 = (Y4 = t3) + rA2 | 0, c4 = v4 + (f4 >>> 0 > (y4 = f4 + gA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, w4 = c4 = (y4 = y4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ y4, c4 ^ b4, 32), b4 = D4 = t3, k4 = c4, c4 = N4 + P4 | 0, c4 = (D4 = s4 + R4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, s4 = D4, U4 = c4, c4 = b4 + c4 | 0, N4 = D4 = D4 + k4 | 0, G4 = c4 = s4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(D4 ^ f4, Y4 ^ c4, 40), c4 = w4 + (P4 = t3) | 0, R4 = D4, c4 = yA2 + ((D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (D4 = D4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, Y4 = D4, D4 ^= k4, k4 = c4, w4 = _A(D4, b4 ^ c4, 48), c4 = _A(w4 ^ L4, (c4 = m4) ^ (m4 = t3), 32), IA2 = D4 = t3, b4 = c4, v4 = D4, D4 = _A(r4 ^ s4, U4 ^ W2, 1), c4 = SA2 + (y4 = t3) | 0, c4 = _4 + ((f4 = D4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (f4 = f4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, _4 = s4 = f4 + cA2 | 0, s4 = c4 = s4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, h4 = D4, U4 = y4, D4 = (f4 = _A(f4 ^ x4, r4 ^ FA2, 32)) + J4 | 0, c4 = (J4 = t3) + K4 | 0, y4 = D4, r4 = _A(r4 = D4 ^ h4, (h4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) ^ U4, 40), c4 = (W2 = t3) + s4 | 0, s4 = D4 = r4 + _4 | 0, f4 = _A(D4 ^ f4, J4 ^ (K4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = h4 + (U4 = t3) | 0, _4 = D4 = f4 + y4 | 0, J4 = c4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + v4 | 0, v4 = c4 = (h4 = D4 + b4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(h4 ^ d4, c4 ^ n4, 40), c4 = (x4 = t3) + u4 | 0, u4 = D4 = y4 + AA2 | 0, d4 = c4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, D4 = a4, n4 = e4, e4 = f4, a4 = _A(M4 ^ p4, T2 ^ $2, 48), c4 = H4 + (AA2 = t3) | 0, M4 = a4, F4 = c4 = (f4 = F4 + a4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(f4 ^ S4, HA2 ^ c4, 1), H4 = a4 = t3, S4 = c4, c4 = k4 + KA2 | 0, c4 = ((k4 = Y4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, k4 = c4 = (a4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(a4 ^ e4, c4 ^ U4, 32), c4 = (Y4 = t3) + n4 | 0, S4 = _A((D4 = e4 + D4 | 0) ^ S4, H4 ^ (n4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = k4 + (p4 = t3) | 0, c4 = MA2 + ((k4 = a4) >>> 0 > (a4 = a4 + S4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (k4 = a4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(e4 ^ k4, Y4 ^ c4, 48), c4 = n4 + ($2 = t3) | 0, Y4 = a4, H4 = c4 = (n4 = D4 + a4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(n4 ^ S4, p4 ^ c4, 1), c4 = (S4 = t3) + d4 | 0, c4 = hA2 + ((a4 = D4 + u4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = nA2 + (e4 = (a4 = a4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, tA2 = p4 = a4 + oA2 | 0, p4 = c4 = p4 >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4, T2 = D4, L4 = a4, D4 = _A(r4 ^ _4, J4 ^ W2, 1), c4 = (r4 = t3) + l3 | 0, c4 = pA2 + ((a4 = D4 + O2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = NA2 + (_4 = (a4 = a4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, O2 = J4 = a4 + EA2 | 0, J4 = c4 = J4 >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4, l3 = D4, c4 = _A(a4 ^ M4, _4 ^ AA2, 32), AA2 = D4 = t3, a4 = c4, c4 = G4 + m4 | 0, N4 = D4 = w4 + N4 | 0, M4 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = AA2 + c4 | 0, G4 = c4 = (w4 = D4 + a4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(w4 ^ l3, c4 ^ r4, 40), c4 = (m4 = t3) + J4 | 0, _4 = D4 = r4 + O2 | 0, l3 = _A(D4 ^ a4, AA2 ^ (J4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(l3 ^ L4, (AA2 = t3) ^ e4, 32), W2 = D4 = t3, O2 = c4, e4 = D4, a4 = fA2, D4 = _A(N4 ^ R4, M4 ^ P4, 1), c4 = K4 + (M4 = t3) | 0, c4 = ((N4 = s4) >>> 0 > (s4 = D4 + s4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, c4 = hA2 + (s4 = (a4 = a4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, N4 = K4 = a4 + iA2 | 0, K4 = c4 = K4 >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ Z2, s4 ^ CA2, 32), c4 = F4 + (R4 = t3) | 0, F4 = a4, c4 = (a4 = f4 + a4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = M4, M4 = c4, f4 = _A(D4 ^ a4, f4 ^ c4, 40), c4 = (P4 = t3) + K4 | 0, s4 = D4 = f4 + N4 | 0, D4 = _A(D4 ^ F4, R4 ^ (K4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = M4 + (L4 = t3) | 0, M4 = D4, N4 = D4 = a4 + D4 | 0, R4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + e4 | 0, c4 = (F4 = D4 + O2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = F4 ^ T2, T2 = c4, S4 = _A(D4, c4 ^ S4, 40), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = S4 + tA2 | 0, Z2 = D4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(b4 ^ u4, d4 ^ IA2, 48), c4 = v4 + (IA2 = t3) | 0, b4 = D4, c4 = (D4 = h4 + D4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, h4 = D4, v4 = c4, c4 = _A(D4 ^ y4, c4 ^ x4, 1), x4 = D4 = t3, e4 = c4, c4 = J4 + sA2 | 0, c4 = ((a4 = _4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) + D4 | 0, c4 = MA2 + (a4 = (D4 = a4 + e4 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) | 0, _4 = y4 = D4 + QA2 | 0, y4 = c4 = y4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(D4 ^ M4, a4 ^ L4, 32), c4 = H4 + (J4 = t3) | 0, M4 = D4, n4 = c4 = (a4 = n4 + D4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(a4 ^ e4, x4 ^ c4, 40), c4 = (x4 = t3) + y4 | 0, _4 = D4 = e4 + _4 | 0, D4 = _A(y4 = D4 ^ M4, J4 ^ (M4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + (tA2 = t3) | 0, n4 = D4, H4 = c4 = (y4 = a4 + D4 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(y4 ^ e4, x4 ^ c4, 1), c4 = (J4 = t3) + Z2 | 0, c4 = SA2 + ((a4 = D4 + p4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (e4 = (a4 = a4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) + rA2 | 0, FA2 = x4 = a4 + gA2 | 0, x4 = c4 = x4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, u4 = D4, d4 = a4, L4 = e4, D4 = _A(f4 ^ N4, P4 ^ R4, 1), c4 = pA2 + (e4 = t3) | 0, c4 = U4 + ((a4 = D4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = KA2 + (f4 = (a4 = a4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4) | 0, R4 = k4 = a4 + aA2 | 0, k4 = c4 = k4 >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4, U4 = D4, N4 = e4, c4 = _A(a4 ^ b4, f4 ^ IA2, 32), b4 = D4 = t3, f4 = c4, a4 = D4, c4 = G4 + AA2 | 0, c4 = (D4 = w4 + l3 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, w4 = D4, G4 = c4, c4 = c4 + a4 | 0, c4 = (e4 = D4 + f4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = e4 ^ U4, U4 = c4, D4 = _A(D4, c4 ^ N4, 40), c4 = (c4 = k4) + (k4 = t3) | 0, N4 = a4 = D4 + R4 | 0, R4 = c4 = a4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, b4 = _A(a4 ^ f4, b4 ^ c4, 48), c4 = _A(b4 ^ d4, (c4 = L4) ^ (L4 = t3), 32), P4 = a4 = t3, l3 = c4, a4 = _A(w4 ^ r4, G4 ^ m4, 1), c4 = (w4 = t3) + wA2 | 0, c4 = K4 + ((f4 = a4 + fA2 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = B4 + (r4 = (f4 = f4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, m4 = s4 = f4 + kA2 | 0, s4 = c4 = s4 >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4, K4 = a4, G4 = w4, f4 = _A(f4 ^ Y4, r4 ^ $2, 32), c4 = (Y4 = t3) + v4 | 0, w4 = a4 = f4 + h4 | 0, a4 = (r4 = _A(a4 ^ K4, (h4 = a4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) ^ G4, 40)) + m4 | 0, c4 = (m4 = t3) + s4 | 0, K4 = a4, a4 = _A(a4 ^ f4, Y4 ^ (G4 = a4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = h4 + (AA2 = t3) | 0, Y4 = a4, v4 = a4 = w4 + a4 | 0, d4 = c4 = a4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = P4 + c4 | 0, c4 = (f4 = a4 + l3 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, a4 = J4, J4 = c4, w4 = _A(f4 ^ u4, a4 ^ c4, 40), c4 = (IA2 = t3) + x4 | 0, s4 = a4 = w4 + FA2 | 0, c4 = _A(a4 ^ l3, P4 ^ (x4 = a4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4), 48), P4 = a4 = t3, l3 = c4, a4 = D4, c4 = U4 + L4 | 0, U4 = D4 = e4 + b4 | 0, b4 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ a4, c4 ^ k4, 1), e4 = a4 = t3, D4 = c4, c4 = G4 + Q4 | 0, c4 = ((h4 = K4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = yA2 + (h4 = (a4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) | 0, L4 = k4 = a4 + z2 | 0, k4 = c4 = k4 >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, K4 = D4, G4 = e4, D4 = _A(p4 ^ O2, Z2 ^ W2, 48), c4 = T2 + (W2 = t3) | 0, p4 = D4, c4 = (D4 = F4 + D4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, F4 = D4, a4 = _A(a4 ^ n4, h4 ^ tA2, 32), T2 = c4, c4 = c4 + (O2 = t3) | 0, e4 = D4 = a4 + D4 | 0, h4 = _A(D4 ^ K4, (n4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ G4, 40), c4 = (Z2 = t3) + k4 | 0, k4 = D4 = h4 + L4 | 0, D4 = _A(D4 ^ a4, O2 ^ (K4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + ($2 = t3) | 0, G4 = D4, O2 = c4 = (n4 = e4 + D4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ n4, Z2 ^ c4, 1), c4 = MA2 + (L4 = t3) | 0, Z2 = D4, tA2 = D4 = QA2 + D4 | 0, e4 = c4 = D4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(S4 ^ F4, T2 ^ CA2, 1), c4 = (h4 = t3) + R4 | 0, c4 = NA2 + ((a4 = D4 + N4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = BA2 + (F4 = (a4 = a4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, T2 = S4 = a4 + j2 | 0, S4 = c4 = S4 >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, N4 = h4, a4 = _A(a4 ^ Y4, F4 ^ AA2, 32), c4 = H4 + (AA2 = t3) | 0, R4 = a4, c4 = (h4 = y4 + a4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, y4 = N4, N4 = c4, F4 = _A(D4 ^ h4, y4 ^ c4, 40), c4 = (CA2 = t3) + S4 | 0, Y4 = D4 = F4 + T2 | 0, c4 = (H4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, S4 = c4 = (e4 = D4 + tA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, T2 = c4 = _A(e4 ^ l3, c4 ^ P4, 32), u4 = D4 = t3, D4 = _A(r4 ^ v4, d4 ^ m4, 1), c4 = (y4 = t3) + M4 | 0, c4 = X2 + ((a4 = D4 + _4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (a4 = I7 + a4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, d4 = M4 = a4 + cA2 | 0, M4 = c4 = M4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, _4 = D4, v4 = y4, a4 = _A(a4 ^ p4, r4 ^ W2, 32), c4 = (p4 = t3) + b4 | 0, y4 = D4 = a4 + U4 | 0, D4 = (r4 = _A(D4 ^ _4, (U4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ v4, 40)) + d4 | 0, c4 = (d4 = t3) + M4 | 0, M4 = D4, D4 = _A(D4 ^ a4, p4 ^ (_4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = U4 + (W2 = t3) | 0, U4 = D4, p4 = c4 = (D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + u4 | 0, b4 = c4 = (y4 = D4) >>> 0 > (D4 = D4 + T2 | 0) >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(D4 ^ Z2, L4 ^ c4, 40), c4 = S4 + (L4 = t3) | 0, v4 = a4, c4 = Q4 + ((a4 = e4 + a4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4) | 0, Z2 = a4 = a4 + g6 | 0, e4 = a4 ^ T2, T2 = c4 = a4 >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(e4, u4 ^ c4, 48), c4 = b4 + (u4 = t3) | 0, b4 = c4 = (S4 = D4 + a4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = c4 = _A(S4 ^ v4, L4 ^ c4, 1), v4 = e4 = t3, e4 = _A(y4 ^ r4, p4 ^ d4, 1), c4 = K4 + (r4 = t3) | 0, c4 = NA2 + ((y4 = e4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = hA2 + (k4 = (y4 = y4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, L4 = K4 = y4 + iA2 | 0, K4 = c4 = K4 >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, p4 = e4, d4 = r4, c4 = J4 + P4 | 0, c4 = (e4 = f4 + l3 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, J4 = e4, R4 = _A(Y4 ^ R4, H4 ^ AA2, 48), r4 = _A(y4 ^ R4, k4 ^ (AA2 = t3), 32), Y4 = c4, c4 = c4 + (tA2 = t3) | 0, k4 = e4 = r4 + e4 | 0, e4 = _A(e4 ^ p4, (H4 = e4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) ^ d4, 40), c4 = (p4 = t3) + K4 | 0, d4 = c4 = (f4 = e4 + L4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + v4 | 0, c4 = B4 + ((l3 = f4) >>> 0 > (f4 = D4 + f4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (y4 = (f4 = f4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, FA2 = K4 = f4 + fA2 | 0, L4 = c4 = K4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, m4 = D4, P4 = f4, c4 = _A(w4 ^ J4, Y4 ^ IA2, 1), w4 = f4 = t3, D4 = c4, c4 = _4 + pA2 | 0, c4 = ((K4 = M4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, c4 = yA2 + (K4 = (f4 = D4 + K4 | 0) >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4) | 0, Y4 = M4 = f4 + z2 | 0, M4 = c4 = M4 >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, _4 = D4, c4 = _A(f4 ^ G4, K4 ^ $2, 32), J4 = D4 = t3, f4 = c4, K4 = D4, c4 = N4 + AA2 | 0, N4 = D4 = h4 + R4 | 0, G4 = c4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + K4 | 0, c4 = (h4 = D4 + f4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = h4 ^ _4; + _4 = c4, K4 = _A(D4, c4 ^ w4, 40), c4 = (AA2 = t3) + M4 | 0, R4 = _A(M4 = (D4 = K4 + Y4 | 0) ^ f4, J4 ^ (f4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(c4 = R4 ^ P4, (P4 = t3) ^ y4, 32), IA2 = y4 = t3, Y4 = c4, M4 = y4, y4 = _A(F4 ^ N4, G4 ^ CA2, 1), c4 = BA2 + (F4 = t3) | 0, c4 = x4 + ((w4 = y4 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = SA2 + (s4 = (w4 = w4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = N4 = w4 + eA2 | 0, N4 = c4 = N4 >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ U4, s4 ^ W2, 32), c4 = O2 + (J4 = t3) | 0, U4 = w4, n4 = c4 = (w4 = n4 + w4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, s4 = _A(y4 ^ w4, c4 ^ F4, 40), c4 = (W2 = t3) + N4 | 0, F4 = y4 = s4 + G4 | 0, y4 = _A(N4 = y4 ^ U4, J4 ^ (U4 = y4 >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + ($2 = t3) | 0, N4 = y4, G4 = y4 = w4 + y4 | 0, J4 = c4 = y4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + M4 | 0, c4 = (w4 = y4 + Y4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, y4 = v4, v4 = c4, n4 = _A(w4 ^ m4, y4 ^ c4, 40), c4 = (x4 = t3) + L4 | 0, M4 = y4 = n4 + FA2 | 0, y4 = _A(L4 = y4 ^ Y4, IA2 ^ (Y4 = y4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = v4 + (IA2 = t3) | 0, v4 = y4, w4 = c4 = (y4 = w4 + y4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, x4 = c4 = _A(y4 ^ n4, x4 ^ c4, 1), CA2 = c4, O2 = n4 = t3, n4 = f4, f4 = e4, e4 = _A(r4 ^ l3, d4 ^ tA2, 48), c4 = H4 + (tA2 = t3) | 0, H4 = e4, c4 = (e4 = k4 + e4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = D4, D4 = f4 ^ e4, f4 = c4, D4 = _A(D4, c4 ^ p4, 1), c4 = (p4 = t3) + n4 | 0, c4 = KA2 + (D4 >>> 0 > (r4 = k4 + D4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = rA2 + (k4 = (r4 = r4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = n4 = r4 + gA2 | 0, n4 = c4 = n4 >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ N4, k4 ^ $2, 32), c4 = b4 + (d4 = t3) | 0, N4 = c4 = (k4 = r4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(D4 ^ k4, p4 ^ c4, 40), c4 = ($2 = t3) + n4 | 0, p4 = D4 = S4 + l3 | 0, r4 = _A(D4 ^ r4, d4 ^ (b4 = D4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = N4 + (l3 = t3) | 0, d4 = D4 = r4 + k4 | 0, N4 = D4, L4 = c4 = D4 >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = e4, n4 = f4, c4 = _4 + P4 | 0, c4 = (D4 = h4 + R4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, h4 = D4, D4 ^= K4, K4 = c4, c4 = _A(D4, AA2 ^ c4, 1), m4 = D4 = t3, _4 = c4, f4 = c4, c4 = U4 + q4 | 0, c4 = ((e4 = F4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) + D4 | 0, F4 = c4 = (D4 = e4) >>> 0 > (e4 = f4 + e4 | 0) >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(a4 ^ e4, c4 ^ u4, 32), c4 = (c4 = n4) + (n4 = t3) | 0, R4 = D4 = f4 + k4 | 0, a4 = _A(a4 = D4 ^ _4, m4 ^ (_4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = F4 + (u4 = t3) | 0, c4 = sA2 + ((D4 = a4 + e4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4) | 0, m4 = c4 = (k4 = D4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, n4 = _A(f4 ^ k4, n4 ^ c4, 48), FA2 = c4 = t3, D4 = _A(s4 ^ G4, J4 ^ W2, 1), c4 = (f4 = t3) + T2 | 0, c4 = nA2 + ((e4 = D4 + Z2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = X2 + (s4 = (e4 = e4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, T2 = F4 = I7 + e4 | 0, G4 = c4 = F4 >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, J4 = D4, F4 = _A(e4 ^ H4, s4 ^ tA2, 32), c4 = (W2 = t3) + K4 | 0, K4 = D4 = F4 + h4 | 0, e4 = _A(D4 ^ J4, (H4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ f4, 40), c4 = (c4 = G4) + (G4 = t3) | 0, J4 = D4 = e4 + T2 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = X2 + O2 | 0, c4 = ((s4 = I7 + x4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, U4 = c4 = (f4 = D4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ n4, FA2 ^ c4, 32), c4 = (x4 = t3) + L4 | 0, h4 = _A((s4 = D4 + N4 | 0) ^ CA2, (c4 = s4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ O2, 40), O2 = c4, c4 = rA2 + (N4 = t3) | 0, c4 = U4 + ((Z2 = h4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = f4 + Z2 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = x4, x4 = c4, f4 = _A(D4 ^ U4, f4 ^ c4, 48), c4 = (c4 = O2) + (O2 = t3) | 0, D4 = h4 ^ (s4 = f4 + s4 | 0), h4 = c4 = s4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, Z2 = c4 = _A(D4, c4 ^ N4, 1), CA2 = c4, P4 = D4 = t3, N4 = y4, AA2 = w4, y4 = e4, e4 = _A(F4 ^ J4, T2 ^ W2, 48), c4 = H4 + (J4 = t3) | 0, F4 = D4 = e4 + K4 | 0, K4 = c4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ G4, 1), c4 = (T2 = t3) + KA2 | 0, c4 = m4 + ((D4 = y4 + aA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, k4 = c4 = (w4 = D4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(w4 ^ r4, c4 ^ l3, 32), c4 = (G4 = t3) + AA2 | 0, N4 = r4 = D4 + N4 | 0, H4 = c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(y4 ^ r4, c4 ^ T2, 40), c4 = hA2 + (tA2 = t3) | 0, T2 = y4, c4 = k4 + ((y4 = iA2 + y4 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, w4 = c4 = (y4 = y4 + w4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ y4, c4 ^ G4, 48), c4 = (c4 = H4) + (H4 = t3) | 0, l3 = D4 = r4 + N4 | 0, G4 = D4, m4 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _4 + FA2 | 0, N4 = (D4 = n4 + R4 | 0) ^ a4, a4 = c4 = D4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(N4, c4 ^ u4, 1), u4 = k4 = t3, N4 = c4, c4 = b4 + yA2 | 0, c4 = ((n4 = p4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) + k4 | 0, _4 = c4 = (_4 = n4) >>> 0 > (n4 = n4 + N4 | 0) >>> 0 ? c4 + 1 | 0 : c4, R4 = k4 = _A(n4 ^ v4, IA2 ^ c4, 32), p4 = c4 = t3, c4 = c4 + K4 | 0, b4 = k4 = k4 + F4 | 0, v4 = c4 = R4 >>> 0 > k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = _A(k4 ^ N4, u4 ^ c4, 40), c4 = wA2 + (u4 = t3) | 0, c4 = _4 + ((F4 = k4 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (N4 = n4) >>> 0 > (n4 = n4 + F4 | 0) >>> 0 ? c4 + 1 | 0 : c4, N4 = _A(n4 ^ R4, c4 ^ p4, 48), IA2 = c4 = t3, K4 = c4, S4 = _A(S4 ^ d4, L4 ^ $2, 1), _4 = c4 = t3, R4 = e4, c4 = c4 + q4 | 0, c4 = Y4 + ((e4 = S4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (e4 = e4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, M4 = e4 ^ R4, R4 = c4, M4 = _A(M4, c4 ^ J4, 32), c4 = ($2 = t3) + a4 | 0, Y4 = D4 = M4 + D4 | 0, a4 = _A(D4 ^ S4, (a4 = _4) ^ (_4 = D4 >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = nA2 + (p4 = t3) | 0, c4 = R4 + ((D4 = a4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, R4 = D4 = D4 + e4 | 0, J4 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + NA2 | 0, c4 = ((S4 = Z2 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, Z2 = c4 = (e4 = D4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ N4, c4 ^ K4, 32), c4 = (d4 = t3) + m4 | 0, K4 = _A((S4 = D4 + G4 | 0) ^ CA2, (c4 = S4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = G4 = t3, P4 = c4, c4 = G4 + SA2 | 0, c4 = Z2 + ((G4 = K4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, Z2 = c4 = (G4 = e4 + G4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(D4 ^ G4, c4 ^ d4, 48), c4 = (d4 = t3) + P4 | 0, D4 = (S4 = e4 + S4 | 0) ^ K4, K4 = c4 = S4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, L4 = c4 = _A(D4, c4 ^ L4, 1), P4 = D4 = t3, AA2 = s4, W2 = r4, r4 = a4, a4 = _A(M4 ^ R4, J4 ^ $2, 48), c4 = (M4 = t3) + _4 | 0, _4 = D4 = a4 + Y4 | 0, R4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ r4, c4 ^ p4, 1), c4 = (p4 = t3) + MA2 | 0, c4 = ((D4 = r4 + QA2 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) + F4 | 0, n4 = c4 = (s4 = D4 + n4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(s4 ^ W2, c4 ^ H4, 32), c4 = (F4 = t3) + h4 | 0, Y4 = h4 = D4 + AA2 | 0, H4 = c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ h4, c4 ^ p4, 40), c4 = B4 + (W2 = t3) | 0, p4 = r4, c4 = n4 + ((r4 = kA2 + r4 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, J4 = c4 = (h4 = r4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ h4, c4 ^ F4, 48), c4 = (c4 = H4) + (H4 = t3) | 0, Y4 = D4 = r4 + Y4 | 0, AA2 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, n4 = f4, s4 = y4, c4 = v4 + IA2 | 0, f4 = c4 = (D4 = N4 + b4 | 0) >>> 0 < N4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ k4, c4 ^ u4, 1), c4 = (k4 = t3) + BA2 | 0, c4 = ((F4 = y4 + j2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + w4 | 0, w4 = _A(n4 ^ (s4 = s4 + F4 | 0), (c4 = s4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ O2, 32), F4 = c4, N4 = y4, c4 = (n4 = t3) + R4 | 0, c4 = (y4 = w4 + _4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, _4 = y4, y4 ^= N4, N4 = c4, y4 = _A(y4, c4 ^ k4, 40), c4 = Q4 + (R4 = t3) | 0, c4 = ((k4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + F4 | 0, b4 = c4 = (F4 = k4) >>> 0 > (k4 = k4 + s4 | 0) >>> 0 ? c4 + 1 | 0 : c4, n4 = _A(w4 ^ k4, c4 ^ n4, 48), IA2 = c4 = t3, s4 = c4, w4 = _A(l3 ^ T2, m4 ^ tA2, 1), v4 = c4 = t3, T2 = f4, c4 = c4 + sA2 | 0, c4 = x4 + ((f4 = w4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = M4, M4 = c4 = (f4 = f4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, F4 = _A(a4 ^ f4, F4 ^ c4, 32), c4 = ($2 = t3) + T2 | 0, U4 = D4 = F4 + D4 | 0, a4 = _A(D4 ^ w4, (a4 = v4) ^ (v4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = pA2 + (T2 = t3) | 0, c4 = M4 + ((D4 = a4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, x4 = D4 = D4 + f4 | 0, l3 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + yA2 | 0, c4 = ((w4 = z2 + L4 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + w4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ n4, c4 ^ s4, 32), c4 = (O2 = t3) + AA2 | 0, s4 = _A((w4 = D4 + Y4 | 0) ^ L4, (c4 = w4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = q4 + (u4 = t3) | 0, c4 = M4 + ((m4 = s4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + m4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = O2, O2 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (w4 = f4 + w4 | 0) ^ s4, s4 = c4 = w4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, u4 = c4 = _A(D4, c4 ^ u4, 1), m4 = D4 = t3, P4 = r4, r4 = a4, a4 = _A(F4 ^ x4, l3 ^ $2, 48), c4 = (c4 = v4) + (v4 = t3) | 0, U4 = D4 = a4 + U4 | 0, F4 = T2, T2 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ r4, F4 ^ c4, 1), c4 = (x4 = t3) + SA2 | 0, c4 = b4 + ((D4 = r4 + eA2 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = k4, k4 = D4 + k4 | 0, D4 = H4, H4 = c4 = F4 >>> 0 > k4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(k4 ^ P4, D4 ^ c4, 32), c4 = (c4 = K4) + (K4 = t3) | 0, b4 = c4 = (F4 = D4 + S4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, S4 = F4, r4 = _A(r4 ^ F4, c4 ^ x4, 40), c4 = sA2 + ($2 = t3) | 0, x4 = r4, c4 = H4 + ((r4 = V2 + r4 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, H4 = c4 = (F4 = r4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ F4, c4 ^ K4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = r4 + S4 | 0, P4 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, S4 = e4, c4 = N4 + IA2 | 0, e4 = c4 = (D4 = n4 + _4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ R4, 1), c4 = rA2 + (n4 = t3) | 0, c4 = J4 + ((k4 = y4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, N4 = (k4 = h4 + k4 | 0) ^ S4, S4 = c4 = k4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(N4, c4 ^ d4, 32), K4 = c4 = t3, N4 = y4, c4 = c4 + T2 | 0, c4 = (y4 = h4 + U4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, _4 = y4, y4 ^= N4, N4 = c4, y4 = _A(y4, c4 ^ n4, 40), c4 = Q4 + (R4 = t3) | 0, c4 = S4 + ((n4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, J4 = c4 = (n4 = k4 + n4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(h4 ^ n4, c4 ^ K4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(p4 ^ Y4, W2 ^ AA2, 1), U4 = c4 = t3, Y4 = e4, c4 = c4 + B4 | 0, c4 = Z2 + ((e4 = h4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = c4 = (e4 = e4 + G4 | 0) >>> 0 < G4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ v4, 32), c4 = (CA2 = t3) + Y4 | 0, Y4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (p4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4) ^ U4, 40), c4 = X2 + (v4 = t3) | 0, c4 = G4 + ((D4 = I7 + a4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = m4 + nA2 | 0, c4 = ((h4 = u4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + P4 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ u4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ m4, 40), d4 = c4, c4 = KA2 + (u4 = t3) | 0, c4 = U4 + ((m4 = k4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + m4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = d4) + (d4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, u4 = c4 = _A(D4, c4 ^ u4, 1), tA2 = c4, m4 = D4 = t3, AA2 = w4, W2 = r4, w4 = a4, a4 = _A(K4 ^ G4, T2 ^ CA2, 48), c4 = (K4 = t3) + p4 | 0, G4 = D4 = a4 + Y4 | 0, Y4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ v4, 1), c4 = (v4 = t3) + wA2 | 0, c4 = J4 + ((D4 = w4 + fA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (p4 = t3) + s4 | 0, b4 = c4 = (s4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ v4, 40), c4 = MA2 + (CA2 = t3) | 0, J4 = w4, c4 = n4 + ((w4 = QA2 + w4 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = w4 + r4 | 0, w4 = p4, p4 = c4 = n4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ n4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, v4 = D4 = w4 + s4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = N4 + IA2 | 0, f4 = c4 = (D4 = S4 + _4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ R4, 1), c4 = (S4 = t3) + pA2 | 0, c4 = H4 + ((s4 = y4 + DA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, r4 = _A(r4 ^ (s4 = s4 + F4 | 0), (c4 = s4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ L4, 32), N4 = F4 = t3, F4 = c4, _4 = y4, c4 = N4 + Y4 | 0, c4 = (y4 = r4 + G4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, G4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = hA2 + (R4 = t3) | 0, c4 = ((S4 = y4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + F4 | 0, H4 = N4, N4 = c4 = (F4 = s4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(r4 ^ F4, H4 ^ c4, 48), IA2 = c4 = t3, s4 = c4, r4 = _A(l3 ^ x4, P4 ^ $2, 1), Y4 = c4 = t3, H4 = f4, c4 = c4 + BA2 | 0, c4 = O2 + ((f4 = r4 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, M4 = c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ f4, c4 ^ K4, 32), c4 = ($2 = t3) + H4 | 0, H4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ r4, (a4 = Y4) ^ (Y4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = NA2 + (x4 = t3) | 0, c4 = M4 + ((D4 = a4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = D4 = D4 + f4 | 0, O2 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = m4 + Q4 | 0, c4 = ((r4 = u4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ S4, c4 ^ s4, 32), c4 = (u4 = t3) + T2 | 0, s4 = _A((r4 = D4 + v4 | 0) ^ tA2, (c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ m4, 40), m4 = c4, c4 = SA2 + (L4 = t3) | 0, c4 = M4 + ((P4 = s4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + P4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = u4, u4 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = m4) + (m4 = t3) | 0, D4 = (r4 = f4 + r4 | 0) ^ s4, s4 = c4 = r4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, L4 = c4 = _A(D4, c4 ^ L4, 1), P4 = D4 = t3, AA2 = h4, W2 = w4, w4 = a4, a4 = _A(K4 ^ l3, O2 ^ $2, 48), c4 = (K4 = t3) + Y4 | 0, Y4 = D4 = a4 + H4 | 0, H4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ x4, 1), c4 = (x4 = t3) + MA2 | 0, c4 = N4 + ((D4 = w4 + QA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (h4 = D4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ W2, c4 ^ b4, 32), c4 = (N4 = t3) + k4 | 0, b4 = c4 = (k4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ k4, c4 ^ x4, 40), c4 = BA2 + ($2 = t3) | 0, x4 = w4, c4 = F4 + ((w4 = j2 + w4 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = w4 + h4 | 0, w4 = N4, N4 = c4 = F4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ F4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = w4 + k4 | 0, O2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, h4 = e4, c4 = _4 + IA2 | 0, e4 = c4 = (D4 = S4 + G4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ R4, 1), c4 = NA2 + (S4 = t3) | 0, c4 = p4 + ((k4 = y4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (k4 = k4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ k4, c4 ^ d4, 32), G4 = c4 = t3, _4 = y4, c4 = c4 + H4 | 0, c4 = (y4 = h4 + Y4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = nA2 + (Y4 = t3) | 0, c4 = n4 + ((S4 = y4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (n4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = G4, G4 = c4, S4 = _A(h4 ^ n4, k4 ^ c4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(J4 ^ v4, T2 ^ CA2, 1), H4 = c4 = t3, p4 = e4, c4 = c4 + X2 | 0, c4 = Z2 + ((e4 = I7 + h4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (e4 = e4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ K4, 32), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = sA2 + (J4 = t3) | 0, c4 = U4 + ((D4 = a4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, v4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + rA2 | 0, c4 = ((h4 = L4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + O2 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ L4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = B4 + (d4 = t3) | 0, c4 = U4 + ((P4 = k4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + P4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = r4, W2 = w4, w4 = a4, a4 = _A(K4 ^ v4, T2 ^ CA2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ J4, 1), c4 = (J4 = t3) + yA2 | 0, c4 = G4 + ((D4 = w4 + z2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (G4 = t3) + s4 | 0, b4 = c4 = (s4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ J4, 40), c4 = pA2 + (CA2 = t3) | 0, J4 = w4, c4 = n4 + ((w4 = DA2 + w4 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = w4 + r4 | 0, w4 = G4, G4 = c4 = n4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ n4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, v4 = D4 = w4 + s4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = _4 + IA2 | 0, f4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = (S4 = t3) + hA2 | 0, c4 = N4 + ((s4 = y4 + iA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (s4 = s4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ s4, c4 ^ m4, 32), N4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = r4 + H4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = wA2 + (Y4 = t3) | 0, c4 = F4 + ((S4 = y4 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, H4 = N4, N4 = c4 = (F4 = s4 + S4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(r4 ^ F4, H4 ^ c4, 48), IA2 = c4 = t3, s4 = c4, r4 = _A(l3 ^ x4, O2 ^ $2, 1), H4 = c4 = t3, p4 = f4, c4 = c4 + q4 | 0, c4 = u4 + ((f4 = r4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, M4 = c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ f4, c4 ^ K4, 32), c4 = ($2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ r4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = KA2 + (x4 = t3) | 0, c4 = M4 + ((D4 = a4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = D4 = D4 + f4 | 0, O2 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + B4 | 0, c4 = ((r4 = d4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ S4, c4 ^ s4, 32), c4 = (u4 = t3) + T2 | 0, s4 = _A((r4 = D4 + v4 | 0) ^ d4, (c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), m4 = c4, c4 = NA2 + (d4 = t3) | 0, c4 = M4 + ((P4 = s4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + P4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = u4, u4 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = m4) + (m4 = t3) | 0, D4 = (r4 = f4 + r4 | 0) ^ s4, s4 = c4 = r4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = h4, W2 = w4, w4 = a4, a4 = _A(K4 ^ l3, O2 ^ $2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ x4, 1), c4 = (x4 = t3) + q4 | 0, c4 = N4 + ((D4 = w4 + cA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (h4 = D4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ W2, c4 ^ b4, 32), c4 = (N4 = t3) + k4 | 0, b4 = c4 = (k4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ k4, c4 ^ x4, 40), c4 = wA2 + ($2 = t3) | 0, x4 = w4, c4 = F4 + ((w4 = fA2 + w4 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = w4 + h4 | 0, w4 = N4, N4 = c4 = F4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ F4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = w4 + k4 | 0, O2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, h4 = e4, c4 = _4 + IA2 | 0, e4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = hA2 + (S4 = t3) | 0, c4 = G4 + ((k4 = y4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (k4 = k4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ k4, c4 ^ L4, 32), G4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = h4 + H4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = pA2 + (Y4 = t3) | 0, c4 = n4 + ((S4 = y4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (n4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = G4, G4 = c4, S4 = _A(h4 ^ n4, k4 ^ c4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(J4 ^ v4, T2 ^ CA2, 1), H4 = c4 = t3, p4 = e4, c4 = c4 + BA2 | 0, c4 = Z2 + ((e4 = h4 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (e4 = e4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ K4, 32), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = KA2 + (J4 = t3) | 0, c4 = U4 + ((D4 = a4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, v4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + sA2 | 0, c4 = ((h4 = d4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + O2 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ d4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = X2 + (d4 = t3) | 0, c4 = U4 + ((P4 = I7 + k4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + P4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = r4, W2 = w4, w4 = a4, a4 = _A(K4 ^ v4, T2 ^ CA2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ J4, 1), c4 = (J4 = t3) + nA2 | 0, c4 = G4 + ((D4 = w4 + oA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (G4 = t3) + s4 | 0, b4 = c4 = (s4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ J4, 40), c4 = Q4 + (CA2 = t3) | 0, J4 = w4, c4 = n4 + ((w4 = g6 + w4 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = w4 + r4 | 0, w4 = G4, G4 = c4 = n4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ n4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, v4 = D4 = w4 + s4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = _4 + IA2 | 0, f4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = (S4 = t3) + rA2 | 0, c4 = N4 + ((s4 = y4 + gA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (s4 = s4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ s4, c4 ^ m4, 32), N4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = r4 + H4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = MA2 + (Y4 = t3) | 0, c4 = F4 + ((S4 = y4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, H4 = N4, N4 = c4 = (F4 = s4 + S4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(r4 ^ F4, H4 ^ c4, 48), IA2 = c4 = t3, s4 = c4, r4 = _A(l3 ^ x4, O2 ^ $2, 1), H4 = c4 = t3, p4 = f4, c4 = c4 + SA2 | 0, c4 = u4 + ((f4 = r4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, M4 = c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ f4, c4 ^ K4, 32), c4 = ($2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ r4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = yA2 + (x4 = t3) | 0, c4 = M4 + ((D4 = a4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = D4 = D4 + f4 | 0, O2 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + KA2 | 0, c4 = ((r4 = d4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ S4, c4 ^ s4, 32), c4 = (u4 = t3) + T2 | 0, s4 = _A((r4 = D4 + v4 | 0) ^ d4, (c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), m4 = c4, c4 = wA2 + (d4 = t3) | 0, c4 = M4 + ((P4 = s4 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + P4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = u4, u4 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = m4) + (m4 = t3) | 0, D4 = (r4 = f4 + r4 | 0) ^ s4, s4 = c4 = r4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = h4, W2 = w4, w4 = a4, a4 = _A(K4 ^ l3, O2 ^ $2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ x4, 1), c4 = (x4 = t3) + NA2 | 0, c4 = N4 + ((D4 = w4 + EA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (h4 = D4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ W2, c4 ^ b4, 32), c4 = (N4 = t3) + k4 | 0, b4 = c4 = (k4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ k4, c4 ^ x4, 40), c4 = B4 + ($2 = t3) | 0, x4 = w4, c4 = F4 + ((w4 = kA2 + w4 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = w4 + h4 | 0, w4 = N4, N4 = c4 = F4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ F4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = w4 + k4 | 0, O2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, h4 = e4, c4 = _4 + IA2 | 0, e4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = MA2 + (S4 = t3) | 0, c4 = G4 + ((k4 = y4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (k4 = k4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ k4, c4 ^ L4, 32), G4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = h4 + H4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = q4 + (Y4 = t3) | 0, c4 = n4 + ((S4 = y4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (n4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = G4, G4 = c4, S4 = _A(h4 ^ n4, k4 ^ c4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(J4 ^ v4, T2 ^ CA2, 1), H4 = c4 = t3, p4 = e4, c4 = c4 + pA2 | 0, c4 = Z2 + ((e4 = h4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (e4 = e4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ K4, 32), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = SA2 + (J4 = t3) | 0, c4 = U4 + ((D4 = a4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, v4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + hA2 | 0, c4 = ((h4 = d4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + O2 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ d4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = Q4 + (d4 = t3) | 0, c4 = U4 + ((P4 = k4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + P4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = r4, W2 = w4, w4 = a4, a4 = _A(K4 ^ v4, T2 ^ CA2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ J4, 1), c4 = (v4 = t3) + BA2 | 0, c4 = G4 + ((D4 = w4 + j2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (G4 = t3) + s4 | 0, b4 = s4 = D4 + AA2 | 0, J4 = c4 = s4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ v4, 40), c4 = sA2 + (AA2 = t3) | 0, v4 = w4, c4 = n4 + ((w4 = V2 + w4 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, s4 = w4 + r4 | 0, w4 = G4, G4 = c4 = s4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ s4, w4 ^ c4, 48), c4 = (c4 = J4) + (J4 = t3) | 0, b4 = D4 = w4 + b4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = _4 + IA2 | 0, f4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = (S4 = t3) + X2 | 0, c4 = N4 + ((n4 = I7 + y4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (n4 = n4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, N4 = r4 = _A(r4 ^ n4, c4 ^ m4, 32), _4 = c4 = t3, R4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = r4 + H4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, Y4 = y4, y4 ^= R4, R4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = nA2 + (H4 = t3) | 0, c4 = F4 + ((r4 = y4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, p4 = (r4 = r4 + n4 | 0) ^ N4, N4 = c4 = r4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, n4 = _A(p4, c4 ^ _4, 48), m4 = c4 = t3, S4 = c4, _4 = F4 = _A(l3 ^ x4, O2 ^ $2, 1), p4 = c4 = t3, x4 = f4, c4 = c4 + yA2 | 0, c4 = u4 + ((f4 = F4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, M4 = K4, K4 = c4, F4 = _A(a4 ^ f4, M4 ^ c4, 32), c4 = (W2 = t3) + x4 | 0, M4 = D4 = F4 + D4 | 0, a4 = _A(a4 = D4 ^ _4, (_4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ p4, 40), c4 = rA2 + (p4 = t3) | 0, c4 = K4 + ((D4 = a4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, K4 = D4 = D4 + f4 | 0, x4 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + sA2 | 0, c4 = ((u4 = V2) >>> 0 > (V2 = d4 + V2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, sA2 = c4 = (D4 = D4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, V2 = _A(D4 ^ n4, c4 ^ S4, 32), c4 = (l3 = t3) + T2 | 0, S4 = _A((f4 = b4 + V2 | 0) ^ d4, (c4 = f4 >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), u4 = c4, c4 = nA2 + (O2 = t3) | 0, c4 = sA2 + ((d4 = oA2) >>> 0 > (oA2 = S4 + oA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (oA2 = D4 + oA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = V2 ^ oA2, V2 = c4, nA2 = _A(D4, c4 ^ l3, 48); + c4 = (sA2 = t3) + u4 | 0, f4 = c4 = (D4 = f4 + nA2 | 0) >>> 0 < nA2 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ S4, c4 ^ O2, 1), S4 = t3, l3 = c4, O2 = h4, h4 = gA2, u4 = rA2, rA2 = _A(F4 ^ K4, x4 ^ W2, 48), c4 = (F4 = t3) + _4 | 0, _4 = h4, M4 = c4 = (gA2 = M4 + rA2 | 0) >>> 0 < rA2 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(a4 ^ (K4 = gA2), c4 ^ p4, 1), c4 = (p4 = t3) + u4 | 0, c4 = N4 + (h4 >>> 0 > (gA2 = _4 + h4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, a4 = c4 = (gA2 = r4 + gA2 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ gA2, c4 ^ J4, 32), c4 = (c4 = k4) + (k4 = t3) | 0, N4 = r4 = w4 + O2 | 0, _4 = c4 = r4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ h4, c4 ^ p4, 40), c4 = (p4 = t3) + NA2 | 0, c4 = (r4 >>> 0 > (EA2 = r4 + EA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, a4 = c4 = (a4 = EA2) >>> 0 > (EA2 = gA2 + EA2 | 0) >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ EA2, c4 ^ k4, 48), c4 = (h4 = t3) + _4 | 0, k4 = gA2 = w4 + N4 | 0, NA2 = c4 = gA2 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, N4 = I7, _4 = X2, c4 = R4 + m4 | 0, gA2 = c4 = (I7 = n4 + Y4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, X2 = _A(I7 ^ y4, c4 ^ H4, 1), c4 = (n4 = t3) + _4 | 0, c4 = G4 + ((y4 = N4 + X2 | 0) >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4) | 0, e4 = _A((y4 = y4 + s4 | 0) ^ e4, (c4 = y4 >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) ^ L4, 32), N4 = c4, G4 = iA2, iA2 = X2, c4 = (s4 = t3) + M4 | 0, M4 = n4, n4 = c4 = (X2 = e4 + K4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, iA2 = _A(X2 ^ iA2, M4 ^ c4, 40), c4 = (K4 = t3) + hA2 | 0, c4 = ((hA2 = G4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + N4 | 0, N4 = hA2, y4 = e4 ^ (hA2 = y4 + hA2 | 0), e4 = c4 = N4 >>> 0 > hA2 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(y4, c4 ^ s4, 48), R4 = y4 = t3, s4 = c4, M4 = j2, N4 = BA2, j2 = _A(b4 ^ v4, T2 ^ AA2, 1), _4 = c4 = t3, c4 = c4 + KA2 | 0, c4 = Z2 + ((j2 = (G4 = j2) + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, aA2 = c4 = (j2 = U4 + j2 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, BA2 = _A(j2 ^ rA2, c4 ^ F4, 32), c4 = (U4 = t3) + gA2 | 0, gA2 = I7 = BA2 + I7 | 0, rA2 = _A(I7 ^ G4, (F4 = I7 >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4) ^ _4, 40), c4 = (c4 = N4) + (N4 = t3) | 0, c4 = aA2 + ((I7 = rA2 + M4 | 0) >>> 0 < rA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, aA2 = I7 = I7 + j2 | 0, KA2 = c4 = I7 >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, j2 = c4, c4 = S4 + MA2 | 0, c4 = ((G4 = QA2) >>> 0 > (QA2 = l3 + QA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + j2 | 0, MA2 = c4 = (j2 = I7 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, QA2 = _A(s4 ^ j2, c4 ^ y4, 32), c4 = (G4 = t3) + NA2 | 0, y4 = I7 = QA2 + k4 | 0, I7 = _A(I7 ^ l3, (M4 = S4) ^ (S4 = I7 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = pA2 + (_4 = t3) | 0, pA2 = I7, c4 = MA2 + ((I7 = DA2 + I7 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (I7 = I7 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, MA2 = I7, Y4 = (i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24) ^ I7, M4 = c4, H4 = c4 ^ (i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24), j2 = _A(BA2 ^ aA2, U4 ^ KA2, 48), c4 = (aA2 = t3) + F4 | 0, F4 = I7 = j2 + gA2 | 0, KA2 = c4 = I7 >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, BA2 = fA2, c4 = n4 + R4 | 0, fA2 = c4 = (I7 = s4 + X2 | 0) >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, iA2 = _A(I7 ^ iA2, c4 ^ K4, 1), c4 = (s4 = t3) + wA2 | 0, c4 = ((BA2 = iA2 + BA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, BA2 = c4 = (wA2 = BA2 + EA2 | 0) >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4, gA2 = _A(wA2 ^ nA2, c4 ^ sA2, 32), c4 = (X2 = t3) + KA2 | 0, EA2 = c4 = (DA2 = gA2 + F4 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4, nA2 = gA2, gA2 = _A(iA2 ^ DA2, c4 ^ s4, 40), c4 = (a4 = t3) + SA2 | 0, c4 = (gA2 >>> 0 > (iA2 = gA2 + eA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + BA2 | 0, n4 = X2, X2 = c4 = (wA2 = iA2 + wA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, iA2 = _A(nA2 ^ (eA2 = wA2), n4 ^ c4, 48), c4 = (s4 = t3) + EA2 | 0, c4 = (BA2 = iA2 + DA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, DA2 = BA2, BA2 ^= Y4, C3[A8 + 8 | 0] = BA2, C3[A8 + 9 | 0] = BA2 >>> 8, C3[A8 + 10 | 0] = BA2 >>> 16, C3[A8 + 11 | 0] = BA2 >>> 24, EA2 = c4, c4 ^= H4, C3[A8 + 12 | 0] = c4, C3[A8 + 13 | 0] = c4 >>> 8, C3[A8 + 14 | 0] = c4 >>> 16, C3[A8 + 15 | 0] = c4 >>> 24, wA2 = I7, BA2 = fA2, I7 = j2, j2 = _A(r4 ^ k4, p4 ^ NA2, 1), c4 = (SA2 = t3) + Q4 | 0, c4 = (j2 >>> 0 > (fA2 = j2 + g6 | 0) >>> 0 ? c4 + 1 | 0 : c4) + V2 | 0, oA2 = c4 = (k4 = fA2) >>> 0 > (fA2 = oA2 + fA2 | 0) >>> 0 ? c4 + 1 | 0 : c4, I7 = _A(I7 ^ fA2, c4 ^ aA2, 32), c4 = (c4 = BA2) + (BA2 = t3) | 0, aA2 = c4 = (wA2 = I7 + wA2 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, nA2 = I7, wA2 = _A(j2 ^ (V2 = wA2), c4 ^ SA2, 40), c4 = (r4 = t3) + B4 | 0, c4 = oA2 + ((I7 = wA2 + kA2 | 0) >>> 0 < wA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (I7 = I7 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4, oA2 = I7, I7 ^= nA2, nA2 = c4, fA2 = _A(I7, c4 ^ BA2, 48), c4 = (k4 = t3) + aA2 | 0, V2 = I7 = fA2 + V2 | 0, aA2 = I7 >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4, rA2 = I7 = _A(F4 ^ rA2, N4 ^ KA2, 1), SA2 = c4 = t3, c4 = c4 + q4 | 0, c4 = e4 + ((I7 = I7 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, q4 = c4 = (j2 = I7 + hA2 | 0) >>> 0 < hA2 >>> 0 ? c4 + 1 | 0 : c4, I7 = (BA2 = _A(w4 ^ j2, c4 ^ h4, 32)) + D4 | 0, c4 = (D4 = t3) + f4 | 0, hA2 = I7, I7 = (cA2 = _A(e4 = I7 ^ rA2, (rA2 = I7 >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4) ^ SA2, 40)) + z2 | 0, c4 = (z2 = t3) + yA2 | 0, c4 = q4 + (I7 >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (q4 = I7 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, j2 = q4 ^ GA2 ^ V2, C3[0 | (I7 = A8)] = j2, C3[I7 + 1 | 0] = j2 >>> 8, C3[I7 + 2 | 0] = j2 >>> 16, C3[I7 + 3 | 0] = j2 >>> 24, j2 = c4 ^ E4 ^ aA2, C3[I7 + 4 | 0] = j2, C3[I7 + 5 | 0] = j2 >>> 8, C3[I7 + 6 | 0] = j2 >>> 16, C3[I7 + 7 | 0] = j2 >>> 24, j2 = (BA2 = _A(q4 ^ BA2, c4 ^ D4, 48)) + hA2 | 0, c4 = (hA2 = t3) + rA2 | 0, c4 = (rA2 = j2 >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4) ^ (i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24) ^ nA2, q4 = (i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24) ^ oA2 ^ j2, C3[I7 + 16 | 0] = q4, C3[I7 + 17 | 0] = q4 >>> 8, C3[I7 + 18 | 0] = q4 >>> 16, C3[I7 + 19 | 0] = q4 >>> 24, C3[I7 + 20 | 0] = c4, C3[I7 + 21 | 0] = c4 >>> 8, C3[I7 + 22 | 0] = c4 >>> 16, C3[I7 + 23 | 0] = c4 >>> 24, I7 = _A(QA2 ^ MA2, M4 ^ G4, 48), q4 = t3, oA2 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, c4 = (i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24) ^ _A(gA2 ^ DA2, a4 ^ EA2, 1) ^ I7, C3[A8 + 32 | 0] = c4, C3[A8 + 33 | 0] = c4 >>> 8, C3[A8 + 34 | 0] = c4 >>> 16, C3[A8 + 35 | 0] = c4 >>> 24, c4 = t3 ^ oA2 ^ q4, C3[A8 + 36 | 0] = c4, C3[A8 + 37 | 0] = c4 >>> 8, C3[A8 + 38 | 0] = c4 >>> 16, C3[A8 + 39 | 0] = c4 >>> 24, c4 = S4 + q4 | 0, c4 = (oA2 = I7 + y4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, gA2 = (i3[(I7 = A8) + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24) ^ X2 ^ c4, q4 = (i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24) ^ eA2 ^ oA2, C3[I7 + 24 | 0] = q4, C3[I7 + 25 | 0] = q4 >>> 8, C3[I7 + 26 | 0] = q4 >>> 16, C3[I7 + 27 | 0] = q4 >>> 24, C3[I7 + 28 | 0] = gA2, C3[I7 + 29 | 0] = gA2 >>> 8, C3[I7 + 30 | 0] = gA2 >>> 16, C3[I7 + 31 | 0] = gA2 >>> 24, gA2 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, I7 = fA2 ^ (i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24) ^ _A(j2 ^ cA2, z2 ^ rA2, 1), C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, I7 = k4 ^ t3 ^ gA2, C3[A8 + 44 | 0] = I7, C3[A8 + 45 | 0] = I7 >>> 8, C3[A8 + 46 | 0] = I7 >>> 16, C3[A8 + 47 | 0] = I7 >>> 24, j2 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24, I7 = BA2 ^ (i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24) ^ _A(V2 ^ wA2, r4 ^ aA2, 1), C3[A8 + 56 | 0] = I7, C3[A8 + 57 | 0] = I7 >>> 8, C3[A8 + 58 | 0] = I7 >>> 16, C3[A8 + 59 | 0] = I7 >>> 24, I7 = hA2 ^ t3 ^ j2, C3[A8 + 60 | 0] = I7, C3[A8 + 61 | 0] = I7 >>> 8, C3[A8 + 62 | 0] = I7 >>> 16, C3[A8 + 63 | 0] = I7 >>> 24, j2 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24, I7 = iA2 ^ (i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24) ^ _A(oA2 ^ pA2, c4 ^ _4, 1), C3[A8 + 48 | 0] = I7, C3[A8 + 49 | 0] = I7 >>> 8, C3[A8 + 50 | 0] = I7 >>> 16, C3[A8 + 51 | 0] = I7 >>> 24, I7 = s4 ^ t3 ^ j2, C3[A8 + 52 | 0] = I7, C3[A8 + 53 | 0] = I7 >>> 8, C3[A8 + 54 | 0] = I7 >>> 16, C3[A8 + 55 | 0] = I7 >>> 24; + } + function k3(A8, I7, g6, B4, Q4, o4, c4) { + var D4, a4, y4, f4, e4, w4, h4, k4, n4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, R4, L4, x4, u4, m4, q4, l3, z2, j2, X2, O2, T2, V2, $2, AA2, IA2, gA2, CA2, BA2, QA2, EA2, iA2, oA2, cA2, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, eA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, SA2 = 0, NA2 = 0, KA2 = 0, _A2 = 0, pA2 = 0, HA2 = 0, GA2 = 0, JA2 = 0, YA2 = 0, UA2 = 0, dA2 = 0, bA2 = 0, vA2 = 0, RA2 = 0, LA2 = 0, xA2 = 0, uA2 = 0, qA2 = 0, lA2 = 0, zA2 = 0, jA2 = 0, XA2 = 0, OA2 = 0, TA2 = 0, VA2 = 0, ZA2 = 0, WA2 = 0, $A2 = 0, AI2 = 0, II2 = 0, gI2 = 0, CI2 = 0, BI2 = 0, QI2 = 0; + return r3 = y4 = r3 - 560 | 0, MA(yA2 = y4 + 352 | 0), c4 && W(yA2, 35120, 34, 0), FA(y4 + 288 | 0, o4, 32, 0), W(wA2 = y4 + 352 | 0, y4 + 320 | 0, 32, 0), W(wA2, g6, B4, Q4), v3(wA2, tA2 = y4 + 224 | 0), kA2 = i3[(aA2 = o4) + 32 | 0] | i3[aA2 + 33 | 0] << 8 | i3[aA2 + 34 | 0] << 16 | i3[aA2 + 35 | 0] << 24, nA2 = i3[aA2 + 36 | 0] | i3[aA2 + 37 | 0] << 8 | i3[aA2 + 38 | 0] << 16 | i3[aA2 + 39 | 0] << 24, fA2 = i3[aA2 + 40 | 0] | i3[aA2 + 41 | 0] << 8 | i3[aA2 + 42 | 0] << 16 | i3[aA2 + 43 | 0] << 24, DA2 = i3[aA2 + 44 | 0] | i3[aA2 + 45 | 0] << 8 | i3[aA2 + 46 | 0] << 16 | i3[aA2 + 47 | 0] << 24, yA2 = i3[aA2 + 48 | 0] | i3[aA2 + 49 | 0] << 8 | i3[aA2 + 50 | 0] << 16 | i3[aA2 + 51 | 0] << 24, o4 = i3[aA2 + 52 | 0] | i3[aA2 + 53 | 0] << 8 | i3[aA2 + 54 | 0] << 16 | i3[aA2 + 55 | 0] << 24, eA2 = i3[aA2 + 60 | 0] | i3[aA2 + 61 | 0] << 8 | i3[aA2 + 62 | 0] << 16 | i3[aA2 + 63 | 0] << 24, aA2 = i3[aA2 + 56 | 0] | i3[aA2 + 57 | 0] << 8 | i3[aA2 + 58 | 0] << 16 | i3[aA2 + 59 | 0] << 24, C3[A8 + 56 | 0] = aA2, C3[A8 + 57 | 0] = aA2 >>> 8, C3[A8 + 58 | 0] = aA2 >>> 16, C3[A8 + 59 | 0] = aA2 >>> 24, C3[A8 + 60 | 0] = eA2, C3[A8 + 61 | 0] = eA2 >>> 8, C3[A8 + 62 | 0] = eA2 >>> 16, C3[A8 + 63 | 0] = eA2 >>> 24, C3[A8 + 48 | 0] = yA2, C3[A8 + 49 | 0] = yA2 >>> 8, C3[A8 + 50 | 0] = yA2 >>> 16, C3[A8 + 51 | 0] = yA2 >>> 24, C3[A8 + 52 | 0] = o4, C3[A8 + 53 | 0] = o4 >>> 8, C3[A8 + 54 | 0] = o4 >>> 16, C3[A8 + 55 | 0] = o4 >>> 24, C3[A8 + 40 | 0] = fA2, C3[A8 + 41 | 0] = fA2 >>> 8, C3[A8 + 42 | 0] = fA2 >>> 16, C3[A8 + 43 | 0] = fA2 >>> 24, C3[A8 + 44 | 0] = DA2, C3[A8 + 45 | 0] = DA2 >>> 8, C3[A8 + 46 | 0] = DA2 >>> 16, C3[A8 + 47 | 0] = DA2 >>> 24, C3[0 | (o4 = A8 + 32 | 0)] = kA2, C3[o4 + 1 | 0] = kA2 >>> 8, C3[o4 + 2 | 0] = kA2 >>> 16, C3[o4 + 3 | 0] = kA2 >>> 24, C3[o4 + 4 | 0] = nA2, C3[o4 + 5 | 0] = nA2 >>> 8, C3[o4 + 6 | 0] = nA2 >>> 16, C3[o4 + 7 | 0] = nA2 >>> 24, s3(tA2), Z(y4, tA2), mA(A8, y4), MA(wA2), c4 && W(wA2, 35120, 34, 0), W(c4 = y4 + 352 | 0, A8, 64, 0), W(c4, g6, B4, Q4), v3(c4, rA2 = y4 + 160 | 0), s3(rA2), C3[y4 + 288 | 0] = 248 & i3[y4 + 288 | 0], C3[y4 + 319 | 0] = 63 & i3[y4 + 319 | 0] | 64, g6 = i3[23 + (A8 = a4 = y4 + 288 | 0) | 0], fA2 = PA(f4 = i3[A8 + 21 | 0] | i3[A8 + 22 | 0] << 8 | g6 << 16 & 2031616, 0, e4 = (i3[rA2 + 28 | 0] | i3[rA2 + 29 | 0] << 8 | i3[rA2 + 30 | 0] << 16 | i3[rA2 + 31 | 0] << 24) >>> 7 | 0, 0), yA2 = t3, g6 = (A8 = i3[rA2 + 27 | 0]) >>> 24 | 0, Q4 = A8 << 8 | (DA2 = i3[rA2 + 23 | 0] | i3[rA2 + 24 | 0] << 8 | i3[rA2 + 25 | 0] << 16 | i3[rA2 + 26 | 0] << 24) >>> 24, A8 = PA(w4 = 2097151 & ((3 & (nA2 = (A8 = (B4 = i3[rA2 + 28 | 0]) >>> 16 | 0) | g6)) << 30 | (g6 = (B4 <<= 16) | Q4) >>> 2), 0, h4 = (c4 = i3[a4 + 23 | 0] | i3[a4 + 24 | 0] << 8 | i3[a4 + 25 | 0] << 16 | i3[a4 + 26 | 0] << 24) >>> 5 & 2097151, 0), g6 = t3 + yA2 | 0, B4 = A8 >>> 0 > (Q4 = A8 + fA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(k4 = (g6 = i3[rA2 + 23 | 0]) << 16 & 2031616 | i3[rA2 + 21 | 0] | i3[rA2 + 22 | 0] << 8, 0, n4 = (i3[a4 + 28 | 0] | i3[a4 + 29 | 0] << 8 | i3[a4 + 30 | 0] << 16 | i3[a4 + 31 | 0] << 24) >>> 7 | 0, 0), B4 = t3 + B4 | 0, yA2 = g6 = A8 + Q4 | 0, Q4 = A8 >>> 0 > g6 >>> 0 ? B4 + 1 | 0 : B4, B4 = (A8 = i3[a4 + 27 | 0]) >>> 24 | 0, c4 = A8 << 8 | c4 >>> 24, A8 = PA(F4 = 2097151 & ((3 & (B4 |= g6 = (A8 = i3[a4 + 28 | 0]) >>> 16 | 0)) << 30 | (g6 = (A8 <<= 16) | c4) >>> 2), 0, S4 = DA2 >>> 5 & 2097151, 0), g6 = t3 + Q4 | 0, aA2 = B4 = A8 + yA2 | 0, Q4 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, DA2 = PA(h4, 0, S4, 0), yA2 = t3, g6 = (A8 = i3[a4 + 19 | 0]) >>> 24 | 0, c4 = A8 << 8 | (HA2 = i3[a4 + 15 | 0] | i3[a4 + 16 | 0] << 8 | i3[a4 + 17 | 0] << 16 | i3[a4 + 18 | 0] << 24) >>> 24, B4 = g6, g6 = PA(M4 = (7 & (B4 |= g6 = (A8 = i3[a4 + 20 | 0]) >>> 16 | 0)) << 29 | (g6 = (A8 <<= 16) | c4) >>> 3, nA2 = B4 >>> 3 | 0, e4, 0), A8 = t3 + yA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, c4 = (g6 = PA(f4, 0, w4, 0)) + B4 | 0, B4 = t3 + A8 | 0, g6 = g6 >>> 0 > (DA2 = c4) >>> 0 ? B4 + 1 | 0 : B4, B4 = (A8 = i3[rA2 + 19 | 0]) >>> 24 | 0, yA2 = A8 << 8 | (KA2 = i3[rA2 + 15 | 0] | i3[rA2 + 16 | 0] << 8 | i3[rA2 + 17 | 0] << 16 | i3[rA2 + 18 | 0] << 24) >>> 24, A8 = PA(N4 = (7 & (fA2 = (A8 = (c4 = i3[rA2 + 20 | 0]) >>> 16 | 0) | B4)) << 29 | (B4 = (c4 <<= 16) | yA2) >>> 3, K4 = fA2 >>> 3 | 0, n4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(k4, 0, F4, 0), g6 = t3 + g6 | 0, kA2 = g6 = A8 >>> 0 > (tA2 = A8 + B4 | 0) >>> 0 ? g6 + 1 | 0 : g6, sA2 = A8 = g6 - ((tA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >>> 21 | 0) + Q4 | 0, DA2 = B4 = (A8 = (2097151 & A8) << 11 | (fA2 = tA2 - -1048576 | 0) >>> 21) >>> 0 > (aA2 = A8 + aA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, NA2 = A8 = B4 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, eA2 = (2097151 & A8) << 11 | (yA2 = aA2 - -1048576 | 0) >>> 21, c4 = A8 >>> 21 | 0, A8 = PA(n4, 0, S4, 0), g6 = t3, B4 = A8, A8 = PA(e4, 0, h4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, SA2 = (A8 = B4) + (B4 = PA(w4, 0, F4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > SA2 >>> 0 ? A8 + 1 | 0 : A8, wA2 = SA2 - (g6 = -2097152 & (B4 = SA2 - -1048576 | 0)) | 0, g6 = (A8 - ((131071 & (Q4 = A8 - ((SA2 >>> 0 < 4293918720) - 1 | 0) | 0)) + (g6 >>> 0 > SA2 >>> 0) | 0) | 0) + c4 | 0, m4 = g6 = (A8 = eA2 + wA2 | 0) >>> 0 < wA2 >>> 0 ? g6 + 1 | 0 : g6, q4 = A8, wA2 = PA(A8, g6, 470296, 0), eA2 = t3, g6 = PA(e4, 0, F4, 0), A8 = t3, c4 = g6, g6 = PA(w4, 0, n4, 0), A8 = t3 + A8 | 0, g6 = g6 >>> 0 > (c4 = c4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = Q4 >>> 21 | 0, Q4 = (2097151 & Q4) << 11 | B4 >>> 21, B4 = A8 + g6 | 0, UA2 = Q4 = (B4 = Q4 >>> 0 > (c4 = Q4 + c4 | 0) >>> 0 ? B4 + 1 | 0 : B4) - ((c4 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = c4 - (g6 = -2097152 & (YA2 = c4 - -1048576 | 0)) | 0, l3 = c4 = B4 - ((131071 & Q4) + (g6 >>> 0 > c4 >>> 0) | 0) | 0, z2 = g6 = aA2 - (B4 = -2097152 & yA2) | 0, j2 = Q4 = DA2 - ((B4 >>> 0 > aA2 >>> 0) + NA2 | 0) | 0, X2 = A8, B4 = PA(A8, c4, 666643, 0), A8 = t3 + eA2 | 0, A8 = B4 >>> 0 > (c4 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(g6, Q4, 654183, 0), g6 = t3 + A8 | 0, hA2 = Q4 = B4 + c4 | 0, yA2 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, SA2 = tA2 - (A8 = -2097152 & fA2) | 0, sA2 = kA2 - ((A8 >>> 0 > tA2 >>> 0) + sA2 | 0) | 0, g6 = PA(w4, 0, M4, nA2), B4 = t3, Q4 = (A8 = g6) + (g6 = PA(_4 = HA2 >>> 6 & 2097151, 0, e4, 0)) | 0, A8 = t3 + B4 | 0, A8 = g6 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(h4, 0, k4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(f4, 0, S4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(n4, 0, p4 = KA2 >>> 6 & 2097151, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(F4, 0, N4, K4), g6 = t3 + A8 | 0, tA2 = Q4 = B4 + Q4 | 0, c4 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[a4 + 14 | 0]) >>> 24 | 0, Q4 = A8 << 8 | (kA2 = i3[a4 + 10 | 0] | i3[a4 + 11 | 0] << 8 | i3[a4 + 12 | 0] << 16 | i3[a4 + 13 | 0] << 24) >>> 24, g6 = PA(H4 = 2097151 & ((1 & (g6 |= A8 = (B4 = i3[a4 + 15 | 0]) >>> 16 | 0)) << 31 | (A8 = (B4 <<= 16) | Q4) >>> 1), 0, e4, 0), A8 = t3, B4 = g6, g6 = PA(w4, 0, _4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(S4, 0, M4, nA2)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(h4, 0, N4, K4), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(f4, 0, k4, 0), g6 = t3 + g6 | 0, fA2 = B4 = A8 + Q4 | 0, Q4 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[rA2 + 14 | 0]) >>> 24 | 0, DA2 = A8 << 8 | (aA2 = i3[rA2 + 10 | 0] | i3[rA2 + 11 | 0] << 8 | i3[rA2 + 12 | 0] << 16 | i3[rA2 + 13 | 0] << 24) >>> 24, B4 = g6, g6 = (A8 = i3[rA2 + 15 | 0]) >>> 16 | 0, g6 = PA(G4 = 2097151 & ((1 & (g6 |= B4)) << 31 | (A8 = A8 << 16 | DA2) >>> 1), 0, n4, 0), A8 = t3 + Q4 | 0, A8 = g6 >>> 0 > (B4 = g6 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(F4, 0, p4, 0), A8 = t3 + A8 | 0, DA2 = A8 = g6 >>> 0 > (fA2 = g6 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, dA2 = g6 = A8 - ((fA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >>> 21 | 0) + c4 | 0, eA2 = B4 = (g6 = (2097151 & g6) << 11 | (wA2 = fA2 - -1048576 | 0) >>> 21) >>> 0 > (NA2 = g6 + tA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, GA2 = g6 = B4 - ((NA2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >>> 21 | 0) + sA2 | 0, O2 = A8 = (g6 = (B4 = (2097151 & g6) << 11 | (tA2 = NA2 - -1048576 | 0) >>> 21) + SA2 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, T2 = g6, A8 = PA(g6, A8, -997805, -1), g6 = t3 + yA2 | 0, hA2 = B4 = A8 + hA2 | 0, yA2 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, SA2 = (RA2 = i3[23 + (D4 = y4 + 224 | 0) | 0] | i3[D4 + 24 | 0] << 8 | i3[D4 + 25 | 0] << 16 | i3[D4 + 26 | 0] << 24) >>> 5 & 2097151, B4 = PA(J4 = (A8 = i3[a4 + 2 | 0]) << 16 & 2031616 | i3[0 | a4] | i3[a4 + 1 | 0] << 8, 0, S4, 0), g6 = t3, Q4 = (A8 = PA(k4, 0, Y4 = (c4 = i3[a4 + 2 | 0] | i3[a4 + 3 | 0] << 8 | i3[a4 + 4 | 0] << 16 | i3[a4 + 5 | 0] << 24) >>> 5 & 2097151, 0)) + B4 | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(U4 = (i3[a4 + 7 | 0] | i3[a4 + 8 | 0] << 8 | i3[a4 + 9 | 0] << 16 | i3[a4 + 10 | 0] << 24) >>> 7 & 2097151, 0, p4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(G4, 0, d4 = kA2 >>> 4 & 2097151, 0), A8 = t3 + g6 | 0, kA2 = Q4 = B4 + Q4 | 0, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, c4 = (g6 = i3[a4 + 6 | 0]) << 8 | c4 >>> 24, B4 = A8 = g6 >>> 24 | 0, g6 = (A8 = i3[a4 + 7 | 0]) >>> 16 | 0, g6 = PA(b4 = 2097151 & ((3 & (g6 |= B4)) << 30 | (A8 = A8 << 16 | c4) >>> 2), 0, N4, K4), A8 = t3 + Q4 | 0, A8 = g6 >>> 0 > (B4 = g6 + kA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(_4, 0, P4 = (i3[rA2 + 7 | 0] | i3[rA2 + 8 | 0] << 8 | i3[rA2 + 9 | 0] << 16 | i3[rA2 + 10 | 0] << 24) >>> 7 & 2097151, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(H4, 0, JA2 = aA2 >>> 4 & 2097151, 0), A8 = t3 + B4 | 0, c4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = (g6 = i3[rA2 + 6 | 0]) >>> 24 | 0, kA2 = g6 << 8 | (aA2 = i3[rA2 + 2 | 0] | i3[rA2 + 3 | 0] << 8 | i3[rA2 + 4 | 0] << 16 | i3[rA2 + 5 | 0] << 24) >>> 24, g6 = A8, A8 = PA(M4, nA2, R4 = 2097151 & ((3 & (g6 |= B4 = (A8 = i3[rA2 + 7 | 0]) >>> 16 | 0)) << 30 | (A8 = A8 << 16 | kA2) >>> 2), 0), g6 = t3 + c4 | 0, g6 = A8 >>> 0 > (B4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = B4, B4 = PA(L4 = (A8 = i3[rA2 + 2 | 0]) << 16 & 2031616 | i3[0 | rA2] | i3[rA2 + 1 | 0] << 8, 0, h4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = Q4 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(f4, 0, x4 = aA2 >>> 5 & 2097151, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, kA2 = B4 = B4 + SA2 | 0, c4 = g6 = g6 >>> 0 > B4 >>> 0 ? A8 + 1 | 0 : A8, Q4 = i3[D4 + 21 | 0] | i3[D4 + 22 | 0] << 8, A8 = PA(k4, 0, J4, 0), g6 = t3, aA2 = (B4 = A8) + (A8 = PA(N4, K4, Y4, 0)) | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > aA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(G4, 0, U4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (aA2 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(d4, 0, JA2, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, aA2 = (A8 = B4) + (B4 = PA(p4, 0, b4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > aA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(_4, 0, R4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + aA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, aA2 = (g6 = PA(H4, 0, P4, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > aA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(M4, nA2, x4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (aA2 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(f4, 0, L4, 0), g6 = t3 + g6 | 0, A8 = A8 >>> 0 > (B4 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, g6 = (g6 = B4) >>> 0 > (B4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = B4, B4 = (A8 = i3[D4 + 23 | 0]) << 16 & 2031616, A8 = g6, B4 = A8 = B4 >>> 0 > (Q4 = Q4 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, rA2 = A8 = A8 - ((Q4 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (g6 = A8 >>> 21 | 0) + c4 | 0, A8 = (g6 = (c4 = kA2 = (A8 = (2097151 & A8) << 11 | (aA2 = Q4 - -1048576 | 0) >>> 21) + kA2 | 0) >>> 0 < A8 >>> 0 ? g6 + 1 | 0 : g6) + yA2 | 0, A8 = (yA2 = c4 + hA2 | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, KA2 = c4 - -1048576 | 0, _A2 = c4 = g6 - ((c4 >>> 0 < 4293918720) - 1 | 0) | 0, pA2 = yA2 - (g6 = -2097152 & KA2) | 0, bA2 = A8 - ((g6 >>> 0 > yA2 >>> 0) + c4 | 0) | 0, kA2 = Q4, yA2 = B4, A8 = PA(z2, j2, 470296, 0), g6 = t3, B4 = A8, A8 = PA(q4, m4, 666643, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(T2, O2, 654183, 0)) | 0, A8 = t3 + g6 | 0, HA2 = Q4, c4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(N4, K4, J4, 0), A8 = t3, B4 = g6, g6 = PA(p4, 0, Y4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(U4, 0, JA2, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(d4, 0, P4, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(G4, 0, b4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(_4, 0, x4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(H4, 0, R4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(M4, nA2, L4, 0)) | 0, g6 = t3 + A8 | 0, SA2 = Q4, B4 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[D4 + 19 | 0]) >>> 24 | 0, sA2 = A8 << 8 | (hA2 = i3[D4 + 15 | 0] | i3[D4 + 16 | 0] << 8 | i3[D4 + 17 | 0] << 16 | i3[D4 + 18 | 0] << 24) >>> 24, B4 = ((vA2 = (A8 = (Q4 = i3[D4 + 20 | 0]) >>> 16 | 0) | g6) >>> 3 | 0) + B4 | 0, SA2 = Q4 = (g6 = (7 & vA2) << 29 | (g6 = (Q4 <<= 16) | sA2) >>> 3) + SA2 | 0, Q4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, sA2 = hA2 >>> 6 & 2097151, A8 = PA(p4, 0, J4, 0), g6 = t3, B4 = A8, A8 = PA(G4, 0, Y4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, hA2 = (A8 = B4) + (B4 = PA(U4, 0, P4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > hA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(d4, 0, R4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (hA2 = B4 + hA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(b4, 0, JA2, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (hA2 = B4 + hA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(_4, 0, L4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (hA2 = g6 + hA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(H4, 0, x4, 0), g6 = t3 + B4 | 0, A8 = A8 >>> 0 > (hA2 = A8 + hA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, OA2 = A8 = (xA2 = hA2 + sA2 | 0) >>> 0 < hA2 >>> 0 ? A8 + 1 | 0 : A8, II2 = A8 = A8 - ((xA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (jA2 = xA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + Q4 | 0, VA2 = A8 = B4 >>> 0 > (TA2 = B4 + SA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, gI2 = A8 = A8 - ((TA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (qA2 = TA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + c4 | 0, g6 = (B4 >>> 0 > (Q4 = B4 + HA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) + yA2 | 0, yA2 = (B4 = Q4 + kA2 | 0) - (A8 = -2097152 & aA2) | 0, rA2 = A8 = (g6 = B4 >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + rA2 | 0) | 0, CI2 = A8 = A8 - ((yA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (lA2 = yA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + bA2 | 0, Q4 = A8 = B4 >>> 0 > (c4 = B4 + pA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, AI2 = A8 = A8 - ((c4 >>> 0 < 4293918720) - 1 | 0) | 0, zA2 = (2097151 & A8) << 11 | (HA2 = c4 - -1048576 | 0) >>> 21, kA2 = A8 >> 21, vA2 = NA2 - (A8 = -2097152 & tA2) | 0, GA2 = eA2 - ((A8 >>> 0 > NA2 >>> 0) + GA2 | 0) | 0, A8 = PA(e4, 0, n4, 0), XA2 = g6 = t3, pA2 = A8, hA2 = A8 - -1048576 | 0, uA2 = g6 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, V2 = A8 = g6 >>> 21 | 0, A8 = PA(u4 = (2097151 & g6) << 11 | hA2 >>> 21, A8, -683901, -1), g6 = t3 + DA2 | 0, g6 = A8 >>> 0 > (B4 = A8 + fA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, tA2 = B4 - (A8 = -2097152 & wA2) | 0, aA2 = g6 - ((A8 >>> 0 > B4 >>> 0) + dA2 | 0) | 0, g6 = PA(S4, 0, _4, 0), A8 = t3, B4 = g6, g6 = PA(e4, 0, d4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(w4, 0, H4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, DA2 = (g6 = B4) + (B4 = PA(k4, 0, M4, nA2)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > DA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(h4, 0, p4, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(f4, 0, N4, K4), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(n4, 0, JA2, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(F4, 0, G4, 0), A8 = t3 + A8 | 0, fA2 = B4 = g6 + DA2 | 0, DA2 = g6 >>> 0 > B4 >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(w4, 0, d4, 0), g6 = t3, B4 = A8, A8 = PA(e4, 0, U4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, eA2 = (A8 = PA(k4, 0, _4, 0)) + B4 | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > eA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(S4, 0, H4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (eA2 = A8 + eA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(M4, nA2, N4, K4), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (eA2 = B4 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(h4, 0, G4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, eA2 = (g6 = B4) + (B4 = PA(f4, 0, p4, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > eA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(n4, 0, P4, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (eA2 = A8 + eA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(F4, 0, JA2, 0), g6 = t3 + B4 | 0, sA2 = g6 = A8 >>> 0 > (SA2 = A8 + eA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, WA2 = A8 = g6 - ((SA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (2097151 & A8) << 11 | (NA2 = SA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + DA2 | 0, wA2 = A8 = g6 >>> 0 > (dA2 = g6 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, LA2 = A8 = A8 - ((dA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (B4 = A8 >>> 21 | 0) + aA2 | 0, tA2 = g6 = (A8 = (2097151 & A8) << 11 | (eA2 = dA2 - -1048576 | 0) >>> 21) >>> 0 > (bA2 = A8 + tA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, ZA2 = A8 = g6 - ((bA2 >>> 0 < 4293918720) - 1 | 0) | 0, DA2 = (2097151 & A8) << 11 | (aA2 = bA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + GA2 | 0, $2 = A8 = (g6 = DA2 + vA2 | 0) >>> 0 < DA2 >>> 0 ? A8 + 1 | 0 : A8, AA2 = g6, A8 = PA(g6, A8, -683901, -1), g6 = t3 + kA2 | 0, zA2 = B4 = A8 + zA2 | 0, kA2 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(w4, 0, J4, 0), g6 = t3, B4 = A8, A8 = PA(S4, 0, Y4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, DA2 = (A8 = B4) + (B4 = PA(N4, K4, U4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(p4, 0, d4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(k4, 0, b4, 0), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(_4, 0, JA2, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(H4, 0, G4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, DA2 = (A8 = B4) + (B4 = PA(M4, nA2, P4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(h4, 0, x4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(f4, 0, R4, 0), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(F4, 0, L4, 0), g6 = t3 + A8 | 0, GA2 = DA2 = B4 + DA2 | 0, B4 = B4 >>> 0 > DA2 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[D4 + 27 | 0]) >>> 24 | 0, fA2 = A8 << 8 | RA2 >>> 24, DA2 = 2097151 & ((3 & (g6 |= A8 = (DA2 = i3[D4 + 28 | 0]) >>> 16 | 0)) << 30 | (A8 = (DA2 <<= 16) | fA2) >>> 2), g6 = B4, fA2 = A8 = DA2 + GA2 | 0, DA2 = A8 >>> 0 < DA2 >>> 0 ? g6 + 1 | 0 : g6, vA2 = PA(X2, l3, 470296, 0), GA2 = t3, A8 = (B4 = (2097151 & UA2) << 11 | YA2 >>> 21) + (pA2 - (g6 = -2097152 & hA2) | 0) | 0, g6 = XA2 - ((524287 & uA2) + (g6 >>> 0 > pA2 >>> 0) | 0) + (UA2 >>> 21) | 0, IA2 = g6 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, gA2 = A8, g6 = PA(A8, g6, 666643, 0), A8 = t3 + GA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + vA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, hA2 = (g6 = PA(q4, m4, 654183, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > hA2 >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(z2, j2, -997805, -1), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (hA2 = g6 + hA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(T2, O2, 136657, 0), g6 = t3 + A8 | 0, KA2 = (A8 = (2097151 & _A2) << 11 | KA2 >>> 21) + (hA2 = B4 + hA2 | 0) | 0, g6 = (_A2 >>> 21 | 0) + (B4 >>> 0 > hA2 >>> 0 ? g6 + 1 | 0 : g6) | 0, uA2 = hA2 = DA2 - ((fA2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 >>> 0 > KA2 >>> 0 ? g6 + 1 | 0 : g6) + DA2 | 0, g6 = (DA2 = fA2 + KA2 | 0) - (B4 = -2097152 & (XA2 = fA2 - -1048576 | 0)) | 0, B4 = (A8 = (A8 = DA2 >>> 0 < KA2 >>> 0 ? A8 + 1 | 0 : A8) - ((B4 >>> 0 > DA2 >>> 0) + hA2 | 0) | 0) + kA2 | 0, vA2 = DA2 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, pA2 = (B4 = (fA2 = g6 + zA2 | 0) >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4) - (((g6 = -2097152 & (GA2 = g6 - -1048576 | 0)) >>> 0 > fA2 >>> 0) + DA2 | 0) | 0, RA2 = A8 = fA2 - g6 | 0, DA2 = c4, c4 = Q4, $A2 = bA2 - (A8 = -2097152 & aA2) | 0, hA2 = tA2 - ((A8 >>> 0 > bA2 >>> 0) + ZA2 | 0) | 0, A8 = PA(gA2, IA2, -683901, -1), g6 = t3, Q4 = (B4 = A8) + (A8 = PA(u4, V2, 136657, 0)) | 0, B4 = t3 + g6 | 0, g6 = wA2 + (A8 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4) | 0, eA2 = (B4 = Q4 + dA2 | 0) - (A8 = -2097152 & eA2) | 0, tA2 = (g6 = B4 >>> 0 < dA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + LA2 | 0) | 0, g6 = PA(u4, V2, -997805, -1), A8 = t3 + sA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + SA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(gA2, IA2, 136657, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(X2, l3, -683901, -1), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, aA2 = Q4 - (A8 = -2097152 & NA2) | 0, kA2 = g6 - ((A8 >>> 0 > Q4 >>> 0) + WA2 | 0) | 0, g6 = PA(S4, 0, d4, 0), A8 = t3, B4 = g6, g6 = PA(w4, 0, U4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(e4, 0, b4, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(N4, K4, _4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(k4, 0, H4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(M4, nA2, p4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(h4, 0, JA2, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(f4, 0, G4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(n4, 0, R4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(F4, 0, P4, 0), A8 = t3 + g6 | 0, fA2 = Q4 = B4 + Q4 | 0, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(S4, 0, U4, 0), g6 = t3, B4 = A8, A8 = PA(e4, 0, Y4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, wA2 = (A8 = B4) + (B4 = PA(k4, 0, d4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > wA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(w4, 0, b4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (wA2 = g6 + wA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(_4, 0, p4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (wA2 = A8 + wA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(N4, K4, H4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (wA2 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(M4, nA2, G4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (wA2 = B4 + wA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(h4, 0, P4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (wA2 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(f4, 0, JA2, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (wA2 = g6 + wA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, wA2 = (A8 = PA(n4, 0, x4, 0)) + wA2 | 0, g6 = t3 + B4 | 0, B4 = PA(F4, 0, R4, 0), A8 = t3 + (A8 >>> 0 > wA2 >>> 0 ? g6 + 1 | 0 : g6) | 0, bA2 = A8 = B4 >>> 0 > (ZA2 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, BA2 = A8 = A8 - ((ZA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (UA2 = ZA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + Q4 | 0, YA2 = A8 = B4 >>> 0 > (zA2 = B4 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, QA2 = A8 = A8 - ((zA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (_A2 = zA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + kA2 | 0, KA2 = A8 = B4 >>> 0 > (dA2 = B4 + aA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, EA2 = A8 = A8 - ((dA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (sA2 = dA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + tA2 | 0, Q4 = A8 = B4 >>> 0 > (aA2 = B4 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, tA2 = A8 = A8 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, kA2 = (2097151 & A8) << 11 | (B4 = aA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + hA2 | 0, WA2 = A8 = (fA2 = kA2 + $A2 | 0) >>> 0 < kA2 >>> 0 ? A8 + 1 | 0 : A8, LA2 = fA2, A8 = PA(fA2, A8, -683901, -1), g6 = t3, fA2 = A8, A8 = PA(AA2, $2, 136657, 0), g6 = t3 + g6 | 0, A8 = (A8 >>> 0 > (fA2 = fA2 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6) + c4 | 0, BI2 = (c4 = DA2 + fA2 | 0) - (g6 = -2097152 & HA2) | 0, QI2 = (A8 = c4 >>> 0 < fA2 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 > c4 >>> 0) + AI2 | 0) | 0, kA2 = yA2, fA2 = rA2, yA2 = PA(LA2, WA2, 136657, 0), c4 = t3, $A2 = A8 = aA2 - (g6 = -2097152 & B4) | 0, CA2 = Q4 = Q4 - ((g6 >>> 0 > aA2 >>> 0) + tA2 | 0) | 0, B4 = PA(AA2, $2, -997805, -1), g6 = t3 + c4 | 0, g6 = B4 >>> 0 > (yA2 = B4 + yA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(A8, Q4, -683901, -1), A8 = t3 + g6 | 0, AI2 = Q4 = B4 + yA2 | 0, DA2 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(T2, O2, 470296, 0), g6 = t3, Q4 = (B4 = A8) + (A8 = PA(z2, j2, 666643, 0)) | 0, B4 = t3 + g6 | 0, g6 = VA2 + (A8 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4) | 0, HA2 = A8 = Q4 + TA2 | 0, c4 = g6 = A8 >>> 0 < TA2 >>> 0 ? g6 + 1 | 0 : g6, g6 = PA(T2, O2, 666643, 0), A8 = t3 + OA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + xA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, eA2 = B4 - (g6 = -2097152 & jA2) | 0, SA2 = A8 - ((g6 >>> 0 > B4 >>> 0) + II2 | 0) | 0, g6 = PA(G4, 0, J4, 0), A8 = t3, B4 = g6, g6 = PA(Y4, 0, JA2, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(U4, 0, R4, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(d4, 0, x4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(b4, 0, P4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(H4, 0, L4, 0), g6 = t3 + B4 | 0, aA2 = Q4 = A8 + Q4 | 0, Q4 = A8 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[D4 + 14 | 0]) >>> 24 | 0, yA2 = A8 << 8 | (tA2 = i3[D4 + 10 | 0] | i3[D4 + 11 | 0] << 8 | i3[D4 + 12 | 0] << 16 | i3[D4 + 13 | 0] << 24) >>> 24, g6 = 2097151 & ((1 & (g6 |= B4 = (A8 = i3[D4 + 15 | 0]) >>> 16 | 0)) << 31 | (A8 = yA2 | A8 << 16) >>> 1), A8 = Q4, aA2 = B4 = g6 + aA2 | 0, Q4 = g6 >>> 0 > B4 >>> 0 ? A8 + 1 | 0 : A8, yA2 = tA2 >>> 4 & 2097151, A8 = PA(J4, 0, JA2, 0), g6 = t3, B4 = A8, A8 = PA(Y4, 0, P4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(U4, 0, x4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + B4 | 0) >>> 0 ? g6 + 1 | 0 : g6, tA2 = (A8 = B4) + (B4 = PA(d4, 0, L4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > tA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(b4, 0, R4, 0), B4 = t3 + A8 | 0, A8 = g6 >>> 0 > (tA2 = g6 + tA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, rA2 = A8 = (jA2 = yA2 + tA2 | 0) >>> 0 < tA2 >>> 0 ? A8 + 1 | 0 : A8, iA2 = A8 = A8 - ((jA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (B4 = A8 >>> 21 | 0) + Q4 | 0, NA2 = g6 = (A8 = (2097151 & A8) << 11 | (hA2 = jA2 - -1048576 | 0) >>> 21) >>> 0 > (VA2 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, oA2 = A8 = g6 - ((VA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (2097151 & A8) << 11 | (wA2 = VA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + SA2 | 0, tA2 = A8 = g6 >>> 0 > (eA2 = g6 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, cA2 = A8 = A8 - ((eA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (B4 = A8 >> 21) + c4 | 0, II2 = g6 = (g6 = (A8 = (2097151 & A8) << 11 | (aA2 = eA2 - -1048576 | 0) >>> 21) >>> 0 > (Q4 = A8 + HA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) - (((B4 = -2097152 & qA2) >>> 0 > Q4 >>> 0) + gI2 | 0) | 0, qA2 = A8 = Q4 - B4 | 0, yA2 = A8 - -1048576 | 0, gI2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >> 21) + DA2 | 0, g6 = ((A8 = (2097151 & A8) << 11 | yA2 >>> 21) >>> 0 > (Q4 = A8 + AI2 | 0) >>> 0 ? B4 + 1 | 0 : B4) + fA2 | 0, xA2 = g6 = (g6 = (A8 = Q4) >>> 0 > (Q4 = Q4 + kA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) - (((B4 = -2097152 & lA2) >>> 0 > Q4 >>> 0) + CI2 | 0) | 0, fA2 = A8 = Q4 - B4 | 0, c4 = A8 - -1048576 | 0, OA2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >> 21) + QI2 | 0, lA2 = A8 = (B4 = (A8 = (2097151 & A8) << 11 | c4 >>> 21) >>> 0 > (DA2 = A8 + BI2 | 0) >>> 0 ? B4 + 1 | 0 : B4) - ((DA2 >>> 0 < 4293918720) - 1 | 0) | 0, HA2 = RA2 - -1048576 | 0, SA2 = pA2 - ((RA2 >>> 0 < 4293918720) - 1 | 0) | 0, kA2 = (2097151 & A8) << 11 | (Q4 = DA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + pA2 | 0, CI2 = (RA2 = kA2 + RA2 | 0) - (g6 = -2097152 & HA2) | 0, BI2 = (kA2 >>> 0 > RA2 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 > RA2 >>> 0) + SA2 | 0) | 0, QI2 = DA2 - (A8 = -2097152 & Q4) | 0, AI2 = B4 - ((A8 >>> 0 > DA2 >>> 0) + lA2 | 0) | 0, TA2 = fA2 - (A8 = -2097152 & c4) | 0, RA2 = xA2 - ((A8 >>> 0 > fA2 >>> 0) + OA2 | 0) | 0, A8 = PA(LA2, WA2, -997805, -1), g6 = t3, B4 = A8, A8 = PA(AA2, $2, 654183, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA($A2, CA2, 136657, 0)) | 0, A8 = t3 + g6 | 0, g6 = II2 + (B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8) | 0, xA2 = (B4 = Q4 + qA2 | 0) - (A8 = -2097152 & yA2) | 0, OA2 = (g6 = B4 >>> 0 < qA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + gI2 | 0) | 0, qA2 = dA2 - (A8 = -2097152 & sA2) | 0, pA2 = KA2 - ((A8 >>> 0 > dA2 >>> 0) + EA2 | 0) | 0, g6 = PA(gA2, IA2, -997805, -1), A8 = t3, B4 = g6, g6 = PA(u4, V2, 654183, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(X2, l3, 136657, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(q4, m4, -683901, -1), B4 = t3 + g6 | 0, g6 = YA2 + (A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4) | 0, sA2 = (B4 = Q4 + zA2 | 0) - (A8 = -2097152 & _A2) | 0, KA2 = (g6 = B4 >>> 0 < zA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + QA2 | 0) | 0, g6 = PA(gA2, IA2, 654183, 0), A8 = t3, B4 = g6, g6 = PA(u4, V2, 470296, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(X2, l3, -997805, -1)) + B4 | 0, B4 = t3 + A8 | 0, g6 = bA2 + (g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4) | 0, g6 = (A8 = Q4 + ZA2 | 0) >>> 0 < ZA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, A8 = PA(q4, m4, 136657, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(z2, j2, -683901, -1)) | 0, A8 = t3 + g6 | 0, yA2 = Q4 - (g6 = -2097152 & UA2) | 0, c4 = (B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 > Q4 >>> 0) + BA2 | 0) | 0, Q4 = (i3[D4 + 28 | 0] | i3[D4 + 29 | 0] << 8 | i3[D4 + 30 | 0] << 16 | i3[D4 + 31 | 0] << 24) >>> 7 | 0, A8 = PA(e4, 0, J4, 0), g6 = t3, DA2 = (B4 = A8) + (A8 = PA(w4, 0, Y4, 0)) | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > DA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(k4, 0, U4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(N4, K4, d4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(S4, 0, b4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(_4, 0, G4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(p4, 0, H4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(M4, nA2, JA2, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(h4, 0, R4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(f4, 0, P4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(n4, 0, L4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(F4, 0, x4, 0), B4 = t3 + A8 | 0, g6 = B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, YA2 = (B4 = (2097151 & uA2) << 11 | XA2 >>> 21) + (A8 = Q4 + DA2 | 0) | 0, A8 = (uA2 >>> 21 | 0) + (g6 = A8 >>> 0 < DA2 >>> 0 ? g6 + 1 | 0 : g6) | 0, kA2 = A8 = B4 >>> 0 > YA2 >>> 0 ? A8 + 1 | 0 : A8, lA2 = g6 = A8 - ((YA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >>> 21 | 0) + c4 | 0, fA2 = B4 = (g6 = (2097151 & g6) << 11 | (nA2 = YA2 - -1048576 | 0) >>> 21) >>> 0 > (_A2 = g6 + yA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, XA2 = g6 = B4 - ((_A2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >> 21) + KA2 | 0, yA2 = A8 = (g6 = (2097151 & g6) << 11 | (DA2 = _A2 - -1048576 | 0) >>> 21) >>> 0 > (sA2 = g6 + sA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, UA2 = g6 = A8 - ((sA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >> 21) + pA2 | 0, uA2 = B4 = (g6 = (Q4 = (2097151 & g6) << 11 | (c4 = sA2 - -1048576 | 0) >>> 21) + qA2 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, pA2 = g6, A8 = PA(g6, B4, -683901, -1), g6 = t3 + OA2 | 0, KA2 = B4 = A8 + xA2 | 0, Q4 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, g6 = PA(AA2, $2, 470296, 0), A8 = t3 + tA2 | 0, A8 = g6 >>> 0 > (eA2 = g6 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(LA2, WA2, 654183, 0), A8 = t3 + (A8 - (((B4 = -2097152 & aA2) >>> 0 > eA2 >>> 0) + cA2 | 0) | 0) | 0, A8 = g6 >>> 0 > (aA2 = g6 + (eA2 - B4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA($A2, CA2, -997805, -1), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (aA2 = B4 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, bA2 = B4 = sA2 - (A8 = -2097152 & c4) | 0, JA2 = yA2 = yA2 - ((A8 >>> 0 > sA2 >>> 0) + UA2 | 0) | 0, aA2 = (c4 = PA(pA2, uA2, 136657, 0)) + aA2 | 0, A8 = t3 + g6 | 0, B4 = PA(B4, yA2, -683901, -1), g6 = t3 + (c4 >>> 0 > aA2 >>> 0 ? A8 + 1 | 0 : A8) | 0, yA2 = g6 = B4 >>> 0 > (tA2 = B4 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, UA2 = A8 = g6 - ((tA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (2097151 & A8) << 11 | (c4 = tA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + Q4 | 0, sA2 = g6 = (A8 = g6 >>> 0 > (aA2 = g6 + KA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, eA2 = (2097151 & g6) << 11 | (Q4 = aA2 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + RA2 | 0, TA2 = KA2 = eA2 + TA2 | 0, KA2 = eA2 >>> 0 > KA2 >>> 0 ? g6 + 1 | 0 : g6, RA2 = aA2 - (g6 = -2097152 & Q4) | 0, ZA2 = A8 - ((g6 >>> 0 > aA2 >>> 0) + sA2 | 0) | 0, xA2 = tA2 - (A8 = -2097152 & c4) | 0, OA2 = yA2 - ((A8 >>> 0 > tA2 >>> 0) + UA2 | 0) | 0, A8 = PA(AA2, $2, 666643, 0), B4 = NA2 + t3 | 0, B4 = (c4 = A8 + VA2 | 0) >>> 0 < VA2 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (A8 = PA(LA2, WA2, 470296, 0)) + (c4 - (g6 = -2097152 & wA2) | 0) | 0, g6 = t3 + (B4 - ((g6 >>> 0 > c4 >>> 0) + oA2 | 0) | 0) | 0, g6 = A8 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, B4 = PA($A2, CA2, 654183, 0), A8 = t3 + g6 | 0, aA2 = Q4 = B4 + Q4 | 0, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, c4 = _A2 - (A8 = -2097152 & DA2) | 0, yA2 = fA2 - ((A8 >>> 0 > _A2 >>> 0) + XA2 | 0) | 0, A8 = PA(gA2, IA2, 470296, 0), g6 = t3, B4 = A8, A8 = PA(u4, V2, 666643, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(X2, l3, 654183, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + B4 | 0) >>> 0 ? g6 + 1 | 0 : g6, DA2 = (A8 = B4) + (B4 = PA(q4, m4, -997805, -1)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(z2, j2, 136657, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, DA2 = (g6 = PA(T2, O2, -683901, -1)) + B4 | 0, B4 = t3 + A8 | 0, g6 = kA2 + (g6 >>> 0 > DA2 >>> 0 ? B4 + 1 | 0 : B4) | 0, _A2 = (B4 = (2097151 & vA2) << 11 | GA2 >>> 21) + ((DA2 = DA2 + YA2 | 0) - (A8 = -2097152 & nA2) | 0) | 0, A8 = ((g6 = DA2 >>> 0 < YA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > DA2 >>> 0) + lA2 | 0) | 0) + (vA2 >> 21) | 0, sA2 = A8 = B4 >>> 0 > _A2 >>> 0 ? A8 + 1 | 0 : A8, qA2 = A8 = A8 - ((_A2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = c4, c4 = (2097151 & A8) << 11 | (wA2 = _A2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + yA2 | 0, UA2 = A8 = (B4 = g6 + c4 | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, YA2 = B4, A8 = PA(B4, A8, -683901, -1), g6 = t3 + Q4 | 0, g6 = A8 >>> 0 > (B4 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(pA2, uA2, -997805, -1)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(bA2, JA2, 136657, 0), B4 = t3 + A8 | 0, GA2 = Q4 = g6 + Q4 | 0, fA2 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, aA2 = jA2 - (A8 = -2097152 & hA2) | 0, kA2 = rA2 - ((A8 >>> 0 > jA2 >>> 0) + iA2 | 0) | 0, g6 = PA(J4, 0, P4, 0), A8 = t3, B4 = g6, g6 = PA(Y4, 0, R4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(U4, 0, L4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(b4, 0, x4, 0)) + B4 | 0, B4 = t3 + A8 | 0, g6 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, nA2 = B4 = (A8 = (i3[D4 + 7 | 0] | i3[D4 + 8 | 0] << 8 | i3[D4 + 9 | 0] << 16 | i3[D4 + 10 | 0] << 24) >>> 7 & 2097151) + Q4 | 0, DA2 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(J4, 0, R4, 0), g6 = t3, B4 = A8, A8 = PA(Y4, 0, x4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(b4, 0, L4, 0)) | 0, A8 = t3 + g6 | 0, yA2 = Q4, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, A8 = (g6 = i3[D4 + 6 | 0]) >>> 24 | 0, c4 = g6 << 8 | (lA2 = i3[D4 + 2 | 0] | i3[D4 + 3 | 0] << 8 | i3[D4 + 4 | 0] << 16 | i3[D4 + 5 | 0] << 24) >>> 24, B4 = A8, g6 = (A8 = i3[D4 + 7 | 0]) >>> 16 | 0, g6 |= B4, B4 = Q4, c4 = B4 = (A8 = 2097151 & ((3 & g6) << 30 | (A8 = A8 << 16 | c4) >>> 2)) >>> 0 > (yA2 = A8 + yA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, zA2 = A8 = B4 - ((yA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (NA2 = yA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + DA2 | 0, eA2 = A8 = B4 >>> 0 > (rA2 = B4 + nA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, XA2 = A8 = A8 - ((rA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >>> 21 | 0) + kA2 | 0, B4 = (A8 = (2097151 & A8) << 11 | (tA2 = rA2 - -1048576 | 0) >>> 21) >>> 0 > (Q4 = A8 + aA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(LA2, WA2, 666643, 0), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA($A2, CA2, 470296, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(YA2, UA2, 136657, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(pA2, uA2, 654183, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, aA2 = (A8 = PA(bA2, JA2, -997805, -1)) + B4 | 0, B4 = t3 + g6 | 0, kA2 = B4 = A8 >>> 0 > aA2 >>> 0 ? B4 + 1 | 0 : B4, vA2 = A8 = B4 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (nA2 = aA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + fA2 | 0, GA2 = B4 = (A8 = B4 >>> 0 > (Q4 = B4 + GA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) - ((Q4 >>> 0 < 4293918720) - 1 | 0) | 0, DA2 = (2097151 & B4) << 11 | (fA2 = Q4 - -1048576 | 0) >>> 21, B4 = (B4 >> 21) + OA2 | 0, dA2 = hA2 = DA2 + xA2 | 0, hA2 = DA2 >>> 0 > hA2 >>> 0 ? B4 + 1 | 0 : B4, DA2 = Q4, g6 = A8, Q4 = (_A2 - (A8 = -2097152 & wA2) | 0) + (wA2 = (2097151 & SA2) << 11 | HA2 >>> 21) | 0, A8 = (sA2 - ((A8 >>> 0 > _A2 >>> 0) + qA2 | 0) | 0) + (SA2 >> 21) | 0, SA2 = A8 = Q4 >>> 0 < wA2 >>> 0 ? A8 + 1 | 0 : A8, xA2 = A8 = A8 - ((Q4 >>> 0 < 4293918720) - 1 | 0) | 0, _A2 = B4 = A8 >> 21, A8 = PA(LA2 = (2097151 & A8) << 11 | (sA2 = Q4 - -1048576 | 0) >>> 21, B4, -683901, -1), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, OA2 = B4 - (A8 = -2097152 & fA2) | 0, jA2 = g6 - ((A8 >>> 0 > B4 >>> 0) + GA2 | 0) | 0, g6 = PA(LA2, _A2, 136657, 0), A8 = t3 + kA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + aA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, VA2 = B4 - (g6 = -2097152 & nA2) | 0, vA2 = A8 - ((g6 >>> 0 > B4 >>> 0) + vA2 | 0) | 0, g6 = PA($A2, CA2, 666643, 0), A8 = t3 + (eA2 - (((B4 = -2097152 & tA2) >>> 0 > rA2 >>> 0) + XA2 | 0) | 0) | 0, A8 = g6 >>> 0 > (DA2 = g6 + (rA2 - B4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(YA2, UA2, -997805, -1), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(pA2, uA2, 470296, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(bA2, JA2, 654183, 0), A8 = t3 + B4 | 0, GA2 = DA2 = g6 + DA2 | 0, kA2 = g6 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = lA2 >>> 5 & 2097151, A8 = PA(J4, 0, x4, 0), g6 = t3, fA2 = A8, A8 = PA(Y4, 0, L4, 0), g6 = t3 + g6 | 0, A8 = A8 >>> 0 > (DA2 = fA2 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, fA2 = g6 = B4 + DA2 | 0, B4 = A8 = g6 >>> 0 < DA2 >>> 0 ? A8 + 1 | 0 : A8, rA2 = (g6 = PA(J4, 0, L4, 0)) + (A8 = (A8 = i3[D4 + 2 | 0]) << 16 & 2031616 | i3[0 | D4] | i3[D4 + 1 | 0] << 8) | 0, g6 = t3, wA2 = g6 = A8 >>> 0 > rA2 >>> 0 ? g6 + 1 | 0 : g6, qA2 = g6 = g6 - ((rA2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >>> 21 | 0) + B4 | 0, tA2 = A8 = (g6 = (2097151 & g6) << 11 | (eA2 = rA2 - -1048576 | 0) >>> 21) >>> 0 > (HA2 = g6 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, lA2 = g6 = A8 - ((HA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & g6) << 11 | (aA2 = HA2 - -1048576 | 0) >>> 21, g6 = (g6 >>> 21 | 0) + c4 | 0, g6 = B4 >>> 0 > (DA2 = B4 + yA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(YA2, UA2, 654183, 0), A8 = t3 + (g6 - (((c4 = -2097152 & NA2) >>> 0 > DA2 >>> 0) + zA2 | 0) | 0) | 0, A8 = B4 >>> 0 > (yA2 = B4 + (DA2 - c4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(pA2, uA2, 666643, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + yA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, nA2 = (g6 = B4) + (B4 = PA(bA2, JA2, 470296, 0)) | 0, g6 = t3 + A8 | 0, fA2 = g6 = B4 >>> 0 > nA2 >>> 0 ? g6 + 1 | 0 : g6, XA2 = g6 = g6 - ((nA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >> 21) + kA2 | 0, NA2 = g6 = (B4 = (g6 = (2097151 & g6) << 11 | (DA2 = nA2 - -1048576 | 0) >>> 21) >>> 0 > (yA2 = g6 + GA2 | 0) >>> 0 ? B4 + 1 | 0 : B4) - ((yA2 >>> 0 < 4293918720) - 1 | 0) | 0, kA2 = (2097151 & g6) << 11 | (c4 = yA2 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + vA2 | 0, uA2 = pA2 = kA2 + VA2 | 0, kA2 = kA2 >>> 0 > pA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(LA2, _A2, -997805, -1), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (yA2 = A8 + yA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, vA2 = yA2 - (A8 = -2097152 & c4) | 0, GA2 = g6 - ((A8 >>> 0 > yA2 >>> 0) + NA2 | 0) | 0, g6 = PA(LA2, _A2, 654183, 0), A8 = t3 + fA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + nA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, pA2 = B4 - (g6 = -2097152 & DA2) | 0, NA2 = A8 - ((g6 >>> 0 > B4 >>> 0) + XA2 | 0) | 0, A8 = PA(YA2, UA2, 470296, 0), B4 = t3 + (tA2 - (((g6 = -2097152 & aA2) >>> 0 > HA2 >>> 0) + lA2 | 0) | 0) | 0, B4 = A8 >>> 0 > (c4 = A8 + (HA2 - g6 | 0) | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(bA2, JA2, 666643, 0), A8 = t3 + B4 | 0, yA2 = c4 = g6 + c4 | 0, B4 = g6 >>> 0 > c4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(YA2, UA2, 666643, 0), A8 = t3 + (wA2 - ((4095 & qA2) + ((c4 = -2097152 & eA2) >>> 0 > rA2 >>> 0) | 0) | 0) | 0, nA2 = A8 = g6 >>> 0 > (aA2 = g6 + (rA2 - c4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, wA2 = A8 = A8 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, c4 = (2097151 & A8) << 11 | (fA2 = aA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + B4 | 0, B4 = A8 = c4 >>> 0 > (DA2 = c4 + yA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, eA2 = A8 = A8 - ((DA2 >>> 0 < 4293918720) - 1 | 0) | 0, c4 = (2097151 & A8) << 11 | (yA2 = DA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + NA2 | 0, c4 = c4 >>> 0 > (tA2 = c4 + pA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(LA2, _A2, 470296, 0), B4 = t3 + B4 | 0, B4 = A8 >>> 0 > (g6 = A8 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, DA2 = g6 - (A8 = -2097152 & yA2) | 0, yA2 = B4 - ((A8 >>> 0 > g6 >>> 0) + eA2 | 0) | 0, g6 = PA(LA2, _A2, 666643, 0), A8 = t3 + (nA2 - (((B4 = -2097152 & fA2) >>> 0 > aA2 >>> 0) + wA2 | 0) | 0) | 0, g6 = (B4 = (A8 = g6 >>> 0 > (NA2 = g6 + (aA2 - B4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + yA2 | 0, A8 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | NA2 >>> 21) >>> 0 > (wA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + c4 | 0, g6 = (g6 = (A8 = (g6 = (2097151 & g6) << 11 | wA2 >>> 21) >>> 0 > (eA2 = g6 + tA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + GA2 | 0, B4 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | eA2 >>> 21) >>> 0 > (c4 = A8 + vA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + kA2 | 0, A8 = (g6 = (B4 = (g6 = (2097151 & g6) << 11 | c4 >>> 21) >>> 0 > (tA2 = g6 + uA2 | 0) >>> 0 ? B4 + 1 | 0 : B4) >> 21) + jA2 | 0, g6 = (B4 = (A8 = (B4 = (2097151 & B4) << 11 | tA2 >>> 21) >>> 0 > (aA2 = B4 + OA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + hA2 | 0, A8 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | aA2 >>> 21) >>> 0 > (kA2 = A8 + dA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + ZA2 | 0, g6 = (g6 = (A8 = (g6 = (2097151 & g6) << 11 | kA2 >>> 21) >>> 0 > (nA2 = g6 + RA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + KA2 | 0, B4 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | nA2 >>> 21) >>> 0 > (fA2 = A8 + TA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + AI2 | 0, A8 = (g6 = (B4 = (g6 = (2097151 & g6) << 11 | fA2 >>> 21) >>> 0 > (DA2 = g6 + QI2 | 0) >>> 0 ? B4 + 1 | 0 : B4) >> 21) + BI2 | 0, sA2 = (hA2 = Q4 - (g6 = -2097152 & sA2) | 0) + ((2097151 & (A8 = (B4 = (2097151 & B4) << 11 | DA2 >>> 21) >>> 0 > (yA2 = B4 + CI2 | 0) >>> 0 ? A8 + 1 | 0 : A8)) << 11 | yA2 >>> 21) | 0, A8 = (SA2 - ((g6 >>> 0 > Q4 >>> 0) + xA2 | 0) | 0) + (A8 >> 21) | 0, SA2 = g6 = (A8 = hA2 >>> 0 > sA2 >>> 0 ? A8 + 1 | 0 : A8) >> 21, NA2 = (A8 = PA(KA2 = (2097151 & A8) << 11 | sA2 >>> 21, g6, 666643, 0)) + (g6 = 2097151 & NA2) | 0, A8 = t3, Q4 = A8 = g6 >>> 0 > NA2 >>> 0 ? A8 + 1 | 0 : A8, C3[0 | o4] = NA2, C3[o4 + 1 | 0] = (255 & A8) << 24 | NA2 >>> 8, A8 = 2097151 & wA2, g6 = PA(KA2, SA2, 470296, 0) + A8 | 0, B4 = t3, A8 = (Q4 >> 21) + (A8 >>> 0 > g6 >>> 0 ? B4 + 1 | 0 : B4) | 0, A8 = (wA2 = (hA2 = (2097151 & Q4) << 11 | NA2 >>> 21) + g6 | 0) >>> 0 < hA2 >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 4 | 0] = (2047 & A8) << 21 | wA2 >>> 11, g6 = A8, B4 = wA2, C3[o4 + 3 | 0] = (7 & A8) << 29 | B4 >>> 3, C3[o4 + 2 | 0] = 31 & ((65535 & Q4) << 16 | NA2 >>> 16) | B4 << 5, Q4 = 2097151 & eA2, eA2 = PA(KA2, SA2, 654183, 0) + Q4 | 0, A8 = t3, wA2 = (2097151 & g6) << 11 | B4 >>> 21, g6 = (g6 >> 21) + (Q4 = Q4 >>> 0 > eA2 >>> 0 ? A8 + 1 | 0 : A8) | 0, A8 = g6 = (eA2 = wA2 + eA2 | 0) >>> 0 < wA2 >>> 0 ? g6 + 1 | 0 : g6, C3[o4 + 6 | 0] = (63 & A8) << 26 | eA2 >>> 6, Q4 = eA2, eA2 = 0, C3[o4 + 5 | 0] = eA2 << 13 | (1572864 & B4) >>> 19 | Q4 << 2, B4 = 2097151 & c4, c4 = PA(KA2, SA2, -997805, -1) + B4 | 0, g6 = t3, g6 = B4 >>> 0 > c4 >>> 0 ? g6 + 1 | 0 : g6, eA2 = (2097151 & (B4 = A8)) << 11 | Q4 >>> 21, B4 = (A8 >>= 21) + g6 | 0, B4 = (c4 = eA2 + c4 | 0) >>> 0 < eA2 >>> 0 ? B4 + 1 | 0 : B4, C3[o4 + 9 | 0] = (511 & B4) << 23 | c4 >>> 9, C3[o4 + 8 | 0] = (1 & B4) << 31 | c4 >>> 1, g6 = 0, C3[o4 + 7 | 0] = g6 << 18 | (2080768 & Q4) >>> 14 | c4 << 7, g6 = 2097151 & tA2, Q4 = PA(KA2, SA2, 136657, 0) + g6 | 0, A8 = t3, A8 = g6 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, tA2 = (2097151 & (g6 = B4)) << 11 | c4 >>> 21, g6 = A8 + (B4 = g6 >> 21) | 0, g6 = (Q4 = tA2 + Q4 | 0) >>> 0 < tA2 >>> 0 ? g6 + 1 | 0 : g6, C3[o4 + 12 | 0] = (4095 & g6) << 20 | Q4 >>> 12, B4 = Q4, C3[o4 + 11 | 0] = (15 & g6) << 28 | B4 >>> 4, Q4 = 0, C3[o4 + 10 | 0] = Q4 << 15 | (1966080 & c4) >>> 17 | B4 << 4, Q4 = 2097151 & aA2, c4 = PA(KA2, SA2, -683901, -1) + Q4 | 0, A8 = t3, A8 = Q4 >>> 0 > c4 >>> 0 ? A8 + 1 | 0 : A8, Q4 = g6, g6 = A8 + (g6 >>= 21) | 0, g6 = (Q4 = (aA2 = c4) + (c4 = (2097151 & Q4) << 11 | B4 >>> 21) | 0) >>> 0 < c4 >>> 0 ? g6 + 1 | 0 : g6, C3[o4 + 14 | 0] = (127 & g6) << 25 | Q4 >>> 7, c4 = 0, C3[o4 + 13 | 0] = c4 << 12 | (1048576 & B4) >>> 20 | Q4 << 1, A8 = g6 >> 21, B4 = (g6 = (2097151 & g6) << 11 | Q4 >>> 21) >>> 0 > (c4 = g6 + (2097151 & kA2) | 0) >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 17 | 0] = (1023 & B4) << 22 | c4 >>> 10, C3[o4 + 16 | 0] = (3 & B4) << 30 | c4 >>> 2, g6 = 0, C3[o4 + 15 | 0] = g6 << 17 | (2064384 & Q4) >>> 15 | c4 << 6, A8 = B4 >> 21, A8 = (g6 = (2097151 & B4) << 11 | c4 >>> 21) >>> 0 > (B4 = g6 + (2097151 & nA2) | 0) >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 20 | 0] = (8191 & A8) << 19 | B4 >>> 13, C3[o4 + 19 | 0] = (31 & A8) << 27 | B4 >>> 5, Q4 = (g6 = 2097151 & fA2) + (fA2 = (2097151 & A8) << 11 | B4 >>> 21) | 0, g6 = A8 >> 21, g6 = Q4 >>> 0 < fA2 >>> 0 ? g6 + 1 | 0 : g6, fA2 = Q4, C3[o4 + 21 | 0] = Q4, nA2 = 0, C3[o4 + 18 | 0] = nA2 << 14 | (1835008 & c4) >>> 18 | B4 << 3, C3[o4 + 22 | 0] = (255 & g6) << 24 | Q4 >>> 8, B4 = g6 >> 21, B4 = (Q4 = (c4 = (2097151 & g6) << 11 | Q4 >>> 21) + (2097151 & DA2) | 0) >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, C3[o4 + 25 | 0] = (2047 & B4) << 21 | Q4 >>> 11, C3[o4 + 24 | 0] = (7 & B4) << 29 | Q4 >>> 3, C3[o4 + 23 | 0] = 31 & ((65535 & g6) << 16 | fA2 >>> 16) | Q4 << 5, A8 = B4 >> 21, A8 = (g6 = (2097151 & B4) << 11 | Q4 >>> 21) >>> 0 > (B4 = g6 + (2097151 & yA2) | 0) >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 27 | 0] = (63 & A8) << 26 | B4 >>> 6, c4 = 0, C3[o4 + 26 | 0] = c4 << 13 | (1572864 & Q4) >>> 19 | B4 << 2, g6 = A8, A8 >>= 21, g6 = (Q4 = (yA2 = (2097151 & g6) << 11 | B4 >>> 21) + (c4 = 2097151 & sA2) | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 31 | 0] = (131071 & g6) << 15 | Q4 >>> 17, A8 = Q4, C3[o4 + 30 | 0] = (511 & g6) << 23 | A8 >>> 9, Q4 = 0, C3[o4 + 28 | 0] = Q4 << 18 | (2080768 & B4) >>> 14 | A8 << 7, C3[o4 + 29 | 0] = yA2 + sA2 >>> 1, MI(a4, 64), MI(D4, 64), I7 && (E3[I7 >> 2] = 64, E3[I7 + 4 >> 2] = 0), r3 = y4 + 560 | 0, 0; + } + function n3(A8, I7, g6, C4) { + for (var B4 = 0, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0; o4 = (B4 = D4 << 3) + g6 | 0, Q4 = i3[0 | (B4 = I7 + B4 | 0)] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, _4 = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, a4 = Q4 << 24 | (65280 & Q4) << 8, y4 = (c4 = 16711680 & Q4) << 24, c4 = c4 >>> 8 | 0, B4 = (e4 = -16777216 & Q4) >>> 24 | 0, E3[o4 >> 2] = y4 | e4 << 8 | -16777216 & ((255 & _4) << 24 | Q4 >>> 8) | 16711680 & ((16777215 & _4) << 8 | Q4 >>> 24) | _4 >>> 8 & 65280 | _4 >>> 24, Q4 = B4 | c4 | a4, B4 = 0, E3[o4 + 4 >> 2] = Q4 | B4, 16 != (0 | (D4 = D4 + 1 | 0)); ) ; + for (I7 = E3[A8 + 4 >> 2], E3[C4 >> 2] = E3[A8 >> 2], E3[C4 + 4 >> 2] = I7, I7 = E3[A8 + 60 >> 2], E3[C4 + 56 >> 2] = E3[A8 + 56 >> 2], E3[C4 + 60 >> 2] = I7, I7 = E3[A8 + 52 >> 2], E3[C4 + 48 >> 2] = E3[A8 + 48 >> 2], E3[C4 + 52 >> 2] = I7, I7 = E3[A8 + 44 >> 2], E3[C4 + 40 >> 2] = E3[A8 + 40 >> 2], E3[C4 + 44 >> 2] = I7, I7 = E3[A8 + 36 >> 2], E3[C4 + 32 >> 2] = E3[A8 + 32 >> 2], E3[C4 + 36 >> 2] = I7, I7 = E3[A8 + 28 >> 2], E3[C4 + 24 >> 2] = E3[A8 + 24 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[A8 + 20 >> 2], E3[C4 + 16 >> 2] = E3[A8 + 16 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[A8 + 12 >> 2], E3[C4 + 8 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 12 >> 2] = I7; o4 = E3[C4 + 56 >> 2], c4 = E3[C4 + 60 >> 2], B4 = E3[(I7 = _4 = (p4 = q4 << 3) + g6 | 0) >> 2], I7 = E3[I7 + 4 >> 2], S4 = Q4 = E3[C4 + 36 >> 2], Q4 = _A(n4 = E3[C4 + 32 >> 2], Q4, 50), D4 = t3, Q4 = _A(n4, S4, 46) ^ Q4, D4 ^= t3, Q4 = _A(n4, S4, 23) ^ Q4, I7 = (t3 ^ D4) + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (D4 = E3[(Q4 = p4 + 33968 | 0) >> 2]) + B4 | 0, I7 = E3[Q4 + 4 >> 2] + I7 | 0, I7 = B4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (D4 = ((y4 = E3[C4 + 48 >> 2]) ^ (w4 = E3[C4 + 40 >> 2])) & n4 ^ y4) + B4 | 0, B4 = (((s4 = E3[C4 + 52 >> 2]) ^ (M4 = E3[C4 + 44 >> 2])) & S4 ^ s4) + I7 | 0, I7 = (Q4 >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4) + c4 | 0, I7 = (o4 = Q4 + o4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, D4 = (Q4 = E3[C4 + 24 >> 2]) + o4 | 0, B4 = E3[C4 + 28 >> 2] + I7 | 0, r4 = B4 = Q4 >>> 0 > D4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 24 >> 2] = D4, E3[C4 + 28 >> 2] = B4, F4 = B4 = E3[C4 + 4 >> 2], B4 = _A(Q4 = E3[C4 >> 2], B4, 36), c4 = t3, B4 = _A(Q4, F4, 30) ^ B4, c4 ^= t3, e4 = o4 + (_A(Q4, F4, 25) ^ B4) | 0, B4 = I7 + (t3 ^ c4) | 0, B4 = o4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4, a4 = (I7 = e4) + (e4 = Q4 & ((c4 = E3[C4 + 16 >> 2]) | (o4 = E3[C4 + 8 >> 2])) | o4 & c4) | 0, I7 = (I7 = B4) + (F4 & ((B4 = E3[C4 + 20 >> 2]) | (h4 = E3[C4 + 12 >> 2])) | B4 & h4) | 0, e4 = I7 = a4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 56 >> 2] = a4, E3[C4 + 60 >> 2] = I7, f4 = c4, k4 = B4, K4 = E3[(I7 = v4 = (N4 = 8 | p4) + g6 | 0) >> 2], G4 = E3[I7 + 4 >> 2], B4 = ((S4 ^ M4) & r4 ^ M4) + s4 | 0, B4 = (I7 = (c4 = (w4 ^ n4) & D4 ^ w4) + y4 | 0) >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, c4 = _A(D4, r4, 50), y4 = t3, c4 = _A(D4, r4, 46) ^ c4, y4 ^= t3, c4 = (s4 = _A(D4, r4, 23) ^ c4) + I7 | 0, I7 = (t3 ^ y4) + B4 | 0, I7 = (c4 >>> 0 < s4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, I7 = (B4 = c4 + K4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, c4 = (c4 = B4) + (y4 = E3[(B4 = N4 + 33968 | 0) >> 2]) | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (I7 = c4 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4) + k4 | 0, s4 = B4 = (y4 = c4 + f4 | 0) >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 16 >> 2] = y4, E3[C4 + 20 >> 2] = B4, I7 = I7 + ((h4 | F4) & e4 | h4 & F4) | 0, I7 = (B4 = c4 + ((Q4 | o4) & a4 | Q4 & o4) | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, c4 = _A(a4, e4, 36), f4 = t3, c4 = _A(a4, e4, 30) ^ c4, f4 ^= t3, k4 = B4, B4 = _A(a4, e4, 25) ^ c4, I7 = (t3 ^ f4) + I7 | 0, f4 = I7 = B4 >>> 0 > (c4 = k4 + B4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 48 >> 2] = c4, E3[C4 + 52 >> 2] = I7, k4 = o4, N4 = h4, I7 = (h4 = E3[(B4 = U4 = (o4 = 16 | p4) + g6 | 0) >> 2]) + w4 | 0, B4 = E3[B4 + 4 >> 2] + M4 | 0, B4 = I7 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, o4 = (w4 = I7) + (h4 = E3[(I7 = o4 + 33968 | 0) >> 2]) | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = ((r4 ^ S4) & s4 ^ S4) + (I7 = o4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = o4) + (o4 = (D4 ^ n4) & y4 ^ n4) | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, o4 = _A(y4, s4, 50), h4 = t3, o4 = _A(y4, s4, 46) ^ o4, h4 ^= t3, o4 = (w4 = _A(y4, s4, 23) ^ o4) + B4 | 0, B4 = (t3 ^ h4) + I7 | 0, B4 = (w4 = o4 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) + N4 | 0, N4 = B4 = (h4 = o4) >>> 0 > (o4 = o4 + k4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 8 >> 2] = o4, E3[C4 + 12 >> 2] = B4, I7 = _A(c4, f4, 36), B4 = t3, I7 = _A(c4, f4, 30) ^ I7, B4 ^= t3, M4 = _A(c4, f4, 25) ^ I7, I7 = ((e4 | F4) & f4 | e4 & F4) + (t3 ^ B4) | 0, B4 = w4 + ((k4 = M4 + ((Q4 | a4) & c4 | Q4 & a4) | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) | 0, h4 = B4 = (w4 = h4 + k4 | 0) >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 40 >> 2] = w4, E3[C4 + 44 >> 2] = B4, k4 = Q4, B4 = (B4 = n4) + (n4 = E3[(I7 = R4 = (Q4 = 24 | p4) + g6 | 0) >> 2]) | 0, I7 = E3[I7 + 4 >> 2] + S4 | 0, I7 = B4 >>> 0 < n4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (M4 = B4) + (n4 = E3[(B4 = Q4 + 33968 | 0) >> 2]) | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (r4 ^ (r4 ^ s4) & N4) + (B4 = Q4 >>> 0 < n4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = D4 ^ (D4 ^ y4) & o4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(o4, N4, 50), n4 = t3, Q4 = _A(o4, N4, 46) ^ Q4, n4 ^= t3, Q4 = (S4 = _A(o4, N4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ n4) + B4 | 0, B4 = (I7 = Q4 >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7) + F4 | 0, S4 = B4 = (F4 = Q4 + k4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 >> 2] = F4, E3[C4 + 4 >> 2] = B4, B4 = _A(w4, h4, 36), n4 = t3, B4 = _A(w4, h4, 30) ^ B4, k4 = t3 ^ n4, M4 = _A(w4, h4, 25) ^ B4, B4 = ((e4 | f4) & h4 | e4 & f4) + (t3 ^ k4) | 0, I7 = I7 + ((n4 = M4 + ((c4 | a4) & w4 | c4 & a4) | 0) >>> 0 < M4 >>> 0 ? B4 + 1 | 0 : B4) | 0, n4 = I7 = (k4 = Q4 + n4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 32 >> 2] = k4, E3[C4 + 36 >> 2] = I7, Q4 = E3[(B4 = P4 = (I7 = 32 | p4) + g6 | 0) >> 2], B4 = r4 + E3[B4 + 4 >> 2] | 0, B4 = (Q4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (D4 = E3[(I7 = I7 + 33968 | 0) >> 2]) + Q4 | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (s4 ^ (s4 ^ N4) & S4) + (I7 = Q4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = y4 ^ (o4 ^ y4) & F4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(F4, S4, 50), D4 = t3, Q4 = _A(F4, S4, 46) ^ Q4, D4 ^= t3, Q4 = (r4 = _A(F4, S4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ D4) + I7 | 0, M4 = B4 = Q4 >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(k4, n4, 36), D4 = t3, B4 = _A(k4, n4, 30) ^ B4, r4 = t3 ^ D4, K4 = _A(k4, n4, 25) ^ B4, B4 = ((f4 | h4) & n4 | f4 & h4) + (t3 ^ r4) | 0, I7 = ((D4 = K4 + ((c4 | w4) & k4 | c4 & w4) | 0) >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, D4 = I7 = (r4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 24 >> 2] = r4, E3[C4 + 28 >> 2] = I7, B4 = e4 + M4 | 0, M4 = B4 = (e4 = Q4 + a4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 56 >> 2] = e4, E3[C4 + 60 >> 2] = B4, Q4 = E3[(I7 = d4 = (B4 = 40 | p4) + g6 | 0) >> 2], I7 = s4 + E3[I7 + 4 >> 2] | 0, I7 = (Q4 = Q4 + y4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (a4 = E3[(B4 = B4 + 33968 | 0) >> 2]) + Q4 | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (N4 ^ (S4 ^ N4) & M4) + (B4 = Q4 >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = o4 ^ (o4 ^ F4) & e4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(e4, M4, 50), a4 = t3, Q4 = _A(e4, M4, 46) ^ Q4, a4 ^= t3, Q4 = (y4 = _A(e4, M4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ a4) + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(r4, D4, 36), a4 = t3, B4 = _A(r4, D4, 30) ^ B4, y4 = t3 ^ a4, s4 = _A(r4, D4, 25) ^ B4, B4 = ((h4 | n4) & D4 | h4 & n4) + (t3 ^ y4) | 0, B4 = ((a4 = s4 + ((w4 | k4) & r4 | w4 & k4) | 0) >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, a4 = B4 = (y4 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 16 >> 2] = y4, E3[C4 + 20 >> 2] = B4, I7 = I7 + f4 | 0, K4 = I7 = (f4 = Q4 + c4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 48 >> 2] = f4, E3[C4 + 52 >> 2] = I7, Q4 = E3[(B4 = Y4 = (I7 = 48 | p4) + g6 | 0) >> 2], B4 = N4 + E3[B4 + 4 >> 2] | 0, B4 = (Q4 = Q4 + o4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (o4 = E3[(I7 = I7 + 33968 | 0) >> 2]) + Q4 | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (S4 ^ (S4 ^ M4) & K4) + (I7 = Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = F4 ^ (e4 ^ F4) & f4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(f4, K4, 50), o4 = t3, Q4 = _A(f4, K4, 46) ^ Q4, o4 ^= t3, Q4 = (c4 = _A(f4, K4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ o4) + I7 | 0, c4 = B4 = Q4 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(y4, a4, 36), o4 = t3, B4 = _A(y4, a4, 30) ^ B4, s4 = t3 ^ o4, N4 = _A(y4, a4, 25) ^ B4, B4 = ((D4 | n4) & a4 | D4 & n4) + (t3 ^ s4) | 0, I7 = ((o4 = N4 + ((r4 | k4) & y4 | r4 & k4) | 0) >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, s4 = I7 = (B4 = o4) >>> 0 > (o4 = Q4 + o4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 8 >> 2] = o4, E3[C4 + 12 >> 2] = I7, B4 = c4 + h4 | 0, N4 = B4 = (G4 = Q4 + w4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 40 >> 2] = G4, E3[C4 + 44 >> 2] = B4, Q4 = E3[(I7 = b4 = (B4 = 56 | p4) + g6 | 0) >> 2], I7 = S4 + E3[I7 + 4 >> 2] | 0, I7 = (Q4 = Q4 + F4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (c4 = E3[(B4 = B4 + 33968 | 0) >> 2]) + Q4 | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (M4 ^ (M4 ^ K4) & N4) + (B4 = Q4 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = e4 ^ (e4 ^ f4) & G4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(G4, N4, 50), c4 = t3, Q4 = _A(G4, N4, 46) ^ Q4, c4 ^= t3, Q4 = (h4 = _A(G4, N4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ c4) + B4 | 0, I7 = Q4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(o4, s4, 36), c4 = t3, B4 = _A(o4, s4, 30) ^ B4, h4 = t3 ^ c4, w4 = _A(o4, s4, 25) ^ B4, B4 = ((D4 | a4) & s4 | D4 & a4) + (t3 ^ h4) | 0, B4 = ((c4 = w4 + ((y4 | r4) & o4 | y4 & r4) | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, h4 = B4 = (h4 = c4) >>> 0 > (c4 = Q4 + c4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 >> 2] = c4, E3[C4 + 4 >> 2] = B4, I7 = I7 + n4 | 0, S4 = I7 = (w4 = Q4 + k4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 32 >> 2] = w4, E3[C4 + 36 >> 2] = I7, Q4 = E3[(B4 = L4 = (I7 = 64 | p4) + g6 | 0) >> 2], B4 = M4 + E3[B4 + 4 >> 2] | 0, B4 = (Q4 = Q4 + e4 | 0) >>> 0 < e4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (e4 = E3[(I7 = I7 + 33968 | 0) >> 2]) + Q4 | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (K4 ^ (N4 ^ K4) & S4) + (I7 = Q4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = f4 ^ (f4 ^ G4) & w4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(w4, S4, 50), e4 = t3, Q4 = _A(w4, S4, 46) ^ Q4, e4 ^= t3, Q4 = (F4 = _A(w4, S4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ e4) + I7 | 0, n4 = B4 = Q4 >>> 0 < F4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(c4, h4, 36), e4 = t3, B4 = _A(c4, h4, 30) ^ B4, F4 = t3 ^ e4, k4 = _A(c4, h4, 25) ^ B4, B4 = ((a4 | s4) & h4 | a4 & s4) + (t3 ^ F4) | 0, I7 = ((e4 = k4 + ((o4 | y4) & c4 | o4 & y4) | 0) >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, e4 = I7 = (F4 = Q4 + e4 | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 56 >> 2] = F4, E3[C4 + 60 >> 2] = I7, B4 = D4 + n4 | 0, M4 = B4 = (D4 = Q4 + r4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 24 >> 2] = D4, E3[C4 + 28 >> 2] = B4, Q4 = E3[(I7 = J4 = (B4 = 72 | p4) + g6 | 0) >> 2], I7 = K4 + E3[I7 + 4 >> 2] | 0, I7 = (Q4 = Q4 + f4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (f4 = E3[(B4 = B4 + 33968 | 0) >> 2]) + Q4 | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (N4 ^ (S4 ^ N4) & M4) + (B4 = Q4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = G4 ^ (w4 ^ G4) & D4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(D4, M4, 50), f4 = t3, Q4 = _A(D4, M4, 46) ^ Q4, f4 ^= t3, Q4 = (n4 = _A(D4, M4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ f4) + B4 | 0, I7 = Q4 >>> 0 < n4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(F4, e4, 36), f4 = t3, B4 = _A(F4, e4, 30) ^ B4, n4 = t3 ^ f4, k4 = _A(F4, e4, 25) ^ B4, B4 = ((h4 | s4) & e4 | h4 & s4) + (t3 ^ n4) | 0, B4 = ((f4 = k4 + ((o4 | c4) & F4 | o4 & c4) | 0) >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, f4 = B4 = (n4 = Q4 + f4 | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 48 >> 2] = n4, E3[C4 + 52 >> 2] = B4, I7 = I7 + a4 | 0, K4 = I7 = (a4 = Q4 + y4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 16 >> 2] = a4, E3[C4 + 20 >> 2] = I7, I7 = (I7 = G4) + (y4 = E3[(B4 = G4 = (Q4 = 80 | p4) + g6 | 0) >> 2]) | 0, B4 = E3[B4 + 4 >> 2] + N4 | 0, B4 = I7 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (r4 = I7) + (y4 = E3[(I7 = Q4 + 33968 | 0) >> 2]) | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (S4 ^ (S4 ^ M4) & K4) + (I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = w4 ^ (D4 ^ w4) & a4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(a4, K4, 50), y4 = t3, Q4 = _A(a4, K4, 46) ^ Q4, y4 ^= t3, Q4 = (k4 = _A(a4, K4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ y4) + I7 | 0, r4 = B4 = Q4 >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(n4, f4, 36), y4 = t3, B4 = _A(n4, f4, 30) ^ B4, k4 = t3 ^ y4, N4 = _A(n4, f4, 25) ^ B4, B4 = ((e4 | h4) & f4 | e4 & h4) + (t3 ^ k4) | 0, I7 = ((y4 = N4 + ((c4 | F4) & n4 | c4 & F4) | 0) >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, y4 = I7 = (k4 = Q4 + y4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 40 >> 2] = k4, E3[C4 + 44 >> 2] = I7, B4 = r4 + s4 | 0, s4 = B4 = (r4 = Q4 + o4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 8 >> 2] = r4, E3[C4 + 12 >> 2] = B4, B4 = 33968 + (I7 = 88 | p4) | 0, o4 = E3[(I7 = H4 = I7 + g6 | 0) >> 2], Q4 = E3[B4 >> 2] + o4 | 0, I7 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, B4 = S4 + (Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (M4 ^ (M4 ^ K4) & s4) + (B4 = (I7 = Q4 + w4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (Q4 = D4 ^ (D4 ^ a4) & r4) + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(r4, s4, 50), o4 = t3, Q4 = _A(r4, s4, 46) ^ Q4, o4 ^= t3, Q4 = (w4 = _A(r4, s4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ o4) + B4 | 0, I7 = Q4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(k4, y4, 36), o4 = t3, B4 = _A(k4, y4, 30) ^ B4, w4 = t3 ^ o4, N4 = _A(k4, y4, 25) ^ B4, B4 = ((e4 | f4) & y4 | e4 & f4) + (t3 ^ w4) | 0, B4 = ((o4 = N4 + ((n4 | F4) & k4 | n4 & F4) | 0) >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, w4 = B4 = (w4 = o4) >>> 0 > (o4 = Q4 + o4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 32 >> 2] = o4, E3[C4 + 36 >> 2] = B4, I7 = I7 + h4 | 0, h4 = I7 = (B4 = c4) >>> 0 > (c4 = Q4 + c4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[C4 >> 2] = c4, E3[C4 + 4 >> 2] = I7, B4 = 33968 + (I7 = 96 | p4) | 0, N4 = E3[(I7 = x4 = I7 + g6 | 0) >> 2], Q4 = E3[B4 >> 2] + N4 | 0, B4 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, I7 = M4 + (Q4 >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (D4 = a4 ^ (a4 ^ r4) & c4) + B4 | 0, B4 = (K4 ^ (s4 ^ K4) & h4) + I7 | 0, B4 = Q4 >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, I7 = _A(c4, h4, 50), D4 = t3, I7 = _A(c4, h4, 46) ^ I7, D4 ^= t3, M4 = Q4, Q4 = _A(c4, h4, 23) ^ I7, B4 = (t3 ^ D4) + B4 | 0, S4 = B4 = (I7 = M4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = I7, I7 = _A(o4, w4, 36), D4 = t3, I7 = _A(o4, w4, 30) ^ I7, N4 = t3 ^ D4, M4 = _A(o4, w4, 25) ^ I7, I7 = ((y4 | f4) & w4 | y4 & f4) + (t3 ^ N4) | 0, B4 = ((D4 = M4 + ((n4 | k4) & o4 | n4 & k4) | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) + B4 | 0, D4 = B4 = (N4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 24 >> 2] = N4, E3[C4 + 28 >> 2] = B4, B4 = e4 + S4 | 0, e4 = B4 = (F4 = Q4 + F4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 56 >> 2] = F4, E3[C4 + 60 >> 2] = B4, B4 = 33968 + (I7 = 104 | p4) | 0, S4 = E3[(I7 = m4 = I7 + g6 | 0) >> 2], Q4 = E3[B4 >> 2] + S4 | 0, I7 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, B4 = K4 + (Q4 >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (I7 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (a4 = r4 ^ (c4 ^ r4) & F4) + I7 | 0, I7 = (s4 ^ (h4 ^ s4) & e4) + B4 | 0, I7 = Q4 >>> 0 < a4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(F4, e4, 50), a4 = t3, B4 = _A(F4, e4, 46) ^ B4, a4 ^= t3, S4 = _A(F4, e4, 23) ^ B4, B4 = (t3 ^ a4) + I7 | 0, M4 = B4 = (Q4 = S4 + Q4 | 0) >>> 0 < S4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(N4, D4, 36), a4 = t3, B4 = _A(N4, D4, 30) ^ B4, S4 = t3 ^ a4, K4 = _A(N4, D4, 25) ^ B4, B4 = ((y4 | w4) & D4 | y4 & w4) + (t3 ^ S4) | 0, I7 = ((a4 = K4 + ((o4 | k4) & N4 | o4 & k4) | 0) >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, a4 = I7 = (S4 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 16 >> 2] = S4, E3[C4 + 20 >> 2] = I7, I7 = f4 + M4 | 0, f4 = I7 = (n4 = Q4 + n4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 48 >> 2] = n4, E3[C4 + 52 >> 2] = I7, B4 = 33968 + (I7 = 112 | p4) | 0, M4 = E3[(Q4 = K4 = I7 + g6 | 0) >> 2], I7 = E3[B4 >> 2] + M4 | 0, B4 = E3[B4 + 4 >> 2] + E3[Q4 + 4 >> 2] | 0, B4 = s4 + (I7 >>> 0 < M4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (h4 ^ (e4 ^ h4) & f4) + (B4 = (I7 = I7 + r4 | 0) >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (Q4 = c4 ^ (c4 ^ F4) & n4) + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(n4, f4, 50), r4 = t3, Q4 = _A(n4, f4, 46) ^ Q4, r4 ^= t3, Q4 = (s4 = _A(n4, f4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ r4) + B4 | 0, M4 = I7 = Q4 >>> 0 < s4 >>> 0 ? I7 + 1 | 0 : I7, B4 = I7, I7 = _A(S4, a4, 36), r4 = t3, I7 = _A(S4, a4, 30) ^ I7, s4 = t3 ^ r4, u4 = _A(S4, a4, 25) ^ I7, I7 = ((D4 | w4) & a4 | D4 & w4) + (t3 ^ s4) | 0, B4 = ((r4 = u4 + ((o4 | N4) & S4 | o4 & N4) | 0) >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) + B4 | 0, r4 = B4 = (s4 = Q4 + r4 | 0) >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 8 >> 2] = s4, E3[C4 + 12 >> 2] = B4, B4 = y4 + M4 | 0, Q4 = B4 = (y4 = Q4 + k4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 40 >> 2] = y4, E3[C4 + 44 >> 2] = B4, B4 = 33968 + (I7 = 120 | p4) | 0, p4 = E3[(I7 = k4 = I7 + g6 | 0) >> 2], M4 = E3[B4 >> 2] + p4 | 0, B4 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, I7 = h4 + (M4 >>> 0 < p4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (e4 ^ (e4 ^ f4) & Q4) + (I7 = (B4 = c4 + M4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (c4 = F4 ^ (n4 ^ F4) & y4) + B4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, c4 = _A(y4, Q4, 50), e4 = t3, c4 = _A(y4, Q4, 46) ^ c4, e4 ^= t3, Q4 = (c4 = _A(y4, Q4, 23) ^ c4) + B4 | 0, B4 = (t3 ^ e4) + I7 | 0, B4 = Q4 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, c4 = Q4, e4 = B4, I7 = B4, B4 = _A(s4, r4, 36), y4 = t3, B4 = _A(s4, r4, 30) ^ B4, f4 = t3 ^ y4, h4 = _A(s4, r4, 25) ^ B4, B4 = ((D4 | a4) & r4 | D4 & a4) + (t3 ^ f4) | 0, I7 = ((y4 = h4 + ((S4 | N4) & s4 | S4 & N4) | 0) >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, I7 = (Q4 = Q4 + y4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 >> 2] = Q4, E3[C4 + 4 >> 2] = I7, B4 = e4 + w4 | 0, B4 = (f4 = o4) >>> 0 > (o4 = o4 + c4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 32 >> 2] = o4, E3[C4 + 36 >> 2] = B4, 64 != (0 | q4); ) a4 = ((q4 = q4 + 16 | 0) << 3) + g6 | 0, c4 = E3[_4 >> 2], D4 = E3[_4 + 4 >> 2], u4 = E3[J4 >> 2], e4 = I7 = E3[J4 + 4 >> 2], B4 = I7, Q4 = I7 = E3[K4 + 4 >> 2], I7 = _A(N4 = E3[K4 >> 2], I7, 45), o4 = t3, f4 = ((63 & Q4) << 26 | N4 >>> 6) ^ (I7 = _A(N4, Q4, 3) ^ I7), I7 = (Q4 >>> 6 ^ (y4 = t3 ^ o4)) + B4 | 0, B4 = ((o4 = f4 + u4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) + D4 | 0, B4 = (I7 = o4 + c4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, c4 = o4 = E3[v4 + 4 >> 2], o4 = _A(D4 = E3[v4 >> 2], o4, 63), y4 = t3, o4 = ((127 & c4) << 25 | D4 >>> 7) ^ _A(D4, c4, 56) ^ o4, B4 = (t3 ^ y4 ^ c4 >>> 7) + B4 | 0, o4 = B4 = o4 >>> 0 > (S4 = o4 + I7 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[a4 >> 2] = S4, E3[a4 + 4 >> 2] = B4, D4 = (K4 = E3[G4 >> 2]) + D4 | 0, I7 = (a4 = E3[G4 + 4 >> 2]) + c4 | 0, B4 = D4 >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7, c4 = I7 = E3[k4 + 4 >> 2], I7 = _A(M4 = E3[k4 >> 2], I7, 45), y4 = t3, f4 = D4, D4 = ((63 & c4) << 26 | M4 >>> 6) ^ _A(M4, c4, 3) ^ I7, B4 = (t3 ^ y4 ^ c4 >>> 6) + B4 | 0, D4 = D4 >>> 0 > (f4 = f4 + D4 | 0) >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(y4 = E3[U4 >> 2], I7 = E3[U4 + 4 >> 2], 63), h4 = t3, r4 = f4, f4 = ((127 & I7) << 25 | y4 >>> 7) ^ _A(y4, I7, 56) ^ B4, B4 = (t3 ^ h4 ^ I7 >>> 7) + D4 | 0, D4 = B4 = f4 >>> 0 > (s4 = r4 + f4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 136 >> 2] = s4, E3[_4 + 140 >> 2] = B4, B4 = (G4 = E3[H4 >> 2]) + y4 | 0, I7 = (y4 = E3[H4 + 4 >> 2]) + I7 | 0, f4 = _A(S4, o4, 45), h4 = t3, f4 = (w4 = ((63 & o4) << 26 | S4 >>> 6) ^ _A(S4, o4, 3) ^ f4) + B4 | 0, B4 = (t3 ^ h4 ^ o4 >>> 6) + (B4 >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = f4 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, h4 = I7 = E3[R4 + 4 >> 2], I7 = _A(w4 = E3[R4 >> 2], I7, 63), F4 = t3, r4 = f4, f4 = ((127 & h4) << 25 | w4 >>> 7) ^ _A(w4, h4, 56) ^ I7, B4 = (t3 ^ F4 ^ h4 >>> 7) + B4 | 0, f4 = B4 = f4 >>> 0 > (p4 = r4 + f4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 144 >> 2] = p4, E3[_4 + 148 >> 2] = B4, w4 = (v4 = E3[x4 >> 2]) + w4 | 0, I7 = (I7 = h4) + (h4 = E3[x4 + 4 >> 2]) | 0, B4 = w4 >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7, I7 = _A(s4, D4, 45), F4 = t3, n4 = ((63 & D4) << 26 | s4 >>> 6) ^ _A(s4, D4, 3) ^ I7, B4 = (t3 ^ F4 ^ D4 >>> 6) + B4 | 0, B4 = (w4 = n4 + w4 | 0) >>> 0 < n4 >>> 0 ? B4 + 1 | 0 : B4, F4 = I7 = E3[P4 + 4 >> 2], I7 = _A(n4 = E3[P4 >> 2], I7, 63), k4 = t3, r4 = w4, w4 = ((127 & F4) << 25 | n4 >>> 7) ^ _A(n4, F4, 56) ^ I7, B4 = (t3 ^ k4 ^ F4 >>> 7) + B4 | 0, w4 = B4 = w4 >>> 0 > (U4 = r4 + w4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 152 >> 2] = U4, E3[_4 + 156 >> 2] = B4, I7 = (R4 = E3[m4 >> 2]) + n4 | 0, B4 = (B4 = F4) + (F4 = E3[m4 + 4 >> 2]) | 0, n4 = _A(p4, f4, 45), k4 = t3, n4 = ((63 & f4) << 26 | p4 >>> 6) ^ _A(p4, f4, 3) ^ n4, B4 = (t3 ^ k4 ^ f4 >>> 6) + (I7 >>> 0 < R4 >>> 0 ? B4 + 1 | 0 : B4) | 0, n4 = (r4 = n4 + I7 | 0) >>> 0 < n4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(k4 = E3[d4 >> 2], I7 = E3[d4 + 4 >> 2], 63), P4 = t3, H4 = r4, r4 = ((127 & I7) << 25 | k4 >>> 7) ^ (B4 = _A(k4, I7, 56) ^ B4), B4 = (I7 >>> 7 ^ (d4 = t3 ^ P4)) + n4 | 0, n4 = B4 = r4 >>> 0 > (P4 = H4 + r4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 160 >> 2] = P4, E3[_4 + 164 >> 2] = B4, I7 = I7 + Q4 | 0, I7 = (B4 = k4 + N4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, k4 = _A(U4, w4, 45), r4 = t3, k4 = (d4 = ((63 & w4) << 26 | U4 >>> 6) ^ _A(U4, w4, 3) ^ k4) + B4 | 0, B4 = (t3 ^ r4 ^ w4 >>> 6) + I7 | 0, B4 = k4 >>> 0 < d4 >>> 0 ? B4 + 1 | 0 : B4, r4 = E3[Y4 >> 2], Y4 = I7 = E3[Y4 + 4 >> 2], I7 = _A(r4, I7, 63), d4 = t3, I7 = _A(r4, Y4, 56) ^ I7, H4 = k4, B4 = (Y4 >>> 7 ^ (J4 = t3 ^ d4)) + B4 | 0, k4 = B4 = (k4 = ((127 & Y4) << 25 | r4 >>> 7) ^ I7) >>> 0 > (d4 = H4 + k4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 168 >> 2] = d4, E3[_4 + 172 >> 2] = B4, I7 = c4 + Y4 | 0, I7 = (B4 = r4 + M4 | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, H4 = r4 = E3[b4 + 4 >> 2], r4 = _A(J4 = E3[b4 >> 2], r4, 63), Y4 = t3, r4 = (b4 = ((127 & H4) << 25 | J4 >>> 7) ^ _A(J4, H4, 56) ^ r4) + B4 | 0, B4 = (t3 ^ Y4 ^ H4 >>> 7) + I7 | 0, I7 = r4 >>> 0 < b4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(P4, n4, 45), Y4 = t3, B4 = _A(P4, n4, 3) ^ B4, b4 = t3 ^ Y4, Y4 = r4, I7 = (n4 >>> 6 ^ b4) + I7 | 0, r4 = I7 = (r4 = ((63 & n4) << 26 | P4 >>> 6) ^ B4) >>> 0 > (Y4 = Y4 + r4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 176 >> 2] = Y4, E3[_4 + 180 >> 2] = I7, x4 = E3[L4 >> 2], L4 = I7 = E3[L4 + 4 >> 2], b4 = I7, I7 = _A(u4, e4, 63), B4 = t3, m4 = ((127 & e4) << 25 | u4 >>> 7) ^ _A(u4, e4, 56) ^ I7, I7 = (t3 ^ B4 ^ e4 >>> 7) + D4 | 0, B4 = ((s4 = m4 + s4 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, B4 = (I7 = s4 + x4 | 0) >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4, D4 = _A(Y4, r4, 45), s4 = t3, b4 = (D4 = ((63 & r4) << 26 | Y4 >>> 6) ^ _A(Y4, r4, 3) ^ D4) + I7 | 0, I7 = (t3 ^ s4 ^ r4 >>> 6) + B4 | 0, D4 = I7 = D4 >>> 0 > b4 >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 192 >> 2] = b4, E3[_4 + 196 >> 2] = I7, B4 = o4 + H4 | 0, B4 = (I7 = S4 + J4 | 0) >>> 0 < J4 >>> 0 ? B4 + 1 | 0 : B4, s4 = _A(x4, L4, 63), J4 = t3, H4 = ((127 & L4) << 25 | x4 >>> 7) ^ _A(x4, L4, 56) ^ s4, B4 = (t3 ^ J4 ^ L4 >>> 7) + B4 | 0, I7 = (s4 = H4 + I7 | 0) >>> 0 < H4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(d4, k4, 45), J4 = t3, B4 = _A(d4, k4, 3) ^ B4, L4 = s4, I7 = (k4 >>> 6 ^ (H4 = t3 ^ J4)) + I7 | 0, s4 = I7 = (s4 = ((63 & k4) << 26 | d4 >>> 6) ^ B4) >>> 0 > (J4 = L4 + s4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 184 >> 2] = J4, E3[_4 + 188 >> 2] = I7, I7 = _A(G4, y4, 63), B4 = t3, I7 = ((127 & y4) << 25 | G4 >>> 7) ^ _A(G4, y4, 56) ^ I7, B4 = (t3 ^ B4 ^ y4 >>> 7) + a4 | 0, I7 = w4 + (I7 >>> 0 > (H4 = I7 + K4 | 0) >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = U4 + H4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, w4 = _A(b4, D4, 45), U4 = t3, w4 = _A(b4, D4, 3) ^ w4, H4 = t3 ^ U4, U4 = (w4 ^= (63 & D4) << 26 | b4 >>> 6) + B4 | 0, B4 = (D4 >>> 6 ^ H4) + I7 | 0, w4 = B4 = w4 >>> 0 > U4 >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 208 >> 2] = U4, E3[_4 + 212 >> 2] = B4, I7 = _A(K4, a4, 63), B4 = t3, H4 = _A(K4, a4, 56) ^ I7, B4 = ((I7 = a4 >>> 7 | 0) ^ t3 ^ B4) + e4 | 0, I7 = f4 + ((a4 = (K4 = H4 ^ ((127 & a4) << 25 | K4 >>> 7)) + u4 | 0) >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = a4 + p4 | 0) >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7, e4 = _A(J4, s4, 45), a4 = t3, f4 = (e4 = ((63 & s4) << 26 | J4 >>> 6) ^ _A(J4, s4, 3) ^ e4) + B4 | 0, B4 = (t3 ^ a4 ^ s4 >>> 6) + I7 | 0, e4 = B4 = e4 >>> 0 > f4 >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 200 >> 2] = f4, E3[_4 + 204 >> 2] = B4, I7 = _A(R4, F4, 63), B4 = t3, K4 = ((127 & F4) << 25 | R4 >>> 7) ^ _A(R4, F4, 56) ^ I7, I7 = (t3 ^ B4 ^ F4 >>> 7) + h4 | 0, B4 = k4 + ((a4 = K4 + v4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (I7 = a4 + d4 | 0) >>> 0 < d4 >>> 0 ? B4 + 1 | 0 : B4, a4 = _A(U4, w4, 45), k4 = t3, K4 = I7, I7 = w4 >>> 6 | 0, a4 = ((63 & w4) << 26 | U4 >>> 6) ^ _A(U4, w4, 3) ^ a4, B4 = (I7 ^ t3 ^ k4) + B4 | 0, a4 = B4 = a4 >>> 0 > (w4 = K4 + a4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 224 >> 2] = w4, E3[_4 + 228 >> 2] = B4, I7 = _A(v4, h4, 63), B4 = t3, I7 = _A(v4, h4, 56) ^ I7, k4 = t3 ^ B4, K4 = ((127 & h4) << 25 | v4 >>> 7) ^ I7, I7 = ((B4 = h4 >>> 7 | 0) ^ k4) + y4 | 0, B4 = n4 + ((h4 = K4 + G4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (I7 = h4 + P4 | 0) >>> 0 < P4 >>> 0 ? B4 + 1 | 0 : B4, y4 = _A(f4, e4, 45), h4 = t3, k4 = I7, I7 = e4 >>> 6 | 0, e4 = ((63 & e4) << 26 | f4 >>> 6) ^ _A(f4, e4, 3) ^ y4, I7 = (I7 ^ t3 ^ h4) + B4 | 0, e4 = I7 = (y4 = k4 + e4 | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 216 >> 2] = y4, E3[_4 + 220 >> 2] = I7, I7 = _A(M4, c4, 63), B4 = t3, h4 = ((127 & c4) << 25 | M4 >>> 7) ^ _A(M4, c4, 56) ^ I7, B4 = (t3 ^ B4 ^ c4 >>> 7) + Q4 | 0, B4 = s4 + ((I7 = h4 + N4 | 0) >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (f4 = I7 + J4 | 0) >>> 0 < J4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(w4, a4, 45), h4 = t3, k4 = f4, f4 = _A(w4, a4, 3) ^ B4, B4 = a4 >>> 6 | 0, a4 = k4 + (f4 ^= (63 & a4) << 26 | w4 >>> 6) | 0, I7 = (B4 ^ t3 ^ h4) + I7 | 0, E3[_4 + 240 >> 2] = a4, E3[_4 + 244 >> 2] = a4 >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7, I7 = _A(N4, Q4, 63), B4 = t3, I7 = _A(N4, Q4, 56) ^ I7, a4 = t3 ^ B4, B4 = ((B4 = Q4 >>> 7 | 0) ^ a4) + F4 | 0, I7 = r4 + ((I7 ^= (127 & Q4) << 25 | N4 >>> 7) >>> 0 > (Q4 = I7 + R4 | 0) >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = Q4 + Y4 | 0) >>> 0 < Y4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(y4, e4, 45), a4 = t3, f4 = B4, B4 = e4 >>> 6 | 0, Q4 = ((63 & e4) << 26 | y4 >>> 6) ^ _A(y4, e4, 3) ^ Q4, B4 = (B4 ^ t3 ^ a4) + I7 | 0, Q4 = B4 = Q4 >>> 0 > (e4 = f4 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 232 >> 2] = e4, E3[_4 + 236 >> 2] = B4, I7 = _A(S4, o4, 63), B4 = t3, f4 = _A(S4, o4, 56) ^ I7, B4 = ((I7 = o4 >>> 7 | 0) ^ t3 ^ B4) + c4 | 0, I7 = D4 + ((o4 = (a4 = f4 ^ ((127 & o4) << 25 | S4 >>> 7)) + M4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = o4 + b4 | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, o4 = _A(e4, Q4, 45), c4 = t3, f4 = B4, B4 = Q4 >>> 6 | 0, Q4 = f4 + (o4 = ((63 & Q4) << 26 | e4 >>> 6) ^ _A(e4, Q4, 3) ^ o4) | 0, B4 = (B4 ^ t3 ^ c4) + I7 | 0, E3[_4 + 248 >> 2] = Q4, E3[_4 + 252 >> 2] = Q4 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4; + I7 = I7 + E3[A8 + 4 >> 2] | 0, I7 = (g6 = Q4 + E3[A8 >> 2] | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[A8 >> 2] = g6, E3[A8 + 4 >> 2] = I7, B4 = E3[A8 + 12 >> 2] + E3[C4 + 12 >> 2] | 0, I7 = (g6 = E3[C4 + 8 >> 2]) + E3[A8 + 8 >> 2] | 0, E3[A8 + 8 >> 2] = I7, E3[A8 + 12 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, B4 = E3[A8 + 20 >> 2] + E3[C4 + 20 >> 2] | 0, I7 = (g6 = E3[C4 + 16 >> 2]) + E3[A8 + 16 >> 2] | 0, E3[A8 + 16 >> 2] = I7, E3[A8 + 20 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, I7 = E3[A8 + 28 >> 2] + E3[C4 + 28 >> 2] | 0, g6 = (B4 = E3[C4 + 24 >> 2]) + E3[A8 + 24 >> 2] | 0, E3[A8 + 24 >> 2] = g6, E3[A8 + 28 >> 2] = g6 >>> 0 < B4 >>> 0 ? I7 + 1 | 0 : I7, B4 = E3[A8 + 36 >> 2] + E3[C4 + 36 >> 2] | 0, I7 = (g6 = E3[C4 + 32 >> 2]) + E3[A8 + 32 >> 2] | 0, E3[A8 + 32 >> 2] = I7, E3[A8 + 36 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, I7 = E3[A8 + 44 >> 2] + E3[C4 + 44 >> 2] | 0, g6 = (B4 = E3[C4 + 40 >> 2]) + E3[A8 + 40 >> 2] | 0, E3[A8 + 40 >> 2] = g6, E3[A8 + 44 >> 2] = g6 >>> 0 < B4 >>> 0 ? I7 + 1 | 0 : I7, B4 = E3[A8 + 52 >> 2] + E3[C4 + 52 >> 2] | 0, I7 = (g6 = E3[C4 + 48 >> 2]) + E3[A8 + 48 >> 2] | 0, E3[A8 + 48 >> 2] = I7, E3[A8 + 52 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, B4 = E3[A8 + 60 >> 2] + E3[C4 + 60 >> 2] | 0, I7 = (g6 = E3[C4 + 56 >> 2]) + E3[A8 + 56 >> 2] | 0, E3[A8 + 56 >> 2] = I7, E3[A8 + 60 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4; + } + function s3(A8) { + var I7, g6, B4, Q4, E4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0; + h4 = (G4 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24) >>> 5 & 2097151, r4 = PA(I7 = (i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24) >>> 3 | 0, 0, -683901, -1), w4 = (e4 = i3[A8 + 44 | 0]) << 16 & 2031616 | i3[A8 + 42 | 0] | i3[A8 + 43 | 0] << 8, e4 = t3, F4 = e4 = w4 >>> 0 > (M4 = r4 + w4 | 0) >>> 0 ? e4 + 1 | 0 : e4, p4 = e4 = e4 - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, r4 = e4 >> 21, e4 = (w4 = h4) + (h4 = (2097151 & e4) << 11 | (n4 = M4 - -1048576 | 0) >>> 21) | 0, w4 = r4, P4 = w4 = e4 >>> 0 < h4 >>> 0 ? w4 + 1 | 0 : w4, z2 = e4, _4 = PA(e4, w4, -683901, -1), S4 = t3, s4 = PA(g6 = (i3[A8 + 49 | 0] | i3[A8 + 50 | 0] << 8 | i3[A8 + 51 | 0] << 16 | i3[A8 + 52 | 0] << 24) >>> 7 & 2097151, 0, -997805, -1), r4 = (e4 = i3[A8 + 27 | 0]) >>> 24 | 0, h4 = e4 << 8 | (H4 = i3[A8 + 23 | 0] | i3[A8 + 24 | 0] << 8 | i3[A8 + 25 | 0] << 16 | i3[A8 + 26 | 0] << 24) >>> 24, w4 = (e4 = i3[A8 + 28 | 0]) >>> 16 | 0, w4 = 2097151 & ((3 & (w4 |= r4)) << 30 | (e4 = h4 | e4 << 16) >>> 2), e4 = t3, e4 = w4 >>> 0 > (r4 = w4 + s4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(q4 = (N4 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24) >>> 4 & 2097151, 0, 654183, 0), e4 = t3 + e4 | 0, s4 = r4 = w4 + r4 | 0, r4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, k4 = (w4 = i3[A8 + 48 | 0]) << 8 | G4 >>> 24, w4 = e4 = w4 >>> 24 | 0, e4 = PA(B4 = 2097151 & ((3 & (G4 = (e4 = (h4 = i3[A8 + 49 | 0]) >>> 16 | 0) | w4)) << 30 | (w4 = (h4 <<= 16) | k4) >>> 2), 0, 136657, 0), r4 = t3 + r4 | 0, r4 = e4 >>> 0 > (w4 = e4 + s4 | 0) >>> 0 ? r4 + 1 | 0 : r4, h4 = (e4 = PA(Q4 = (i3[A8 + 57 | 0] | i3[A8 + 58 | 0] << 8 | i3[A8 + 59 | 0] << 16 | i3[A8 + 60 | 0] << 24) >>> 6 & 2097151, 0, 666643, 0)) + w4 | 0, w4 = t3 + r4 | 0, s4 = h4, r4 = e4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, w4 = (e4 = i3[A8 + 56 | 0]) >>> 24 | 0, k4 = e4 << 8 | N4 >>> 24, w4 = PA(E4 = 2097151 & ((1 & (N4 = (e4 = (h4 = i3[A8 + 57 | 0]) >>> 16 | 0) | w4)) << 31 | (w4 = (h4 <<= 16) | k4) >>> 1), 0, 470296, 0), e4 = t3 + r4 | 0, w4 = (e4 = (r4 = h4 = w4 + s4 | 0) >>> 0 < w4 >>> 0 ? e4 + 1 | 0 : e4) + S4 | 0, w4 = r4 >>> 0 > (h4 = r4 + _4 | 0) >>> 0 ? w4 + 1 | 0 : w4, J4 = r4 - -1048576 | 0, v4 = r4 = e4 - ((r4 >>> 0 < 4293918720) - 1 | 0) | 0, S4 = h4 - (e4 = -2097152 & J4) | 0, _4 = w4 - ((e4 >>> 0 > h4 >>> 0) + r4 | 0) | 0, w4 = PA(g6, 0, 654183, 0), e4 = t3, e4 = w4 >>> 0 > (r4 = w4 + (H4 >>> 5 & 2097151) | 0) >>> 0 ? e4 + 1 | 0 : e4, h4 = (w4 = r4) + (r4 = PA(q4, 0, 470296, 0)) | 0, w4 = t3 + e4 | 0, w4 = r4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(B4, j2, -997805, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + h4 | 0) >>> 0 ? w4 + 1 | 0 : w4, h4 = (e4 = r4) + (r4 = PA(E4, X2, 666643, 0)) | 0, e4 = t3 + w4 | 0, k4 = h4, h4 = r4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, s4 = (r4 = PA(g6, 0, 470296, 0)) + (e4 = (e4 = i3[A8 + 23 | 0]) << 16 & 2031616 | i3[A8 + 21 | 0] | i3[A8 + 22 | 0] << 8) | 0, r4 = t3, r4 = e4 >>> 0 > s4 >>> 0 ? r4 + 1 | 0 : r4, s4 = (w4 = PA(q4, 0, 666643, 0)) + s4 | 0, e4 = t3 + r4 | 0, r4 = PA(B4, j2, 654183, 0), w4 = t3 + (w4 >>> 0 > s4 >>> 0 ? e4 + 1 | 0 : e4) | 0, N4 = w4 = r4 >>> 0 > (H4 = r4 + s4 | 0) >>> 0 ? w4 + 1 | 0 : w4, m4 = w4 = w4 - ((H4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = (e4 = w4 >>> 21 | 0) + h4 | 0, r4 = e4 = (w4 = (2097151 & w4) << 11 | (s4 = H4 - -1048576 | 0) >>> 21) >>> 0 > (k4 = w4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4, K4 = w4 = e4 - ((k4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = S4, S4 = (2097151 & w4) << 11 | (h4 = k4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + _4 | 0, G4 = S4 = (w4 = S4 >>> 0 > (Y4 = e4 + S4 | 0) >>> 0 ? w4 + 1 | 0 : w4) - ((Y4 >>> 0 < 4293918720) - 1 | 0) | 0, l3 = Y4 - (e4 = -2097152 & (_4 = Y4 - -1048576 | 0)) | 0, O2 = w4 - ((e4 >>> 0 > Y4 >>> 0) + S4 | 0) | 0, e4 = PA(z2, P4, 136657, 0), r4 = t3 + r4 | 0, r4 = e4 >>> 0 > (w4 = e4 + k4 | 0) >>> 0 ? r4 + 1 | 0 : r4, b4 = w4 - (e4 = -2097152 & h4) | 0, U4 = r4 - ((e4 >>> 0 > w4 >>> 0) + K4 | 0) | 0, Y4 = M4 - (e4 = -2097152 & n4) | 0, p4 = F4 - ((e4 >>> 0 > M4 >>> 0) + p4 | 0) | 0, F4 = PA(I7, 0, 136657, 0), w4 = (e4 = i3[A8 + 40 | 0]) >>> 24 | 0, h4 = e4 << 8 | (n4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24) >>> 24, r4 = (e4 = i3[A8 + 41 | 0]) >>> 16 | 0, w4 = (r4 |= w4) >>> 3 | 0, r4 = (7 & r4) << 29 | (e4 = h4 | e4 << 16) >>> 3, e4 = w4 + t3 | 0, e4 = r4 >>> 0 > (h4 = r4 + F4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(Q4, 0, -683901, -1), e4 = t3 + e4 | 0, e4 = w4 >>> 0 > (r4 = w4 + h4 | 0) >>> 0 ? e4 + 1 | 0 : e4, k4 = r4, w4 = PA(I7, 0, -997805, -1), r4 = t3, r4 = w4 >>> 0 > (h4 = w4 + (n4 >>> 6 & 2097151) | 0) >>> 0 ? r4 + 1 | 0 : r4, n4 = (w4 = h4) + (h4 = PA(Q4, 0, 136657, 0)) | 0, w4 = t3 + r4 | 0, r4 = PA(E4, X2, -683901, -1), w4 = t3 + (h4 >>> 0 > n4 >>> 0 ? w4 + 1 | 0 : w4) | 0, S4 = w4 = r4 >>> 0 > (R4 = r4 + n4 | 0) >>> 0 ? w4 + 1 | 0 : w4, T2 = r4 = w4 - ((R4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = e4 + (w4 = r4 >> 21) | 0, n4 = e4 = (r4 = (2097151 & r4) << 11 | (M4 = R4 - -1048576 | 0) >>> 21) >>> 0 > (K4 = r4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4, L4 = e4 = e4 - ((K4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (w4 = e4 >> 21) + p4 | 0, u4 = w4 = (e4 = (r4 = (2097151 & e4) << 11 | (k4 = K4 - -1048576 | 0) >>> 21) + Y4 | 0) >>> 0 < r4 >>> 0 ? w4 + 1 | 0 : w4, x4 = e4, w4 = PA(e4, w4, -683901, -1), e4 = t3 + U4 | 0, d4 = r4 = w4 + b4 | 0, h4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, Y4 = H4 - (e4 = -2097152 & s4) | 0, p4 = N4 - ((4095 & m4) + (e4 >>> 0 > H4 >>> 0) | 0) | 0, H4 = PA(g6, 0, 666643, 0), e4 = (w4 = i3[A8 + 19 | 0]) >>> 24 | 0, s4 = w4 << 8 | (N4 = i3[A8 + 15 | 0] | i3[A8 + 16 | 0] << 8 | i3[A8 + 17 | 0] << 16 | i3[A8 + 18 | 0] << 24) >>> 24, r4 = e4, w4 = (7 & (r4 |= w4 = (e4 = i3[A8 + 20 | 0]) >>> 16 | 0)) << 29 | (w4 = (e4 <<= 16) | s4) >>> 3, r4 = t3 + (r4 >>> 3 | 0) | 0, r4 = w4 >>> 0 > (s4 = w4 + H4 | 0) >>> 0 ? r4 + 1 | 0 : r4, e4 = PA(B4, j2, 470296, 0), w4 = t3 + r4 | 0, e4 = e4 >>> 0 > (s4 = e4 + s4 | 0) >>> 0 ? w4 + 1 | 0 : w4, r4 = PA(B4, j2, 666643, 0), w4 = t3, H4 = w4 = r4 >>> 0 > (b4 = r4 + (N4 >>> 6 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, V2 = r4 = w4 - ((b4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = e4 + (w4 = r4 >>> 21 | 0) | 0, N4 = e4 = (r4 = (2097151 & r4) << 11 | (F4 = b4 - -1048576 | 0) >>> 21) >>> 0 > (U4 = r4 + s4 | 0) >>> 0 ? e4 + 1 | 0 : e4, Z2 = e4 = e4 - ((U4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (w4 = e4 >>> 21 | 0) + p4 | 0, w4 = (e4 = (2097151 & e4) << 11 | (s4 = U4 - -1048576 | 0) >>> 21) >>> 0 > (r4 = e4 + Y4 | 0) >>> 0 ? w4 + 1 | 0 : w4, p4 = (e4 = r4) + (r4 = PA(z2, P4, -997805, -1)) | 0, e4 = t3 + w4 | 0, e4 = r4 >>> 0 > p4 >>> 0 ? e4 + 1 | 0 : e4, m4 = w4 = K4 - (r4 = -2097152 & k4) | 0, o4 = k4 = n4 - ((r4 >>> 0 > K4 >>> 0) + L4 | 0) | 0, r4 = PA(x4, u4, 136657, 0), e4 = t3 + e4 | 0, e4 = r4 >>> 0 > (n4 = r4 + p4 | 0) >>> 0 ? e4 + 1 | 0 : e4, r4 = PA(w4, k4, -683901, -1), w4 = t3 + e4 | 0, n4 = w4 = r4 >>> 0 > (p4 = r4 + n4 | 0) >>> 0 ? w4 + 1 | 0 : w4, L4 = e4 = w4 - ((p4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (2097151 & e4) << 11 | (k4 = p4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + h4 | 0, d4 = w4 = (e4 = w4 >>> 0 > (K4 = w4 + d4 | 0) >>> 0 ? e4 + 1 | 0 : e4) - ((K4 >>> 0 < 4293918720) - 1 | 0) | 0, Y4 = (2097151 & w4) << 11 | (h4 = K4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + O2 | 0, D4 = l3 = Y4 + l3 | 0, Y4 = Y4 >>> 0 > l3 >>> 0 ? w4 + 1 | 0 : w4, a4 = K4 - (w4 = -2097152 & h4) | 0, y4 = e4 - ((w4 >>> 0 > K4 >>> 0) + d4 | 0) | 0, l3 = p4 - (e4 = -2097152 & k4) | 0, O2 = n4 - ((e4 >>> 0 > p4 >>> 0) + L4 | 0) | 0, r4 = (e4 = PA(z2, P4, 654183, 0)) + (U4 - (w4 = -2097152 & s4) | 0) | 0, w4 = t3 + (N4 - ((2147483647 & Z2) + (w4 >>> 0 > U4 >>> 0) | 0) | 0) | 0, w4 = e4 >>> 0 > r4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(x4, u4, -997805, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + r4 | 0) >>> 0 ? w4 + 1 | 0 : w4, h4 = (e4 = r4) + (r4 = PA(m4, o4, 136657, 0)) | 0, e4 = t3 + w4 | 0, d4 = h4, n4 = r4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, U4 = R4 - (e4 = -2097152 & M4) | 0, K4 = S4 - ((e4 >>> 0 > R4 >>> 0) + T2 | 0) | 0, N4 = PA(q4, 0, -683901, -1), e4 = (w4 = i3[A8 + 35 | 0]) >>> 24 | 0, h4 = w4 << 8 | (s4 = i3[A8 + 31 | 0] | i3[A8 + 32 | 0] << 8 | i3[A8 + 33 | 0] << 16 | i3[A8 + 34 | 0] << 24) >>> 24, r4 = e4, w4 = (e4 = i3[A8 + 36 | 0]) >>> 16 | 0, w4 |= r4, r4 = t3, r4 = (e4 = 2097151 & ((1 & w4) << 31 | (e4 = e4 << 16 | h4) >>> 1)) >>> 0 > (w4 = e4 + N4 | 0) >>> 0 ? r4 + 1 | 0 : r4, h4 = (e4 = PA(I7, 0, 654183, 0)) + w4 | 0, w4 = t3 + r4 | 0, w4 = e4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, r4 = PA(Q4, 0, -997805, -1), e4 = t3 + w4 | 0, e4 = r4 >>> 0 > (h4 = r4 + h4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(E4, X2, 136657, 0), e4 = t3 + e4 | 0, k4 = r4 = w4 + h4 | 0, h4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(g6, 0, -683901, -1), w4 = t3, w4 = e4 >>> 0 > (r4 = e4 + (s4 >>> 4 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, s4 = (e4 = PA(q4, 0, 136657, 0)) + r4 | 0, r4 = t3 + w4 | 0, r4 = e4 >>> 0 > s4 >>> 0 ? r4 + 1 | 0 : r4, e4 = PA(I7, 0, 470296, 0), w4 = t3 + r4 | 0, w4 = e4 >>> 0 > (s4 = e4 + s4 | 0) >>> 0 ? w4 + 1 | 0 : w4, s4 = (r4 = PA(Q4, 0, 654183, 0)) + s4 | 0, e4 = t3 + w4 | 0, w4 = PA(E4, X2, -997805, -1), e4 = t3 + (r4 >>> 0 > s4 >>> 0 ? e4 + 1 | 0 : e4) | 0, N4 = e4 = w4 >>> 0 > (S4 = w4 + s4 | 0) >>> 0 ? e4 + 1 | 0 : e4, f4 = w4 = e4 - ((S4 >>> 0 < 4293918720) - 1 | 0) | 0, r4 = (e4 = w4 >> 21) + h4 | 0, p4 = w4 = (r4 = (w4 = (2097151 & w4) << 11 | (s4 = S4 - -1048576 | 0) >>> 21) >>> 0 > (M4 = w4 + k4 | 0) >>> 0 ? r4 + 1 | 0 : r4) - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = (e4 = w4 >> 21) + K4 | 0, L4 = e4 = (w4 = (h4 = (2097151 & w4) << 11 | (k4 = M4 - -1048576 | 0) >>> 21) + U4 | 0) >>> 0 < h4 >>> 0 ? e4 + 1 | 0 : e4, h4 = d4, d4 = w4, e4 = PA(w4, e4, -683901, -1), w4 = t3 + n4 | 0, K4 = h4 = h4 + e4 | 0, h4 = e4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, n4 = (e4 = PA(z2, P4, 470296, 0)) + (b4 - (w4 = -2097152 & F4) | 0) | 0, w4 = t3 + (H4 - ((2047 & V2) + (w4 >>> 0 > b4 >>> 0) | 0) | 0) | 0, w4 = e4 >>> 0 > n4 >>> 0 ? w4 + 1 | 0 : w4, F4 = (e4 = n4) + (n4 = PA(x4, u4, 654183, 0)) | 0, e4 = t3 + w4 | 0, e4 = n4 >>> 0 > F4 >>> 0 ? e4 + 1 | 0 : e4, n4 = PA(m4, o4, -997805, -1), w4 = t3 + e4 | 0, w4 = n4 >>> 0 > (F4 = n4 + F4 | 0) >>> 0 ? w4 + 1 | 0 : w4, R4 = k4 = M4 - (e4 = -2097152 & k4) | 0, c4 = n4 = r4 - ((e4 >>> 0 > M4 >>> 0) + p4 | 0) | 0, r4 = PA(d4, L4, 136657, 0), e4 = t3 + w4 | 0, e4 = r4 >>> 0 > (F4 = r4 + F4 | 0) >>> 0 ? e4 + 1 | 0 : e4, r4 = PA(k4, n4, -683901, -1), w4 = t3 + e4 | 0, n4 = w4 = r4 >>> 0 > (H4 = r4 + F4 | 0) >>> 0 ? w4 + 1 | 0 : w4, U4 = e4 = w4 - ((H4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (2097151 & e4) << 11 | (k4 = H4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + h4 | 0, K4 = w4 = (e4 = w4 >>> 0 > (F4 = w4 + K4 | 0) >>> 0 ? e4 + 1 | 0 : e4) - ((F4 >>> 0 < 4293918720) - 1 | 0) | 0, M4 = (2097151 & w4) << 11 | (h4 = F4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + O2 | 0, T2 = p4 = M4 + l3 | 0, p4 = M4 >>> 0 > p4 >>> 0 ? w4 + 1 | 0 : w4, V2 = F4 - (w4 = -2097152 & h4) | 0, Z2 = e4 - ((w4 >>> 0 > F4 >>> 0) + K4 | 0) | 0, l3 = H4 - (e4 = -2097152 & k4) | 0, O2 = n4 - ((e4 >>> 0 > H4 >>> 0) + U4 | 0) | 0, n4 = PA(z2, P4, 666643, 0), e4 = (w4 = i3[A8 + 14 | 0]) >>> 24 | 0, h4 = w4 << 8 | (K4 = i3[A8 + 10 | 0] | i3[A8 + 11 | 0] << 8 | i3[A8 + 12 | 0] << 16 | i3[A8 + 13 | 0] << 24) >>> 24, r4 = e4, w4 = (e4 = i3[A8 + 15 | 0]) >>> 16 | 0, w4 |= r4, r4 = t3, r4 = (e4 = 2097151 & ((1 & w4) << 31 | (e4 = e4 << 16 | h4) >>> 1)) >>> 0 > (w4 = e4 + n4 | 0) >>> 0 ? r4 + 1 | 0 : r4, h4 = (e4 = w4) + (w4 = PA(x4, u4, 470296, 0)) | 0, e4 = t3 + r4 | 0, e4 = w4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(m4, o4, 654183, 0), e4 = t3 + e4 | 0, e4 = w4 >>> 0 > (r4 = w4 + h4 | 0) >>> 0 ? e4 + 1 | 0 : e4, h4 = (w4 = r4) + (r4 = PA(d4, L4, -997805, -1)) | 0, w4 = t3 + e4 | 0, w4 = r4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(R4, c4, 136657, 0), w4 = t3 + w4 | 0, H4 = r4 = e4 + h4 | 0, h4 = e4 >>> 0 > r4 >>> 0 ? w4 + 1 | 0 : w4, s4 = S4 - (e4 = -2097152 & s4) | 0, n4 = N4 - ((e4 >>> 0 > S4 >>> 0) + f4 | 0) | 0, r4 = PA(g6, 0, 136657, 0), e4 = t3, e4 = (w4 = (i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24) >>> 7 & 2097151) >>> 0 > (r4 = w4 + r4 | 0) >>> 0 ? e4 + 1 | 0 : e4, k4 = (w4 = r4) + (r4 = PA(q4, 0, -997805, -1)) | 0, w4 = t3 + e4 | 0, w4 = r4 >>> 0 > k4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(B4, j2, -683901, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + k4 | 0) >>> 0 ? w4 + 1 | 0 : w4, k4 = (e4 = PA(I7, 0, 666643, 0)) + r4 | 0, r4 = t3 + w4 | 0, r4 = e4 >>> 0 > k4 >>> 0 ? r4 + 1 | 0 : r4, w4 = PA(Q4, 0, 470296, 0), e4 = t3 + r4 | 0, e4 = w4 >>> 0 > (k4 = w4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(E4, X2, 654183, 0), e4 = t3 + e4 | 0, w4 = (v4 >> 21) + (w4 >>> 0 > (r4 = w4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4) | 0, M4 = w4 = (k4 = (2097151 & v4) << 11 | J4 >>> 21) >>> 0 > (J4 = k4 + r4 | 0) >>> 0 ? w4 + 1 | 0 : w4, v4 = e4 = w4 - ((J4 >>> 0 < 4293918720) - 1 | 0) | 0, k4 = (2097151 & e4) << 11 | (F4 = J4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + n4 | 0, b4 = e4 = (w4 = k4 + s4 | 0) >>> 0 < k4 >>> 0 ? e4 + 1 | 0 : e4, U4 = w4, w4 = PA(w4, e4, -683901, -1), e4 = t3 + h4 | 0, k4 = r4 = w4 + H4 | 0, h4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(x4, u4, 666643, 0), w4 = t3, w4 = e4 >>> 0 > (r4 = e4 + (K4 >>> 4 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(m4, o4, 470296, 0), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + r4 | 0) >>> 0 ? w4 + 1 | 0 : w4, n4 = (e4 = PA(d4, L4, 654183, 0)) + r4 | 0, r4 = t3 + w4 | 0, r4 = e4 >>> 0 > n4 >>> 0 ? r4 + 1 | 0 : r4, w4 = PA(R4, c4, -997805, -1), e4 = t3 + r4 | 0, e4 = w4 >>> 0 > (n4 = w4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(U4, b4, 136657, 0), e4 = t3 + e4 | 0, N4 = e4 = w4 >>> 0 > (S4 = w4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, u4 = w4 = e4 - ((S4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = k4, k4 = (2097151 & w4) << 11 | (s4 = S4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + h4 | 0, x4 = h4 = (w4 = (r4 = e4 + k4 | 0) >>> 0 < k4 >>> 0 ? w4 + 1 | 0 : w4) - ((r4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = (e4 = h4 >> 21) + O2 | 0, z2 = k4 = (h4 = (2097151 & h4) << 11 | (n4 = r4 - -1048576 | 0) >>> 21) + l3 | 0, H4 = h4 >>> 0 > k4 >>> 0 ? e4 + 1 | 0 : e4, k4 = r4, r4 = w4, h4 = (J4 - (w4 = -2097152 & F4) | 0) + (F4 = (2097151 & G4) << 11 | _4 >>> 21) | 0, w4 = (M4 - ((w4 >>> 0 > J4 >>> 0) + v4 | 0) | 0) + (G4 >> 21) | 0, K4 = w4 = h4 >>> 0 < F4 >>> 0 ? w4 + 1 | 0 : w4, q4 = w4 = w4 - ((h4 >>> 0 < 4293918720) - 1 | 0) | 0, _4 = e4 = w4 >> 21, e4 = PA(P4 = (2097151 & w4) << 11 | (v4 = h4 - -1048576 | 0) >>> 21, e4, -683901, -1), r4 = t3 + r4 | 0, r4 = e4 >>> 0 > (w4 = e4 + k4 | 0) >>> 0 ? r4 + 1 | 0 : r4, j2 = w4 - (e4 = -2097152 & n4) | 0, X2 = r4 - ((e4 >>> 0 > w4 >>> 0) + x4 | 0) | 0, e4 = PA(P4, _4, 136657, 0), w4 = N4 + t3 | 0, x4 = (r4 = e4 + S4 | 0) - (e4 = -2097152 & s4) | 0, J4 = (w4 = r4 >>> 0 < S4 >>> 0 ? w4 + 1 | 0 : w4) - ((e4 >>> 0 > r4 >>> 0) + u4 | 0) | 0, w4 = PA(m4, o4, 666643, 0), r4 = t3, r4 = (e4 = (i3[A8 + 7 | 0] | i3[A8 + 8 | 0] << 8 | i3[A8 + 9 | 0] << 16 | i3[A8 + 10 | 0] << 24) >>> 7 & 2097151) >>> 0 > (w4 = e4 + w4 | 0) >>> 0 ? r4 + 1 | 0 : r4, k4 = (e4 = PA(d4, L4, 470296, 0)) + w4 | 0, w4 = t3 + r4 | 0, w4 = e4 >>> 0 > k4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(R4, c4, 654183, 0), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + k4 | 0) >>> 0 ? w4 + 1 | 0 : w4, k4 = (e4 = r4) + (r4 = PA(U4, b4, -997805, -1)) | 0, e4 = t3 + w4 | 0, F4 = k4, k4 = r4 >>> 0 > k4 >>> 0 ? e4 + 1 | 0 : e4, N4 = PA(d4, L4, 666643, 0), e4 = (w4 = i3[A8 + 6 | 0]) >>> 24 | 0, n4 = w4 << 8 | (u4 = i3[A8 + 2 | 0] | i3[A8 + 3 | 0] << 8 | i3[A8 + 4 | 0] << 16 | i3[A8 + 5 | 0] << 24) >>> 24, r4 = e4, w4 = (e4 = i3[A8 + 7 | 0]) >>> 16 | 0, w4 = 2097151 & ((3 & (w4 |= r4)) << 30 | (e4 = e4 << 16 | n4) >>> 2), e4 = t3, e4 = w4 >>> 0 > (r4 = w4 + N4 | 0) >>> 0 ? e4 + 1 | 0 : e4, n4 = (w4 = PA(R4, c4, 470296, 0)) + r4 | 0, r4 = t3 + e4 | 0, r4 = w4 >>> 0 > n4 >>> 0 ? r4 + 1 | 0 : r4, w4 = PA(U4, b4, 654183, 0), e4 = t3 + r4 | 0, N4 = e4 = w4 >>> 0 > (M4 = w4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, G4 = e4 = e4 - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (r4 = e4 >> 21) + k4 | 0, S4 = e4 = (w4 = (e4 = (2097151 & e4) << 11 | (s4 = M4 - -1048576 | 0) >>> 21) >>> 0 > (n4 = e4 + F4 | 0) >>> 0 ? w4 + 1 | 0 : w4) - ((n4 >>> 0 < 4293918720) - 1 | 0) | 0, F4 = (2097151 & e4) << 11 | (k4 = n4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + J4 | 0, x4 = d4 = F4 + x4 | 0, F4 = F4 >>> 0 > d4 >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(P4, _4, -997805, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + n4 | 0) >>> 0 ? w4 + 1 | 0 : w4, m4 = r4 - (e4 = -2097152 & k4) | 0, L4 = w4 - ((e4 >>> 0 > r4 >>> 0) + S4 | 0) | 0, w4 = PA(P4, _4, 654183, 0), e4 = N4 + t3 | 0, d4 = (r4 = w4 + M4 | 0) - (w4 = -2097152 & s4) | 0, J4 = (e4 = r4 >>> 0 < M4 >>> 0 ? e4 + 1 | 0 : e4) - ((w4 >>> 0 > r4 >>> 0) + G4 | 0) | 0, e4 = PA(R4, c4, 666643, 0), w4 = t3, w4 = e4 >>> 0 > (r4 = e4 + (u4 >>> 5 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(U4, b4, 470296, 0), w4 = t3 + w4 | 0, n4 = r4 = e4 + r4 | 0, r4 = e4 >>> 0 > r4 >>> 0 ? w4 + 1 | 0 : w4, k4 = PA(U4, b4, 666643, 0), w4 = (e4 = i3[A8 + 2 | 0]) << 16 & 2031616 | i3[0 | A8] | i3[A8 + 1 | 0] << 8, e4 = t3, N4 = e4 = w4 >>> 0 > (S4 = k4 + w4 | 0) >>> 0 ? e4 + 1 | 0 : e4, b4 = e4 = e4 - ((S4 >>> 0 < 4293918720) - 1 | 0) | 0, k4 = (2097151 & e4) << 11 | (s4 = S4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + r4 | 0, r4 = e4 = k4 >>> 0 > (M4 = k4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, G4 = e4 = e4 - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, k4 = (2097151 & e4) << 11 | (n4 = M4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + J4 | 0, k4 = k4 >>> 0 > (U4 = k4 + d4 | 0) >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(P4, _4, 470296, 0), r4 = r4 + t3 | 0, r4 = (w4 = e4 + M4 | 0) >>> 0 < M4 >>> 0 ? r4 + 1 | 0 : r4, M4 = w4 - (e4 = -2097152 & n4) | 0, n4 = r4 - ((e4 >>> 0 > w4 >>> 0) + G4 | 0) | 0, w4 = PA(P4, _4, 666643, 0), e4 = t3 + (N4 - (((r4 = -2097152 & s4) >>> 0 > S4 >>> 0) + b4 | 0) | 0) | 0, w4 = (r4 = (e4 = w4 >>> 0 > (J4 = w4 + (S4 - r4 | 0) | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + n4 | 0, e4 = (e4 = (w4 = (e4 = (2097151 & e4) << 11 | J4 >>> 21) >>> 0 > (G4 = e4 + M4 | 0) >>> 0 ? w4 + 1 | 0 : w4) >> 21) + k4 | 0, w4 = (w4 = (e4 = (w4 = (2097151 & w4) << 11 | G4 >>> 21) >>> 0 > (_4 = w4 + U4 | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + L4 | 0, r4 = (e4 = (w4 = (e4 = (2097151 & e4) << 11 | _4 >>> 21) >>> 0 > (k4 = e4 + m4 | 0) >>> 0 ? w4 + 1 | 0 : w4) >> 21) + F4 | 0, e4 = (w4 = (r4 = (w4 = (2097151 & w4) << 11 | k4 >>> 21) >>> 0 > (S4 = w4 + x4 | 0) >>> 0 ? r4 + 1 | 0 : r4) >> 21) + X2 | 0, w4 = (r4 = (e4 = (r4 = (2097151 & r4) << 11 | S4 >>> 21) >>> 0 > (M4 = r4 + j2 | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + H4 | 0, H4 = n4 = (e4 = (2097151 & e4) << 11 | M4 >>> 21) + z2 | 0, e4 = (e4 = (w4 = e4 >>> 0 > n4 >>> 0 ? w4 + 1 | 0 : w4) >> 21) + Z2 | 0, w4 = (w4 = (e4 = (w4 = (2097151 & w4) << 11 | n4 >>> 21) >>> 0 > (F4 = w4 + V2 | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + p4 | 0, r4 = (e4 = (w4 = (e4 = (2097151 & e4) << 11 | F4 >>> 21) >>> 0 > (N4 = e4 + T2 | 0) >>> 0 ? w4 + 1 | 0 : w4) >> 21) + y4 | 0, e4 = (w4 = (r4 = (w4 = (2097151 & w4) << 11 | N4 >>> 21) >>> 0 > (s4 = w4 + a4 | 0) >>> 0 ? r4 + 1 | 0 : r4) >> 21) + Y4 | 0, v4 = (p4 = h4 - (w4 = -2097152 & v4) | 0) + ((2097151 & (e4 = (r4 = (2097151 & r4) << 11 | s4 >>> 21) >>> 0 > (n4 = r4 + D4 | 0) >>> 0 ? e4 + 1 | 0 : e4)) << 11 | n4 >>> 21) | 0, e4 = (K4 - ((w4 >>> 0 > h4 >>> 0) + q4 | 0) | 0) + (e4 >> 21) | 0, K4 = w4 = (e4 = p4 >>> 0 > v4 >>> 0 ? e4 + 1 | 0 : e4) >> 21, J4 = (e4 = PA(Y4 = (2097151 & e4) << 11 | v4 >>> 21, w4, 666643, 0)) + (w4 = 2097151 & J4) | 0, e4 = t3, h4 = e4 = w4 >>> 0 > J4 >>> 0 ? e4 + 1 | 0 : e4, C3[0 | A8] = J4, C3[A8 + 1 | 0] = (255 & e4) << 24 | J4 >>> 8, e4 = 2097151 & G4, w4 = PA(Y4, K4, 470296, 0) + e4 | 0, r4 = t3, e4 = (h4 >> 21) + (e4 >>> 0 > w4 >>> 0 ? r4 + 1 | 0 : r4) | 0, e4 = (p4 = (2097151 & h4) << 11 | J4 >>> 21) >>> 0 > (G4 = p4 + w4 | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 4 | 0] = (2047 & e4) << 21 | G4 >>> 11, w4 = e4, r4 = G4, C3[A8 + 3 | 0] = (7 & e4) << 29 | r4 >>> 3, C3[A8 + 2 | 0] = 31 & ((65535 & h4) << 16 | J4 >>> 16) | r4 << 5, h4 = 2097151 & _4, _4 = PA(Y4, K4, 654183, 0) + h4 | 0, e4 = t3, G4 = (2097151 & w4) << 11 | r4 >>> 21, w4 = (w4 >> 21) + (h4 = h4 >>> 0 > _4 >>> 0 ? e4 + 1 | 0 : e4) | 0, e4 = w4 = (_4 = G4 + _4 | 0) >>> 0 < G4 >>> 0 ? w4 + 1 | 0 : w4, C3[A8 + 6 | 0] = (63 & e4) << 26 | _4 >>> 6, h4 = _4, _4 = 0, C3[A8 + 5 | 0] = _4 << 13 | (1572864 & r4) >>> 19 | h4 << 2, r4 = 2097151 & k4, k4 = PA(Y4, K4, -997805, -1) + r4 | 0, w4 = t3, w4 = r4 >>> 0 > k4 >>> 0 ? w4 + 1 | 0 : w4, _4 = (2097151 & (r4 = e4)) << 11 | h4 >>> 21, r4 = (e4 >>= 21) + w4 | 0, r4 = (k4 = _4 + k4 | 0) >>> 0 < _4 >>> 0 ? r4 + 1 | 0 : r4, C3[A8 + 9 | 0] = (511 & r4) << 23 | k4 >>> 9, C3[A8 + 8 | 0] = (1 & r4) << 31 | k4 >>> 1, w4 = 0, C3[A8 + 7 | 0] = w4 << 18 | (2080768 & h4) >>> 14 | k4 << 7, w4 = 2097151 & S4, h4 = PA(Y4, K4, 136657, 0) + w4 | 0, e4 = t3, e4 = w4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, S4 = (2097151 & (w4 = r4)) << 11 | k4 >>> 21, w4 = e4 + (r4 = w4 >> 21) | 0, w4 = (h4 = S4 + h4 | 0) >>> 0 < S4 >>> 0 ? w4 + 1 | 0 : w4, C3[A8 + 12 | 0] = (4095 & w4) << 20 | h4 >>> 12, r4 = h4, C3[A8 + 11 | 0] = (15 & w4) << 28 | r4 >>> 4, h4 = 0, C3[A8 + 10 | 0] = h4 << 15 | (1966080 & k4) >>> 17 | r4 << 4, h4 = 2097151 & M4, k4 = PA(Y4, K4, -683901, -1) + h4 | 0, e4 = t3, e4 = h4 >>> 0 > k4 >>> 0 ? e4 + 1 | 0 : e4, h4 = w4, w4 = e4 + (w4 >>= 21) | 0, w4 = (h4 = (d4 = k4) + (k4 = (2097151 & h4) << 11 | r4 >>> 21) | 0) >>> 0 < k4 >>> 0 ? w4 + 1 | 0 : w4, C3[A8 + 14 | 0] = (127 & w4) << 25 | h4 >>> 7, k4 = 0, C3[A8 + 13 | 0] = k4 << 12 | (1048576 & r4) >>> 20 | h4 << 1, e4 = w4 >> 21, r4 = (w4 = (2097151 & w4) << 11 | h4 >>> 21) >>> 0 > (k4 = w4 + (2097151 & H4) | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 17 | 0] = (1023 & r4) << 22 | k4 >>> 10, C3[A8 + 16 | 0] = (3 & r4) << 30 | k4 >>> 2, w4 = 0, C3[A8 + 15 | 0] = w4 << 17 | (2064384 & h4) >>> 15 | k4 << 6, e4 = r4 >> 21, e4 = (w4 = (2097151 & r4) << 11 | k4 >>> 21) >>> 0 > (r4 = w4 + (2097151 & F4) | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 20 | 0] = (8191 & e4) << 19 | r4 >>> 13, C3[A8 + 19 | 0] = (31 & e4) << 27 | r4 >>> 5, h4 = (w4 = 2097151 & N4) + (N4 = (2097151 & e4) << 11 | r4 >>> 21) | 0, w4 = e4 >> 21, w4 = h4 >>> 0 < N4 >>> 0 ? w4 + 1 | 0 : w4, N4 = h4, C3[A8 + 21 | 0] = h4, F4 = 0, C3[A8 + 18 | 0] = F4 << 14 | (1835008 & k4) >>> 18 | r4 << 3, C3[A8 + 22 | 0] = (255 & w4) << 24 | h4 >>> 8, r4 = w4 >> 21, r4 = (h4 = (k4 = (2097151 & w4) << 11 | h4 >>> 21) + (2097151 & s4) | 0) >>> 0 < k4 >>> 0 ? r4 + 1 | 0 : r4, C3[A8 + 25 | 0] = (2047 & r4) << 21 | h4 >>> 11, C3[A8 + 24 | 0] = (7 & r4) << 29 | h4 >>> 3, C3[A8 + 23 | 0] = 31 & ((65535 & w4) << 16 | N4 >>> 16) | h4 << 5, e4 = r4 >> 21, e4 = (w4 = (2097151 & r4) << 11 | h4 >>> 21) >>> 0 > (r4 = w4 + (2097151 & n4) | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 27 | 0] = (63 & e4) << 26 | r4 >>> 6, k4 = 0, C3[A8 + 26 | 0] = k4 << 13 | (1572864 & h4) >>> 19 | r4 << 2, w4 = e4, e4 >>= 21, w4 = (h4 = (n4 = (2097151 & w4) << 11 | r4 >>> 21) + (k4 = 2097151 & v4) | 0) >>> 0 < k4 >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 31 | 0] = (131071 & w4) << 15 | h4 >>> 17, e4 = h4, C3[A8 + 30 | 0] = (511 & w4) << 23 | e4 >>> 9, h4 = 0, C3[A8 + 28 | 0] = h4 << 18 | (2080768 & r4) >>> 14 | e4 << 7, C3[A8 + 29 | 0] = n4 + v4 >>> 1; + } + function F3(A8, I7, g6, B4, Q4, o4) { + var D4, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, l3 = 0, z2 = 0, j2 = 0, V2 = 0, Z2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0; + for (r3 = D4 = r3 - 592 | 0, p4 = -1, S4 = A8 + 32 | 0, F4 = 32, N4 = 1; H4 = i3[2656 + (w4 = F4 - 1 | 0) | 0], f4 |= (w4 = ((y4 = i3[w4 + S4 | 0]) ^ H4) - 1 >> 8 & N4) & (t4 = i3[S4 + (F4 = F4 - 2 | 0) | 0]) - (e4 = i3[F4 + 2656 | 0]) >> 8 | y4 - H4 >> 8 & N4, N4 = w4 & (e4 ^ t4) - 1 >> 8, F4; ) ; + if (255 & f4 && !(KA(A8) | !(~((127 & ~i3[Q4 + 31 | 0] | i3[Q4 + 1 | 0] & i3[Q4 + 2 | 0] & i3[Q4 + 3 | 0] & i3[Q4 + 4 | 0] & i3[Q4 + 5 | 0] & i3[Q4 + 6 | 0] & i3[Q4 + 7 | 0] & i3[Q4 + 8 | 0] & i3[Q4 + 9 | 0] & i3[Q4 + 10 | 0] & i3[Q4 + 11 | 0] & i3[Q4 + 12 | 0] & i3[Q4 + 13 | 0] & i3[Q4 + 14 | 0] & i3[Q4 + 15 | 0] & i3[Q4 + 16 | 0] & i3[Q4 + 17 | 0] & i3[Q4 + 18 | 0] & i3[Q4 + 19 | 0] & i3[Q4 + 20 | 0] & i3[Q4 + 21 | 0] & i3[Q4 + 22 | 0] & i3[Q4 + 23 | 0] & i3[Q4 + 24 | 0] & i3[Q4 + 25 | 0] & i3[Q4 + 26 | 0] & i3[Q4 + 27 | 0] & i3[Q4 + 28 | 0] & i3[Q4 + 30 | 0] & i3[Q4 + 29 | 0] ^ 255) - 1 & 236 - i3[0 | Q4]) >>> 8 & 1) || KA(Q4) || q3(w4 = D4 + 128 | 0, Q4))) { + for (MA(y4 = D4 + 384 | 0), o4 && W(y4, 35120, 34, 0), W(y4, A8, 32, 0), W(y4, Q4, 32, 0), W(y4, I7, g6, B4), v3(y4, g6 = D4 + 320 | 0), s3(g6), B4 = D4 + 8 | 0, Q4 = 0, I7 = 0, r3 = a4 = r3 - 2272 | 0; o4 = a4 + 2016 | 0, y4 = i3[g6 + (Q4 >>> 3 | 0) | 0], C3[o4 + Q4 | 0] = y4 >>> (6 & Q4) & 1, C3[(f4 = o4) + (o4 = 1 | Q4) | 0] = y4 >>> (7 & o4) & 1, 256 != (0 | (Q4 = Q4 + 2 | 0)); ) ; + for (; ; ) { + I7 = (g6 = I7) + 1 | 0; + A: if (!(g6 >>> 0 > 254) && i3[0 | (f4 = (Q4 = a4 + 2016 | 0) + g6 | 0)]) { + I: if (Q4 = C3[0 | (e4 = I7 + Q4 | 0)]) if ((0 | (Q4 = (y4 = Q4 << 1) + (o4 = C3[0 | f4]) | 0)) <= 15) C3[0 | f4] = Q4, C3[0 | e4] = 0; + else { + if ((0 | (Q4 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = Q4, Q4 = I7; ; ) { + if (!i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + C3[0 | o4] = 1; + break I; + } + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, !o4) break; + } + } + if (!(g6 >>> 0 > 253)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 2 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 2) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (253 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 3 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 3) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 251)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 4 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 4) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (251 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 5 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 5) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 249) && (g6 = C3[0 | (e4 = (Q4 = g6 + 6 | 0) + (a4 + 2016 | 0) | 0)])) if ((0 | (g6 = (y4 = g6 << 6) + (o4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (g6 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = g6; ; ) { + if (i3[0 | (g6 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | g6] = 0, g6 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, g6) continue; + break A; + } + break; + } + C3[0 | g6] = 1; + } else C3[0 | f4] = g6, C3[0 | e4] = 0; + } + } + } + } + } + if (256 == (0 | I7)) break; + } + for (Q4 = 0; I7 = a4 + 1760 | 0, g6 = i3[S4 + (Q4 >>> 3 | 0) | 0], C3[I7 + Q4 | 0] = g6 >>> (6 & Q4) & 1, C3[(o4 = I7) + (I7 = 1 | Q4) | 0] = g6 >>> (7 & I7) & 1, 256 != (0 | (Q4 = Q4 + 2 | 0)); ) ; + for (I7 = 0; ; ) { + I7 = (g6 = I7) + 1 | 0; + A: if (!(g6 >>> 0 > 254) && i3[0 | (f4 = (Q4 = a4 + 1760 | 0) + g6 | 0)]) { + I: if (Q4 = C3[0 | (e4 = I7 + Q4 | 0)]) if ((0 | (Q4 = (y4 = Q4 << 1) + (o4 = C3[0 | f4]) | 0)) <= 15) C3[0 | f4] = Q4, C3[0 | e4] = 0; + else { + if ((0 | (Q4 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = Q4, Q4 = I7; ; ) { + if (!i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + C3[0 | o4] = 1; + break I; + } + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, !o4) break; + } + } + if (!(g6 >>> 0 > 253)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 2 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 2) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (253 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 3 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 3) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 251)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 4 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 4) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (251 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 5 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 5) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 249) && (g6 = C3[0 | (e4 = (Q4 = g6 + 6 | 0) + (a4 + 1760 | 0) | 0)])) if ((0 | (g6 = (y4 = g6 << 6) + (o4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (g6 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = g6; ; ) { + if (i3[0 | (g6 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | g6] = 0, g6 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, g6) continue; + break A; + } + break; + } + C3[0 | g6] = 1; + } else C3[0 | f4] = g6, C3[0 | e4] = 0; + } + } + } + } + } + if (256 == (0 | I7)) break; + } + for (DA(Q4 = a4 + 480 | 0, w4), I7 = E3[w4 + 36 >> 2], E3[a4 + 192 >> 2] = E3[w4 + 32 >> 2], E3[a4 + 196 >> 2] = I7, I7 = E3[w4 + 28 >> 2], E3[a4 + 184 >> 2] = E3[w4 + 24 >> 2], E3[a4 + 188 >> 2] = I7, I7 = E3[w4 + 20 >> 2], E3[a4 + 176 >> 2] = E3[w4 + 16 >> 2], E3[a4 + 180 >> 2] = I7, I7 = E3[w4 + 12 >> 2], E3[a4 + 168 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 172 >> 2] = I7, I7 = E3[w4 + 4 >> 2], E3[a4 + 160 >> 2] = E3[w4 >> 2], E3[a4 + 164 >> 2] = I7, I7 = E3[w4 + 52 >> 2], E3[a4 + 208 >> 2] = E3[w4 + 48 >> 2], E3[a4 + 212 >> 2] = I7, I7 = E3[w4 + 60 >> 2], E3[a4 + 216 >> 2] = E3[w4 + 56 >> 2], E3[a4 + 220 >> 2] = I7, I7 = E3[4 + (g6 = w4 - -64 | 0) >> 2], E3[a4 + 224 >> 2] = E3[g6 >> 2], E3[a4 + 228 >> 2] = I7, I7 = E3[w4 + 76 >> 2], E3[a4 + 232 >> 2] = E3[w4 + 72 >> 2], E3[a4 + 236 >> 2] = I7, I7 = E3[w4 + 44 >> 2], E3[a4 + 200 >> 2] = E3[w4 + 40 >> 2], E3[a4 + 204 >> 2] = I7, I7 = E3[w4 + 92 >> 2], E3[a4 + 248 >> 2] = E3[w4 + 88 >> 2], E3[a4 + 252 >> 2] = I7, I7 = E3[w4 + 100 >> 2], E3[a4 + 256 >> 2] = E3[w4 + 96 >> 2], E3[a4 + 260 >> 2] = I7, I7 = E3[w4 + 108 >> 2], E3[a4 + 264 >> 2] = E3[w4 + 104 >> 2], E3[a4 + 268 >> 2] = I7, I7 = E3[w4 + 116 >> 2], E3[a4 + 272 >> 2] = E3[w4 + 112 >> 2], E3[a4 + 276 >> 2] = I7, I7 = E3[w4 + 84 >> 2], E3[a4 + 240 >> 2] = E3[w4 + 80 >> 2], E3[a4 + 244 >> 2] = I7, _3(o4 = a4 + 320 | 0, g6 = a4 + 160 | 0), M3(a4, o4, h4 = a4 + 440 | 0), M3(a4 + 40 | 0, k4 = a4 + 360 | 0, n4 = a4 + 400 | 0), M3(a4 + 80 | 0, n4, h4), M3(a4 + 120 | 0, o4, k4), X(o4, a4, Q4), M3(g6, o4, h4), M3(G4 = a4 + 200 | 0, k4, n4), M3(J4 = a4 + 240 | 0, n4, h4), M3(K4 = a4 + 280 | 0, o4, k4), DA(I7 = a4 + 640 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 800 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 960 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 1120 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 1280 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 1440 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(a4 + 1600 | 0, g6), E3[B4 + 32 >> 2] = 0, E3[B4 + 36 >> 2] = 0, E3[B4 + 24 >> 2] = 0, E3[B4 + 28 >> 2] = 0, E3[B4 + 16 >> 2] = 0, E3[B4 + 20 >> 2] = 0, E3[B4 + 8 >> 2] = 0, E3[B4 + 12 >> 2] = 0, E3[B4 >> 2] = 0, E3[B4 + 4 >> 2] = 0, E3[B4 + 44 >> 2] = 0, E3[B4 + 48 >> 2] = 0, E3[B4 + 40 >> 2] = 1, E3[B4 + 52 >> 2] = 0, E3[B4 + 56 >> 2] = 0, E3[B4 + 60 >> 2] = 0, E3[B4 + 64 >> 2] = 0, E3[B4 + 68 >> 2] = 0, E3[B4 + 72 >> 2] = 0, E3[B4 + 84 >> 2] = 0, E3[B4 + 88 >> 2] = 0, E3[B4 + 76 >> 2] = 0, E3[B4 + 80 >> 2] = 1, E3[B4 + 92 >> 2] = 0, E3[B4 + 96 >> 2] = 0, E3[B4 + 100 >> 2] = 0, E3[B4 + 104 >> 2] = 0, E3[B4 + 108 >> 2] = 0, E3[B4 + 112 >> 2] = 0, E3[B4 + 116 >> 2] = 0, $2 = B4 + 80 | 0, AA2 = B4 + 40 | 0, I7 = 255; ; ) { + A: { + I: { + if (!i3[(g6 = a4 + 2016 | 0) + I7 | 0] && !i3[(Q4 = a4 + 1760 | 0) + I7 | 0]) { + if (!(i3[(o4 = g6) + (g6 = I7 - 1 | 0) | 0] | i3[g6 + Q4 | 0])) break I; + I7 = g6; + } + if ((0 | I7) < 0) break A; + for (; _3(Q4 = a4 + 320 | 0, B4), (0 | (o4 = C3[(g6 = I7) + (a4 + 2016 | 0) | 0])) > 0 ? (M3(I7 = a4 + 160 | 0, Q4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, Q4, k4), X(Q4, I7, (a4 + 480 | 0) + c3((254 & o4) >>> 1 | 0, 160) | 0)) : (0 | o4) >= 0 || (M3(I7 = a4 + 160 | 0, Q4 = a4 + 320 | 0, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, Q4, k4), O(Q4, I7, (a4 + 480 | 0) + c3((0 - o4 & 254) >>> 1 | 0, 160) | 0)), (0 | (x4 = C3[g6 + (a4 + 1760 | 0) | 0])) > 0 ? (M3(I7 = a4 + 160 | 0, Q4 = a4 + 320 | 0, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, Q4, k4), T(Q4, I7, c3((254 & x4) >>> 1 | 0, 120) + 1472 | 0)) : (0 | x4) >= 0 || (M3(a4 + 160 | 0, u4 = a4 + 320 | 0, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, u4, k4), Y4 = E3[a4 + 160 >> 2], U4 = E3[a4 + 200 >> 2], d4 = E3[a4 + 164 >> 2], b4 = E3[a4 + 204 >> 2], P4 = E3[a4 + 168 >> 2], R4 = E3[a4 + 208 >> 2], L4 = E3[a4 + 172 >> 2], F4 = E3[a4 + 212 >> 2], S4 = E3[a4 + 176 >> 2], N4 = E3[a4 + 216 >> 2], p4 = E3[a4 + 180 >> 2], H4 = E3[a4 + 220 >> 2], f4 = E3[a4 + 184 >> 2], t4 = E3[a4 + 224 >> 2], e4 = E3[a4 + 188 >> 2], y4 = E3[a4 + 228 >> 2], w4 = E3[a4 + 192 >> 2], o4 = E3[a4 + 232 >> 2], Q4 = E3[a4 + 236 >> 2], I7 = E3[a4 + 196 >> 2], E3[a4 + 396 >> 2] = Q4 - I7, E3[a4 + 392 >> 2] = o4 - w4, E3[a4 + 388 >> 2] = y4 - e4, E3[a4 + 384 >> 2] = t4 - f4, E3[a4 + 380 >> 2] = H4 - p4, E3[a4 + 376 >> 2] = N4 - S4, E3[a4 + 372 >> 2] = F4 - L4, E3[a4 + 368 >> 2] = R4 - P4, E3[a4 + 364 >> 2] = b4 - d4, E3[a4 + 360 >> 2] = U4 - Y4, E3[a4 + 356 >> 2] = I7 + Q4, E3[a4 + 352 >> 2] = o4 + w4, E3[a4 + 348 >> 2] = y4 + e4, E3[a4 + 344 >> 2] = f4 + t4, E3[a4 + 340 >> 2] = p4 + H4, E3[a4 + 336 >> 2] = S4 + N4, E3[a4 + 332 >> 2] = F4 + L4, E3[a4 + 328 >> 2] = P4 + R4, E3[a4 + 324 >> 2] = d4 + b4, E3[a4 + 320 >> 2] = Y4 + U4, M3(n4, u4, 40 + (I7 = c3((0 - x4 & 254) >>> 1 | 0, 120) + 1472 | 0) | 0), M3(k4, k4, I7), M3(h4, I7 + 80 | 0, K4), IA2 = E3[a4 + 276 >> 2], gA2 = E3[a4 + 272 >> 2], x4 = E3[a4 + 268 >> 2], u4 = E3[a4 + 264 >> 2], f4 = E3[a4 + 260 >> 2], t4 = E3[a4 + 256 >> 2], e4 = E3[a4 + 252 >> 2], y4 = E3[a4 + 248 >> 2], w4 = E3[a4 + 244 >> 2], o4 = E3[a4 + 240 >> 2], m4 = E3[a4 + 360 >> 2], l3 = E3[a4 + 400 >> 2], z2 = E3[a4 + 364 >> 2], j2 = E3[a4 + 404 >> 2], V2 = E3[a4 + 368 >> 2], Z2 = E3[a4 + 408 >> 2], Y4 = E3[a4 + 372 >> 2], U4 = E3[a4 + 412 >> 2], d4 = E3[a4 + 376 >> 2], b4 = E3[a4 + 416 >> 2], P4 = E3[a4 + 380 >> 2], R4 = E3[a4 + 420 >> 2], L4 = E3[a4 + 384 >> 2], F4 = E3[a4 + 424 >> 2], S4 = E3[a4 + 388 >> 2], N4 = E3[a4 + 428 >> 2], p4 = E3[a4 + 392 >> 2], H4 = E3[a4 + 432 >> 2], Q4 = E3[a4 + 396 >> 2], I7 = E3[a4 + 436 >> 2], E3[a4 + 396 >> 2] = Q4 + I7, E3[a4 + 392 >> 2] = p4 + H4, E3[a4 + 388 >> 2] = S4 + N4, E3[a4 + 384 >> 2] = F4 + L4, E3[a4 + 380 >> 2] = P4 + R4, E3[a4 + 376 >> 2] = d4 + b4, E3[a4 + 372 >> 2] = Y4 + U4, E3[a4 + 368 >> 2] = V2 + Z2, E3[a4 + 364 >> 2] = z2 + j2, E3[a4 + 360 >> 2] = m4 + l3, E3[a4 + 356 >> 2] = I7 - Q4, E3[a4 + 352 >> 2] = H4 - p4, E3[a4 + 348 >> 2] = N4 - S4, E3[a4 + 344 >> 2] = F4 - L4, E3[a4 + 340 >> 2] = R4 - P4, E3[a4 + 336 >> 2] = b4 - d4, E3[a4 + 332 >> 2] = U4 - Y4, E3[a4 + 328 >> 2] = Z2 - V2, E3[a4 + 324 >> 2] = j2 - z2, E3[a4 + 320 >> 2] = l3 - m4, Y4 = o4 << 1, U4 = E3[a4 + 440 >> 2], E3[a4 + 400 >> 2] = Y4 - U4, d4 = w4 << 1, b4 = E3[a4 + 444 >> 2], E3[a4 + 404 >> 2] = d4 - b4, P4 = y4 << 1, R4 = E3[a4 + 448 >> 2], E3[a4 + 408 >> 2] = P4 - R4, L4 = e4 << 1, F4 = E3[a4 + 452 >> 2], E3[a4 + 412 >> 2] = L4 - F4, S4 = t4 << 1, N4 = E3[a4 + 456 >> 2], E3[a4 + 416 >> 2] = S4 - N4, p4 = f4 << 1, H4 = E3[a4 + 460 >> 2], E3[a4 + 420 >> 2] = p4 - H4, f4 = u4 << 1, t4 = E3[a4 + 464 >> 2], E3[a4 + 424 >> 2] = f4 - t4, e4 = x4 << 1, y4 = E3[a4 + 468 >> 2], E3[a4 + 428 >> 2] = e4 - y4, w4 = gA2 << 1, o4 = E3[a4 + 472 >> 2], E3[a4 + 432 >> 2] = w4 - o4, Q4 = IA2 << 1, I7 = E3[a4 + 476 >> 2], E3[a4 + 436 >> 2] = Q4 - I7, E3[a4 + 440 >> 2] = Y4 + U4, E3[a4 + 444 >> 2] = d4 + b4, E3[a4 + 448 >> 2] = P4 + R4, E3[a4 + 452 >> 2] = F4 + L4, E3[a4 + 456 >> 2] = S4 + N4, E3[a4 + 460 >> 2] = p4 + H4, E3[a4 + 464 >> 2] = f4 + t4, E3[a4 + 468 >> 2] = y4 + e4, E3[a4 + 472 >> 2] = o4 + w4, E3[a4 + 476 >> 2] = I7 + Q4), M3(B4, a4 + 320 | 0, h4), M3(AA2, k4, n4), M3($2, n4, h4), I7 = g6 - 1 | 0, (0 | g6) > 0; ) ; + break A; + } + if (I7 = I7 - 2 | 0, g6) continue; + } + break; + } + r3 = a4 + 2272 | 0, mA(I7 = D4 + 288 | 0, B4), CA2 = -1, BA2 = UA(I7, A8), p4 = ((0 | A8) == (0 | I7) ? CA2 : BA2) | NA(A8, I7, 32); + } + return r3 = D4 + 592 | 0, p4; + } + function S3(A8, I7, g6) { + var C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0; + for (r3 = C4 = r3 - 800 | 0, S4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, N4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, _4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, p4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, s4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, H4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, G4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, Q4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, o4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, c4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, D4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, a4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, y4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, f4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, F4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = g6 - -64 | 0, e4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[I7 >> 2] = 33620224 ^ e4, E3[g6 + 56 >> 2] = 1496785429, E3[g6 + 60 >> 2] = 1652156816, E3[(A8 = g6 + 48 | 0) >> 2] = 33620224, E3[A8 + 4 >> 2] = 218629379, E3[g6 + 40 >> 2] = 1110511904, E3[g6 + 44 >> 2] = -584534669, E3[(B4 = g6 + 32 | 0) >> 2] = 1427652059, E3[B4 + 4 >> 2] = -248528275, w4 = F4 ^ e4, E3[g6 >> 2] = w4, E3[g6 + 92 >> 2] = -584534669 ^ f4, E3[g6 + 88 >> 2] = 1110511904 ^ y4, E3[g6 + 84 >> 2] = -248528275 ^ a4, E3[(F4 = g6 + 80 | 0) >> 2] = 1427652059 ^ D4, E3[g6 + 76 >> 2] = 1652156816 ^ c4, E3[g6 + 72 >> 2] = 1496785429 ^ o4, E3[g6 + 68 >> 2] = 218629379 ^ Q4, G4 ^= f4, E3[g6 + 28 >> 2] = G4, H4 ^= y4, E3[g6 + 24 >> 2] = H4, t4 = s4 ^ a4, E3[g6 + 20 >> 2] = t4, p4 ^= D4, E3[(s4 = g6 + 16 | 0) >> 2] = p4, _4 ^= c4, E3[g6 + 12 >> 2] = _4, h4 = N4 ^ o4, E3[g6 + 8 >> 2] = h4, k4 = S4 ^ Q4, E3[g6 + 4 >> 2] = k4, N4 = 0; S4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = S4, S4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = S4, S4 = E3[I7 + 12 >> 2], E3[C4 + 760 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 764 >> 2] = S4, S4 = E3[I7 + 4 >> 2], E3[C4 + 752 >> 2] = E3[I7 >> 2], E3[C4 + 756 >> 2] = S4, S4 = E3[F4 + 12 >> 2], E3[C4 + 744 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 748 >> 2] = S4, S4 = E3[F4 + 4 >> 2], E3[C4 + 736 >> 2] = E3[F4 >> 2], E3[C4 + 740 >> 2] = S4, aA(S4 = C4 + 768 | 0, C4 + 752 | 0, C4 + 736 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 728 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 732 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 720 >> 2] = E3[A8 >> 2], E3[C4 + 724 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 712 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 716 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 704 >> 2] = E3[I7 >> 2], E3[C4 + 708 >> 2] = n4, aA(S4, C4 + 720 | 0, C4 + 704 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 696 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 700 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 688 >> 2] = E3[B4 >> 2], E3[C4 + 692 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 680 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 684 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 672 >> 2] = E3[A8 >> 2], E3[C4 + 676 >> 2] = n4, aA(S4, C4 + 688 | 0, C4 + 672 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 664 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 668 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 656 >> 2] = E3[s4 >> 2], E3[C4 + 660 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 648 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 652 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 640 >> 2] = E3[B4 >> 2], E3[C4 + 644 >> 2] = n4, aA(S4, C4 + 656 | 0, C4 + 640 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 632 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 636 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 624 >> 2] = E3[g6 >> 2], E3[C4 + 628 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 616 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 620 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 608 >> 2] = E3[s4 >> 2], E3[C4 + 612 >> 2] = n4, aA(S4, C4 + 624 | 0, C4 + 608 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 600 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 604 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 592 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 596 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 584 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 588 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 576 >> 2] = E3[g6 >> 2], E3[C4 + 580 >> 2] = n4, aA(S4, C4 + 592 | 0, C4 + 576 | 0), n4 = E3[C4 + 768 >> 2], M4 = E3[C4 + 772 >> 2], K4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = E3[C4 + 780 >> 2] ^ c4, E3[g6 + 8 >> 2] = K4 ^ o4, E3[g6 + 4 >> 2] = M4 ^ Q4, E3[g6 >> 2] = n4 ^ e4, n4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 568 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 572 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 560 >> 2] = E3[I7 >> 2], E3[C4 + 564 >> 2] = n4, n4 = E3[F4 + 12 >> 2], E3[C4 + 552 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 556 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 544 >> 2] = E3[F4 >> 2], E3[C4 + 548 >> 2] = n4, aA(S4, C4 + 560 | 0, C4 + 544 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 536 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 540 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 528 >> 2] = E3[A8 >> 2], E3[C4 + 532 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 520 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 524 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 512 >> 2] = E3[I7 >> 2], E3[C4 + 516 >> 2] = n4, aA(S4, C4 + 528 | 0, C4 + 512 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 504 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 508 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 496 >> 2] = E3[B4 >> 2], E3[C4 + 500 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 488 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 492 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 480 >> 2] = E3[A8 >> 2], E3[C4 + 484 >> 2] = n4, aA(S4, C4 + 496 | 0, C4 + 480 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 472 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 476 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 464 >> 2] = E3[s4 >> 2], E3[C4 + 468 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 456 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 460 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 448 >> 2] = E3[B4 >> 2], E3[C4 + 452 >> 2] = n4, aA(S4, C4 + 464 | 0, C4 + 448 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 440 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 444 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 432 >> 2] = E3[g6 >> 2], E3[C4 + 436 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 424 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 428 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 416 >> 2] = E3[s4 >> 2], E3[C4 + 420 >> 2] = n4, aA(S4, C4 + 432 | 0, C4 + 416 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 408 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 412 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 400 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 404 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 392 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 396 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 384 >> 2] = E3[g6 >> 2], E3[C4 + 388 >> 2] = n4, aA(S4, C4 + 400 | 0, C4 + 384 | 0), n4 = E3[C4 + 768 >> 2], M4 = E3[C4 + 772 >> 2], K4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = E3[C4 + 780 >> 2] ^ f4, E3[g6 + 8 >> 2] = K4 ^ y4, E3[g6 + 4 >> 2] = M4 ^ a4, E3[g6 >> 2] = n4 ^ D4, n4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 376 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 380 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 368 >> 2] = E3[I7 >> 2], E3[C4 + 372 >> 2] = n4, n4 = E3[F4 + 12 >> 2], E3[C4 + 360 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 364 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 352 >> 2] = E3[F4 >> 2], E3[C4 + 356 >> 2] = n4, aA(S4, C4 + 368 | 0, C4 + 352 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 344 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 348 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 336 >> 2] = E3[A8 >> 2], E3[C4 + 340 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 328 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 332 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 320 >> 2] = E3[I7 >> 2], E3[C4 + 324 >> 2] = n4, aA(S4, C4 + 336 | 0, C4 + 320 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 312 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 316 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 304 >> 2] = E3[B4 >> 2], E3[C4 + 308 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 296 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 300 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 288 >> 2] = E3[A8 >> 2], E3[C4 + 292 >> 2] = n4, aA(S4, C4 + 304 | 0, C4 + 288 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 280 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 284 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 272 >> 2] = E3[s4 >> 2], E3[C4 + 276 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 264 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 268 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 256 >> 2] = E3[B4 >> 2], E3[C4 + 260 >> 2] = n4, aA(S4, C4 + 272 | 0, C4 + 256 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 248 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 252 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 240 >> 2] = E3[g6 >> 2], E3[C4 + 244 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 232 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 236 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 224 >> 2] = E3[s4 >> 2], E3[C4 + 228 >> 2] = n4, aA(S4, C4 + 240 | 0, C4 + 224 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 216 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 220 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 208 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 212 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 200 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 204 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 192 >> 2] = E3[g6 >> 2], E3[C4 + 196 >> 2] = n4, aA(S4, C4 + 208 | 0, C4 + 192 | 0), n4 = E3[C4 + 768 >> 2], M4 = E3[C4 + 772 >> 2], K4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = _4 ^ E3[C4 + 780 >> 2], E3[g6 + 8 >> 2] = K4 ^ h4, E3[g6 + 4 >> 2] = M4 ^ k4, E3[g6 >> 2] = n4 ^ w4, n4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 184 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 188 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 176 >> 2] = E3[I7 >> 2], E3[C4 + 180 >> 2] = n4, n4 = E3[F4 + 12 >> 2], E3[C4 + 168 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 172 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 160 >> 2] = E3[F4 >> 2], E3[C4 + 164 >> 2] = n4, aA(S4, C4 + 176 | 0, C4 + 160 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 152 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 156 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 144 >> 2] = E3[A8 >> 2], E3[C4 + 148 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 136 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 140 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 128 >> 2] = E3[I7 >> 2], E3[C4 + 132 >> 2] = n4, aA(S4, C4 + 144 | 0, C4 + 128 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 120 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 124 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 112 >> 2] = E3[B4 >> 2], E3[C4 + 116 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 104 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 108 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 96 >> 2] = E3[A8 >> 2], E3[C4 + 100 >> 2] = n4, aA(S4, C4 + 112 | 0, C4 + 96 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 88 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 92 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 80 >> 2] = E3[s4 >> 2], E3[C4 + 84 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 72 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 76 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 64 >> 2] = E3[B4 >> 2], E3[C4 + 68 >> 2] = n4, aA(S4, C4 + 80 | 0, C4 - -64 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 60 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 48 >> 2] = E3[g6 >> 2], E3[C4 + 52 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 40 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 44 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 32 >> 2] = E3[s4 >> 2], E3[C4 + 36 >> 2] = n4, aA(S4, C4 + 48 | 0, C4 + 32 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 24 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 28 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 16 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 20 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 12 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 >> 2] = E3[g6 >> 2], E3[C4 + 4 >> 2] = n4, aA(S4, C4 + 16 | 0, C4), S4 = E3[C4 + 768 >> 2], n4 = E3[C4 + 772 >> 2], M4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = G4 ^ E3[C4 + 780 >> 2], E3[g6 + 8 >> 2] = M4 ^ H4, E3[g6 + 4 >> 2] = n4 ^ t4, E3[g6 >> 2] = S4 ^ p4, 4 != (0 | (N4 = N4 + 1 | 0)); ) ; + r3 = C4 + 800 | 0; + } + function M3(A8, I7, g6) { + var C4, B4, Q4, i4, o4, D4, a4, y4, f4, e4, w4, r4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, v4, R4, L4, x4, u4, m4, q4, l3, z2, j2, X2, O2, T2, V2, Z2, W2, $2, AA2, IA2, gA2, CA2, BA2, QA2 = 0, EA2 = 0, iA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, eA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, SA2 = 0, MA2 = 0, NA2 = 0, KA2 = 0, _A2 = 0, pA2 = 0, HA2 = 0; + QA2 = PA(C4 = E3[g6 + 4 >> 2], e4 = C4 >> 31, sA2 = (s4 = E3[I7 + 20 >> 2]) << 1, P4 = sA2 >> 31), iA2 = t3, EA2 = (tA2 = PA(kA2 = E3[g6 >> 2], Q4 = kA2 >> 31, B4 = E3[I7 + 24 >> 2], i4 = B4 >> 31)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < tA2 >>> 0 ? QA2 + 1 | 0 : QA2, fA2 = PA(o4 = E3[g6 + 8 >> 2], h4 = o4 >> 31, tA2 = E3[I7 + 16 >> 2], D4 = tA2 >> 31), iA2 = t3 + QA2 | 0, iA2 = (EA2 = fA2 + EA2 | 0) >>> 0 < fA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = (fA2 = PA(w4 = E3[g6 + 12 >> 2], F4 = w4 >> 31, H4 = (S4 = E3[I7 + 12 >> 2]) << 1, v4 = H4 >> 31)) + EA2 | 0, EA2 = t3 + iA2 | 0, EA2 = QA2 >>> 0 < fA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (hA2 = PA(k4 = E3[g6 + 16 >> 2], G4 = k4 >> 31, fA2 = E3[I7 + 8 >> 2], a4 = fA2 >> 31)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < hA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(M4 = E3[g6 + 20 >> 2], R4 = M4 >> 31, J4 = (N4 = E3[I7 + 4 >> 2]) << 1, L4 = J4 >> 31), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, Z2 = aA2 = E3[g6 + 24 >> 2], iA2 = (eA2 = PA(aA2, T2 = aA2 >> 31, hA2 = E3[I7 >> 2], y4 = hA2 >> 31)) + EA2 | 0, EA2 = t3 + QA2 | 0, EA2 = iA2 >>> 0 < eA2 >>> 0 ? EA2 + 1 | 0 : EA2, x4 = E3[g6 + 28 >> 2], QA2 = (eA2 = PA(rA2 = c3(x4, 19), K4 = rA2 >> 31, Y4 = (_4 = E3[I7 + 36 >> 2]) << 1, u4 = Y4 >> 31)) + iA2 | 0, iA2 = t3 + EA2 | 0, iA2 = QA2 >>> 0 < eA2 >>> 0 ? iA2 + 1 | 0 : iA2, NA2 = E3[g6 + 32 >> 2], EA2 = (yA2 = PA(oA2 = c3(NA2, 19), n4 = oA2 >> 31, eA2 = E3[I7 + 32 >> 2], f4 = eA2 >> 31)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < yA2 >>> 0 ? QA2 + 1 | 0 : QA2, W2 = E3[g6 + 36 >> 2], g6 = PA(yA2 = c3(W2, 19), r4 = yA2 >> 31, U4 = (p4 = E3[I7 + 28 >> 2]) << 1, m4 = U4 >> 31), QA2 = t3 + QA2 | 0, cA2 = I7 = g6 + EA2 | 0, g6 = I7 >>> 0 < g6 >>> 0 ? QA2 + 1 | 0 : QA2, I7 = PA(tA2, D4, C4, e4), QA2 = t3, EA2 = PA(kA2, Q4, s4, q4 = s4 >> 31), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(o4, h4, S4, l3 = S4 >> 31), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(fA2, a4, w4, F4), QA2 = t3 + EA2 | 0, QA2 = (I7 = iA2 + I7 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(k4, G4, N4, z2 = N4 >> 31), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(hA2, y4, M4, R4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(aA2 = c3(aA2, 19), d4 = aA2 >> 31, _4, j2 = _4 >> 31), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(eA2, f4, rA2, K4), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(oA2, n4, p4, X2 = p4 >> 31), QA2 = t3 + EA2 | 0, QA2 = (I7 = iA2 + I7 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(yA2, r4, B4, i4), QA2 = t3 + QA2 | 0, _A2 = I7 = EA2 + I7 | 0, FA2 = I7 >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, I7 = PA(C4, e4, H4, v4), QA2 = t3, EA2 = PA(kA2, Q4, tA2, D4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(fA2, a4, o4, h4), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(w4, F4, J4, L4), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(hA2, y4, k4, G4), QA2 = t3 + EA2 | 0, QA2 = (I7 = iA2 + I7 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(b4 = c3(M4, 19), O2 = b4 >> 31, Y4, u4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(eA2, f4, aA2, d4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(rA2, K4, U4, m4), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(oA2, n4, B4, i4), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(yA2, r4, sA2, P4), QA2 = t3 + EA2 | 0, $2 = I7 = iA2 + I7 | 0, AA2 = QA2 = I7 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, IA2 = I7 = I7 + 33554432 | 0, gA2 = QA2 = I7 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, iA2 = (67108863 & QA2) << 6 | I7 >>> 26, QA2 = (QA2 >> 26) + FA2 | 0, _A2 = I7 = iA2 + _A2 | 0, QA2 = I7 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, CA2 = I7 = I7 + 16777216 | 0, QA2 = g6 + (EA2 = (iA2 = I7 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2) >> 25) | 0, QA2 = (I7 = (iA2 = (33554431 & iA2) << 7 | I7 >>> 25) + cA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, SA2 = g6 = (EA2 = I7) + 33554432 | 0, I7 = QA2 = g6 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, E3[A8 + 24 >> 2] = EA2 - (-67108864 & g6), g6 = PA(C4, e4, J4, L4), QA2 = t3, EA2 = PA(kA2, Q4, fA2, a4), iA2 = t3 + QA2 | 0, iA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = (QA2 = g6) + (g6 = PA(hA2, y4, o4, h4)) | 0, QA2 = t3 + iA2 | 0, QA2 = g6 >>> 0 > EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(g6 = c3(w4, 19), MA2 = g6 >> 31, Y4, u4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = (cA2 = PA(eA2, f4, FA2 = c3(k4, 19), V2 = FA2 >> 31)) + EA2 | 0, EA2 = t3 + QA2 | 0, EA2 = iA2 >>> 0 < cA2 >>> 0 ? EA2 + 1 | 0 : EA2, cA2 = PA(U4, m4, b4, O2), QA2 = t3 + EA2 | 0, QA2 = (iA2 = cA2 + iA2 | 0) >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (cA2 = PA(B4, i4, aA2, d4)) + iA2 | 0, iA2 = t3 + QA2 | 0, iA2 = EA2 >>> 0 < cA2 >>> 0 ? iA2 + 1 | 0 : iA2, cA2 = PA(rA2, K4, sA2, P4), QA2 = t3 + iA2 | 0, QA2 = (EA2 = cA2 + EA2 | 0) >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(oA2, n4, tA2, D4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = (cA2 = PA(yA2, r4, H4, v4)) + EA2 | 0, EA2 = t3 + QA2 | 0, wA2 = iA2, pA2 = iA2 >>> 0 < cA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = PA(hA2, y4, C4, e4), EA2 = t3, iA2 = (cA2 = PA(kA2, Q4, N4, z2)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2, cA2 = EA2 = c3(o4, 19), EA2 = (DA2 = PA(EA2, KA2 = EA2 >> 31, _4, j2)) + iA2 | 0, iA2 = t3 + QA2 | 0, iA2 = EA2 >>> 0 < DA2 >>> 0 ? iA2 + 1 | 0 : iA2, DA2 = PA(eA2, f4, g6, MA2), QA2 = t3 + iA2 | 0, QA2 = (EA2 = DA2 + EA2 | 0) >>> 0 < DA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(FA2, V2, p4, X2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = (DA2 = PA(B4, i4, b4, O2)) + EA2 | 0, EA2 = t3 + QA2 | 0, EA2 = iA2 >>> 0 < DA2 >>> 0 ? EA2 + 1 | 0 : EA2, DA2 = PA(aA2, d4, s4, q4), QA2 = t3 + EA2 | 0, QA2 = (iA2 = DA2 + iA2 | 0) >>> 0 < DA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (DA2 = PA(tA2, D4, rA2, K4)) + iA2 | 0, iA2 = t3 + QA2 | 0, iA2 = EA2 >>> 0 < DA2 >>> 0 ? iA2 + 1 | 0 : iA2, DA2 = PA(oA2, n4, S4, l3), QA2 = t3 + iA2 | 0, QA2 = (EA2 = DA2 + EA2 | 0) >>> 0 < DA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(yA2, r4, fA2, a4), QA2 = t3 + QA2 | 0, HA2 = EA2 = iA2 + EA2 | 0, DA2 = EA2 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, QA2 = PA(QA2 = c3(C4, 19), QA2 >> 31, Y4, u4), EA2 = t3, iA2 = PA(kA2, Q4, hA2, y4), EA2 = t3 + EA2 | 0, EA2 = (QA2 = iA2 + QA2 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (cA2 = PA(eA2, f4, cA2, KA2)) + QA2 | 0, QA2 = t3 + EA2 | 0, g6 = (EA2 = PA(g6, MA2, U4, m4)) + iA2 | 0, iA2 = t3 + (iA2 >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2) | 0, iA2 = g6 >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(B4, i4, FA2, V2), QA2 = t3 + iA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(sA2, P4, b4, O2), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(tA2, D4, aA2, d4), EA2 = t3 + QA2 | 0, EA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(rA2, K4, H4, v4), QA2 = t3 + EA2 | 0, QA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(oA2, n4, fA2, a4), iA2 = t3 + QA2 | 0, iA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(yA2, r4, J4, L4), QA2 = t3 + iA2 | 0, cA2 = g6 = EA2 + g6 | 0, MA2 = QA2 = g6 >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, KA2 = g6 = g6 + 33554432 | 0, BA2 = QA2 = g6 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, EA2 = (iA2 = QA2 >> 26) + DA2 | 0, DA2 = g6 = (QA2 = (67108863 & QA2) << 6 | g6 >>> 26) + HA2 | 0, QA2 = g6 >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, HA2 = g6 = g6 + 16777216 | 0, EA2 = (33554431 & (QA2 = g6 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2)) << 7 | g6 >>> 25, QA2 = (QA2 >> 25) + pA2 | 0, QA2 = (g6 = EA2 + wA2 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, pA2 = EA2 = (iA2 = g6) + 33554432 | 0, g6 = QA2 = EA2 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, E3[A8 + 8 >> 2] = iA2 - (-67108864 & EA2), QA2 = PA(B4, i4, C4, e4), iA2 = t3, EA2 = (wA2 = PA(kA2, Q4, p4, X2)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < wA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(o4, h4, s4, q4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(tA2, D4, w4, F4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, wA2 = PA(k4, G4, S4, l3), iA2 = t3 + QA2 | 0, iA2 = (EA2 = wA2 + EA2 | 0) >>> 0 < wA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = (wA2 = PA(fA2, a4, M4, R4)) + EA2 | 0, EA2 = t3 + iA2 | 0, EA2 = QA2 >>> 0 < wA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (wA2 = PA(N4, z2, Z2, T2)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < wA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(hA2, y4, x4, wA2 = x4 >> 31), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(oA2, n4, _4, j2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, nA2 = PA(yA2, r4, eA2, f4), iA2 = t3 + QA2 | 0, QA2 = I7 >> 26, I7 = (SA2 = (67108863 & I7) << 6 | SA2 >>> 26) + (EA2 = nA2 + EA2 | 0) | 0, EA2 = QA2 + (EA2 >>> 0 < nA2 >>> 0 ? iA2 + 1 | 0 : iA2) | 0, QA2 = (iA2 = I7) >>> 0 < SA2 >>> 0 ? EA2 + 1 | 0 : EA2, SA2 = EA2 = iA2 + 16777216 | 0, I7 = QA2 = EA2 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2, E3[A8 + 28 >> 2] = iA2 - (-33554432 & EA2), QA2 = PA(fA2, a4, C4, e4), EA2 = t3, nA2 = PA(kA2, Q4, S4, l3), iA2 = t3 + EA2 | 0, iA2 = (QA2 = nA2 + QA2 | 0) >>> 0 < nA2 >>> 0 ? iA2 + 1 | 0 : iA2, nA2 = PA(o4, h4, N4, z2), EA2 = t3 + iA2 | 0, EA2 = (QA2 = nA2 + QA2 | 0) >>> 0 < nA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (nA2 = PA(hA2, y4, w4, F4)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < nA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(FA2, V2, _4, j2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(eA2, f4, b4, O2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (aA2 = PA(aA2, d4, p4, X2)) + EA2 | 0, iA2 = t3 + QA2 | 0, QA2 = (rA2 = PA(B4, i4, rA2, K4)) + EA2 | 0, EA2 = t3 + (EA2 >>> 0 < aA2 >>> 0 ? iA2 + 1 | 0 : iA2) | 0, iA2 = (oA2 = PA(oA2, n4, s4, q4)) + QA2 | 0, QA2 = t3 + (QA2 >>> 0 < rA2 >>> 0 ? EA2 + 1 | 0 : EA2) | 0, QA2 = iA2 >>> 0 < oA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(yA2, r4, tA2, D4), QA2 = t3 + QA2 | 0, oA2 = EA2 = EA2 + iA2 | 0, QA2 = (QA2 = EA2 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2) + (EA2 = g6 >> 26) | 0, oA2 = g6 = oA2 + (iA2 = (67108863 & g6) << 6 | pA2 >>> 26) | 0, QA2 = g6 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, rA2 = EA2 = g6 + 16777216 | 0, g6 = iA2 = EA2 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2, E3[A8 + 12 >> 2] = oA2 - (-33554432 & EA2), QA2 = PA(C4, e4, U4, m4), iA2 = t3, EA2 = (oA2 = PA(kA2, Q4, eA2, f4)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < oA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(B4, i4, o4, h4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, oA2 = PA(w4, F4, sA2, P4), iA2 = t3 + QA2 | 0, iA2 = (EA2 = oA2 + EA2 | 0) >>> 0 < oA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = (oA2 = PA(tA2, D4, k4, G4)) + EA2 | 0, EA2 = t3 + iA2 | 0, EA2 = QA2 >>> 0 < oA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (oA2 = PA(H4, v4, M4, R4)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < oA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(fA2, a4, Z2, T2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(x4, wA2, J4, L4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (sA2 = PA(hA2, y4, oA2 = NA2, aA2 = oA2 >> 31)) + EA2 | 0, iA2 = t3 + QA2 | 0, QA2 = (yA2 = PA(yA2, r4, Y4, u4)) + EA2 | 0, EA2 = t3 + (EA2 >>> 0 < sA2 >>> 0 ? iA2 + 1 | 0 : iA2) | 0, EA2 = QA2 >>> 0 < yA2 >>> 0 ? EA2 + 1 | 0 : EA2, NA2 = QA2, QA2 = (QA2 = I7 >> 25) + EA2 | 0, QA2 = (I7 = NA2 + (iA2 = (33554431 & I7) << 7 | SA2 >>> 25) | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, yA2 = EA2 = (iA2 = I7) + 33554432 | 0, I7 = QA2 = EA2 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, E3[A8 + 32 >> 2] = iA2 - (-67108864 & EA2), EA2 = g6 >> 25, g6 = (rA2 = (33554431 & g6) << 7 | rA2 >>> 25) + ($2 - (QA2 = -67108864 & IA2) | 0) | 0, QA2 = EA2 + (AA2 - ((QA2 >>> 0 > $2 >>> 0) + gA2 | 0) | 0) | 0, QA2 = g6 >>> 0 < rA2 >>> 0 ? QA2 + 1 | 0 : QA2, QA2 = ((67108863 & (QA2 = (g6 = (EA2 = g6) + 33554432 | 0) >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2)) << 6 | g6 >>> 26) + (iA2 = _A2 - (-33554432 & CA2) | 0) | 0, E3[A8 + 20 >> 2] = QA2, E3[A8 + 16 >> 2] = EA2 - (-67108864 & g6), g6 = PA(eA2, f4, C4, e4), QA2 = t3, EA2 = PA(kA2, Q4, _4, j2), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(o4, h4, p4, X2), EA2 = t3 + QA2 | 0, EA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = PA(B4, i4, w4, F4), iA2 = t3 + EA2 | 0, iA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(k4, G4, s4, q4), QA2 = t3 + iA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(tA2, D4, M4, R4), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(S4, l3, Z2, T2), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(fA2, a4, x4, wA2), EA2 = t3 + QA2 | 0, EA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = PA(oA2, aA2, N4, z2), iA2 = t3 + EA2 | 0, iA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(hA2, y4, W2, W2 >> 31), QA2 = t3 + iA2 | 0, QA2 = (QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2) + (EA2 = I7 >> 26) | 0, QA2 = (I7 = (iA2 = g6) + (g6 = (67108863 & I7) << 6 | yA2 >>> 26) | 0) >>> 0 < g6 >>> 0 ? QA2 + 1 | 0 : QA2, QA2 = (I7 = (g6 = I7) + 16777216 | 0) >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2, E3[A8 + 36 >> 2] = g6 - (-33554432 & I7), iA2 = DA2 - (-33554432 & HA2) | 0, EA2 = cA2 - (g6 = -67108864 & KA2) | 0, kA2 = MA2 - ((g6 >>> 0 > cA2 >>> 0) + BA2 | 0) | 0, I7 = (g6 = PA((33554431 & (g6 = QA2)) << 7 | I7 >>> 25, QA2 >>= 25, 19, 0)) + EA2 | 0, EA2 = t3 + kA2 | 0, QA2 = I7 >>> 0 < g6 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = ((67108863 & (QA2 = (I7 = (g6 = I7) + 33554432 | 0) >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2)) << 6 | I7 >>> 26) + iA2 | 0, E3[A8 + 4 >> 2] = QA2, E3[A8 >> 2] = g6 - (-67108864 & I7); + } + function N3(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4 = 0, F4 = 0, S4 = 0; + r3 = g6 = r3 - 544 | 0, C4 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24, B4 = i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24, Q4 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24, o4 = i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24, c4 = i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24, D4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, a4 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, y4 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24, s4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, f4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, e4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, w4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, t4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, h4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, k4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, n4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, A8 = E3[I7 + 124 >> 2], E3[g6 + 536 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 540 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 528 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 532 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 504 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 508 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 496 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 500 >> 2] = A8, A8 = E3[I7 + 124 >> 2], E3[g6 + 488 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 492 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 480 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 484 >> 2] = A8, aA(S4 = g6 + 512 | 0, g6 + 496 | 0, g6 + 480 | 0), A8 = E3[g6 + 524 >> 2], E3[I7 + 120 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 124 >> 2] = A8, A8 = E3[g6 + 516 >> 2], E3[I7 + 112 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 116 >> 2] = A8, A8 = E3[I7 + 92 >> 2], E3[g6 + 472 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 476 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 464 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 468 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 456 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 460 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 448 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 452 >> 2] = A8, aA(S4, g6 + 464 | 0, g6 + 448 | 0), A8 = E3[g6 + 524 >> 2], E3[I7 + 104 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 108 >> 2] = A8, A8 = E3[g6 + 516 >> 2], E3[I7 + 96 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 100 >> 2] = A8, A8 = E3[I7 + 76 >> 2], E3[g6 + 440 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 444 >> 2] = A8, F4 = E3[4 + (A8 = I7 - -64 | 0) >> 2], E3[g6 + 432 >> 2] = E3[A8 >> 2], E3[g6 + 436 >> 2] = F4, F4 = E3[I7 + 92 >> 2], E3[g6 + 424 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 428 >> 2] = F4, F4 = E3[I7 + 84 >> 2], E3[g6 + 416 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 420 >> 2] = F4, aA(S4, g6 + 432 | 0, g6 + 416 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 92 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 84 >> 2] = F4, F4 = E3[I7 + 60 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 412 >> 2] = F4, F4 = E3[I7 + 52 >> 2], E3[g6 + 400 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 404 >> 2] = F4, F4 = E3[I7 + 76 >> 2], E3[g6 + 392 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 396 >> 2] = F4, F4 = E3[A8 + 4 >> 2], E3[g6 + 384 >> 2] = E3[A8 >> 2], E3[g6 + 388 >> 2] = F4, aA(S4, g6 + 400 | 0, g6 + 384 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 76 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[A8 >> 2] = E3[g6 + 512 >> 2], E3[A8 + 4 >> 2] = F4, F4 = E3[I7 + 44 >> 2], E3[g6 + 376 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 380 >> 2] = F4, F4 = E3[I7 + 36 >> 2], E3[g6 + 368 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 372 >> 2] = F4, F4 = E3[I7 + 60 >> 2], E3[g6 + 360 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 364 >> 2] = F4, F4 = E3[I7 + 52 >> 2], E3[g6 + 352 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 356 >> 2] = F4, aA(S4, g6 + 368 | 0, g6 + 352 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 60 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 52 >> 2] = F4, F4 = E3[I7 + 28 >> 2], E3[g6 + 344 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 348 >> 2] = F4, F4 = E3[I7 + 20 >> 2], E3[g6 + 336 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 340 >> 2] = F4, F4 = E3[I7 + 44 >> 2], E3[g6 + 328 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 332 >> 2] = F4, F4 = E3[I7 + 36 >> 2], E3[g6 + 320 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 324 >> 2] = F4, aA(S4, g6 + 336 | 0, g6 + 320 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 44 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 36 >> 2] = F4, F4 = E3[I7 + 12 >> 2], E3[g6 + 312 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 316 >> 2] = F4, F4 = E3[I7 + 4 >> 2], E3[g6 + 304 >> 2] = E3[I7 >> 2], E3[g6 + 308 >> 2] = F4, F4 = E3[I7 + 28 >> 2], E3[g6 + 296 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 300 >> 2] = F4, F4 = E3[I7 + 20 >> 2], E3[g6 + 288 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 292 >> 2] = F4, aA(S4, g6 + 304 | 0, g6 + 288 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 28 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 20 >> 2] = F4, F4 = E3[g6 + 540 >> 2], E3[g6 + 280 >> 2] = E3[g6 + 536 >> 2], E3[g6 + 284 >> 2] = F4, F4 = E3[g6 + 532 >> 2], E3[g6 + 272 >> 2] = E3[g6 + 528 >> 2], E3[g6 + 276 >> 2] = F4, F4 = E3[I7 + 12 >> 2], E3[g6 + 264 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 268 >> 2] = F4, F4 = E3[I7 + 4 >> 2], E3[g6 + 256 >> 2] = E3[I7 >> 2], E3[g6 + 260 >> 2] = F4, aA(S4, g6 + 272 | 0, g6 + 256 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 8 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 12 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 4 >> 2] = F4, E3[I7 + 12 >> 2] = (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ k4, E3[I7 + 8 >> 2] = (i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24) ^ h4, E3[I7 + 4 >> 2] = (i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) ^ t4, E3[I7 >> 2] = (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) ^ n4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ w4, E3[I7 + 68 >> 2] = (i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24) ^ e4, E3[I7 + 72 >> 2] = (i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) ^ f4, E3[I7 + 76 >> 2] = (i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) ^ s4, s4 = E3[I7 + 124 >> 2], E3[g6 + 536 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 540 >> 2] = s4, s4 = E3[I7 + 116 >> 2], E3[g6 + 528 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 532 >> 2] = s4, s4 = E3[I7 + 108 >> 2], E3[g6 + 248 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 252 >> 2] = s4, s4 = E3[I7 + 100 >> 2], E3[g6 + 240 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 244 >> 2] = s4, s4 = E3[I7 + 124 >> 2], E3[g6 + 232 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 236 >> 2] = s4, s4 = E3[I7 + 116 >> 2], E3[g6 + 224 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 228 >> 2] = s4, aA(S4, g6 + 240 | 0, g6 + 224 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 120 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 124 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 112 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 116 >> 2] = s4, s4 = E3[I7 + 92 >> 2], E3[g6 + 216 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 220 >> 2] = s4, s4 = E3[I7 + 84 >> 2], E3[g6 + 208 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 212 >> 2] = s4, s4 = E3[I7 + 108 >> 2], E3[g6 + 200 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 204 >> 2] = s4, s4 = E3[I7 + 100 >> 2], E3[g6 + 192 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 196 >> 2] = s4, aA(S4, g6 + 208 | 0, g6 + 192 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 104 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 108 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 96 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 100 >> 2] = s4, s4 = E3[I7 + 76 >> 2], E3[g6 + 184 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 188 >> 2] = s4, s4 = E3[A8 + 4 >> 2], E3[g6 + 176 >> 2] = E3[A8 >> 2], E3[g6 + 180 >> 2] = s4, s4 = E3[I7 + 92 >> 2], E3[g6 + 168 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 172 >> 2] = s4, s4 = E3[I7 + 84 >> 2], E3[g6 + 160 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 164 >> 2] = s4, aA(S4, g6 + 176 | 0, g6 + 160 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 92 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 84 >> 2] = s4, s4 = E3[I7 + 60 >> 2], E3[g6 + 152 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 156 >> 2] = s4, s4 = E3[I7 + 52 >> 2], E3[g6 + 144 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 148 >> 2] = s4, s4 = E3[I7 + 76 >> 2], E3[g6 + 136 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 140 >> 2] = s4, s4 = E3[A8 + 4 >> 2], E3[g6 + 128 >> 2] = E3[A8 >> 2], E3[g6 + 132 >> 2] = s4, aA(S4, g6 + 144 | 0, g6 + 128 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 76 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[A8 >> 2] = E3[g6 + 512 >> 2], E3[A8 + 4 >> 2] = s4, s4 = E3[I7 + 44 >> 2], E3[g6 + 120 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 124 >> 2] = s4, s4 = E3[I7 + 36 >> 2], E3[g6 + 112 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 116 >> 2] = s4, s4 = E3[I7 + 60 >> 2], E3[g6 + 104 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 108 >> 2] = s4, s4 = E3[I7 + 52 >> 2], E3[g6 + 96 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 100 >> 2] = s4, aA(S4, g6 + 112 | 0, g6 + 96 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 60 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 52 >> 2] = s4, s4 = E3[I7 + 28 >> 2], E3[g6 + 88 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 92 >> 2] = s4, s4 = E3[I7 + 20 >> 2], E3[g6 + 80 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 84 >> 2] = s4, s4 = E3[I7 + 44 >> 2], E3[g6 + 72 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 76 >> 2] = s4, s4 = E3[I7 + 36 >> 2], E3[g6 + 64 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 68 >> 2] = s4, aA(S4, g6 + 80 | 0, g6 - -64 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 44 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 36 >> 2] = s4, s4 = E3[I7 + 12 >> 2], E3[g6 + 56 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 60 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[g6 + 48 >> 2] = E3[I7 >> 2], E3[g6 + 52 >> 2] = s4, s4 = E3[I7 + 28 >> 2], E3[g6 + 40 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 44 >> 2] = s4, s4 = E3[I7 + 20 >> 2], E3[g6 + 32 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 36 >> 2] = s4, aA(S4, g6 + 48 | 0, g6 + 32 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 28 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 20 >> 2] = s4, s4 = E3[g6 + 540 >> 2], E3[g6 + 24 >> 2] = E3[g6 + 536 >> 2], E3[g6 + 28 >> 2] = s4, s4 = E3[g6 + 532 >> 2], E3[g6 + 16 >> 2] = E3[g6 + 528 >> 2], E3[g6 + 20 >> 2] = s4, s4 = E3[I7 + 12 >> 2], E3[g6 + 8 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 12 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[g6 >> 2] = E3[I7 >> 2], E3[g6 + 4 >> 2] = s4, aA(S4, g6 + 16 | 0, g6), S4 = E3[g6 + 524 >> 2], E3[I7 + 8 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 12 >> 2] = S4, S4 = E3[g6 + 516 >> 2], E3[I7 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 4 >> 2] = S4, E3[I7 + 12 >> 2] = (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ y4, E3[I7 + 8 >> 2] = (i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24) ^ a4, E3[I7 + 4 >> 2] = (i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) ^ D4, E3[I7 >> 2] = (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) ^ c4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ o4, E3[I7 + 68 >> 2] = (i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24) ^ Q4, E3[I7 + 72 >> 2] = (i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) ^ B4, E3[I7 + 76 >> 2] = (i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) ^ C4, r3 = g6 + 544 | 0; + } + function K3(A8, I7, g6, B4, Q4) { + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0; + for (r3 = o4 = r3 - 288 | 0, h4 = (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ B4 >>> 29, k4 = (i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24) ^ B4 << 3, n4 = (i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24) ^ g6 >>> 29, B4 = (i3[0 | (a4 = Q4 + 32 | 0)] | i3[a4 + 1 | 0] << 8 | i3[a4 + 2 | 0] << 16 | i3[a4 + 3 | 0] << 24) ^ g6 << 3, w4 = Q4 + 16 | 0, f4 = Q4 + 48 | 0, D4 = Q4 - -64 | 0, e4 = Q4 + 80 | 0, c4 = Q4 + 96 | 0, y4 = Q4 + 112 | 0; g6 = E3[y4 + 12 >> 2], E3[o4 + 280 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 284 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 272 >> 2] = E3[y4 >> 2], E3[o4 + 276 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 248 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 252 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 240 >> 2] = E3[c4 >> 2], E3[o4 + 244 >> 2] = g6, g6 = E3[y4 + 12 >> 2], E3[o4 + 232 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 236 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 224 >> 2] = E3[y4 >> 2], E3[o4 + 228 >> 2] = g6, aA(t4 = o4 + 256 | 0, o4 + 240 | 0, o4 + 224 | 0), g6 = E3[o4 + 268 >> 2], E3[y4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[y4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[y4 >> 2] = E3[o4 + 256 >> 2], E3[y4 + 4 >> 2] = g6, g6 = E3[e4 + 12 >> 2], E3[o4 + 216 >> 2] = E3[e4 + 8 >> 2], E3[o4 + 220 >> 2] = g6, g6 = E3[e4 + 4 >> 2], E3[o4 + 208 >> 2] = E3[e4 >> 2], E3[o4 + 212 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 200 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 204 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 192 >> 2] = E3[c4 >> 2], E3[o4 + 196 >> 2] = g6, aA(t4, o4 + 208 | 0, o4 + 192 | 0), g6 = E3[o4 + 268 >> 2], E3[c4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[c4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[c4 >> 2] = E3[o4 + 256 >> 2], E3[c4 + 4 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 184 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 188 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 176 >> 2] = E3[D4 >> 2], E3[o4 + 180 >> 2] = g6, g6 = E3[e4 + 12 >> 2], E3[o4 + 168 >> 2] = E3[e4 + 8 >> 2], E3[o4 + 172 >> 2] = g6, g6 = E3[e4 + 4 >> 2], E3[o4 + 160 >> 2] = E3[e4 >> 2], E3[o4 + 164 >> 2] = g6, aA(t4, o4 + 176 | 0, o4 + 160 | 0), g6 = E3[o4 + 268 >> 2], E3[e4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[e4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[e4 >> 2] = E3[o4 + 256 >> 2], E3[e4 + 4 >> 2] = g6, g6 = E3[f4 + 12 >> 2], E3[o4 + 152 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 156 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 144 >> 2] = E3[f4 >> 2], E3[o4 + 148 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 136 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 140 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 128 >> 2] = E3[D4 >> 2], E3[o4 + 132 >> 2] = g6, aA(t4, o4 + 144 | 0, o4 + 128 | 0), g6 = E3[o4 + 268 >> 2], E3[D4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[D4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[D4 >> 2] = E3[o4 + 256 >> 2], E3[D4 + 4 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 120 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 124 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 112 >> 2] = E3[a4 >> 2], E3[o4 + 116 >> 2] = g6, g6 = E3[f4 + 12 >> 2], E3[o4 + 104 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 108 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 96 >> 2] = E3[f4 >> 2], E3[o4 + 100 >> 2] = g6, aA(t4, o4 + 112 | 0, o4 + 96 | 0), g6 = E3[o4 + 268 >> 2], E3[f4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[f4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[f4 >> 2] = E3[o4 + 256 >> 2], E3[f4 + 4 >> 2] = g6, g6 = E3[w4 + 12 >> 2], E3[o4 + 88 >> 2] = E3[w4 + 8 >> 2], E3[o4 + 92 >> 2] = g6, g6 = E3[w4 + 4 >> 2], E3[o4 + 80 >> 2] = E3[w4 >> 2], E3[o4 + 84 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 72 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 76 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 64 >> 2] = E3[a4 >> 2], E3[o4 + 68 >> 2] = g6, aA(t4, o4 + 80 | 0, o4 - -64 | 0), g6 = E3[o4 + 268 >> 2], E3[a4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[a4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[a4 >> 2] = E3[o4 + 256 >> 2], E3[a4 + 4 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 56 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 60 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 + 48 >> 2] = E3[Q4 >> 2], E3[o4 + 52 >> 2] = g6, g6 = E3[w4 + 12 >> 2], E3[o4 + 40 >> 2] = E3[w4 + 8 >> 2], E3[o4 + 44 >> 2] = g6, g6 = E3[w4 + 4 >> 2], E3[o4 + 32 >> 2] = E3[w4 >> 2], E3[o4 + 36 >> 2] = g6, aA(t4, o4 + 48 | 0, o4 + 32 | 0), g6 = E3[o4 + 268 >> 2], E3[w4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[w4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[w4 >> 2] = E3[o4 + 256 >> 2], E3[w4 + 4 >> 2] = g6, g6 = E3[o4 + 284 >> 2], E3[o4 + 24 >> 2] = E3[o4 + 280 >> 2], E3[o4 + 28 >> 2] = g6, g6 = E3[o4 + 276 >> 2], E3[o4 + 16 >> 2] = E3[o4 + 272 >> 2], E3[o4 + 20 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 8 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 12 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 >> 2] = E3[Q4 >> 2], E3[o4 + 4 >> 2] = g6, aA(t4, o4 + 16 | 0, o4), g6 = E3[o4 + 268 >> 2], E3[Q4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[Q4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[Q4 >> 2] = E3[o4 + 256 >> 2], E3[Q4 + 4 >> 2] = g6, F4 = h4 ^ (i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24), E3[Q4 + 12 >> 2] = F4, S4 = k4 ^ (i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24), E3[Q4 + 8 >> 2] = S4, M4 = n4 ^ (i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24), E3[Q4 + 4 >> 2] = M4, N4 = B4 ^ (i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), E3[Q4 >> 2] = N4, K4 = B4 ^ (i3[0 | D4] | i3[D4 + 1 | 0] << 8 | i3[D4 + 2 | 0] << 16 | i3[D4 + 3 | 0] << 24), E3[D4 >> 2] = K4, _4 = n4 ^ (i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24), E3[Q4 + 68 >> 2] = _4, p4 = k4 ^ (i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24), E3[Q4 + 72 >> 2] = p4, H4 = h4 ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24), E3[Q4 + 76 >> 2] = H4, 7 != (0 | (s4 = s4 + 1 | 0)); ) ; + A: { + I: { + g: { + if (g6 = I7 - 16 | 0) { + if (16 == (0 | g6)) break g; + break I; + } + D4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, a4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, w4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, f4 = i3[Q4 + 96 | 0] | i3[Q4 + 97 | 0] << 8 | i3[Q4 + 98 | 0] << 16 | i3[Q4 + 99 | 0] << 24, e4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, c4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, y4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, t4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, h4 = i3[Q4 + 100 | 0] | i3[Q4 + 101 | 0] << 8 | i3[Q4 + 102 | 0] << 16 | i3[Q4 + 103 | 0] << 24, k4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, n4 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, s4 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, B4 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, g6 = i3[Q4 + 104 | 0] | i3[Q4 + 105 | 0] << 8 | i3[Q4 + 106 | 0] << 16 | i3[Q4 + 107 | 0] << 24, I7 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, Q4 = F4 ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24) ^ (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 108 | 0] | i3[Q4 + 109 | 0] << 8 | i3[Q4 + 110 | 0] << 16 | i3[Q4 + 111 | 0] << 24) ^ H4, C3[A8 + 12 | 0] = Q4, C3[A8 + 13 | 0] = Q4 >>> 8, C3[A8 + 14 | 0] = Q4 >>> 16, C3[A8 + 15 | 0] = Q4 >>> 24, I7 = n4 ^ s4 ^ B4 ^ I7 ^ g6 ^ p4 ^ S4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = c4 ^ y4 ^ t4 ^ h4 ^ k4 ^ _4 ^ M4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = D4 ^ a4 ^ w4 ^ f4 ^ e4 ^ K4 ^ N4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24; + break A; + } + y4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, t4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, h4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, k4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, n4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, s4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, B4 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, g6 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, I7 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, c4 = F4 ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24) ^ (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24), C3[A8 + 12 | 0] = c4, C3[A8 + 13 | 0] = c4 >>> 8, C3[A8 + 14 | 0] = c4 >>> 16, C3[A8 + 15 | 0] = c4 >>> 24, I7 = B4 ^ I7 ^ g6 ^ S4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = k4 ^ n4 ^ s4 ^ M4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = y4 ^ t4 ^ h4 ^ N4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, f4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, e4 = i3[0 | (I7 = Q4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, c4 = i3[Q4 + 112 | 0] | i3[Q4 + 113 | 0] << 8 | i3[Q4 + 114 | 0] << 16 | i3[Q4 + 115 | 0] << 24, y4 = i3[Q4 + 96 | 0] | i3[Q4 + 97 | 0] << 8 | i3[Q4 + 98 | 0] << 16 | i3[Q4 + 99 | 0] << 24, t4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, h4 = i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24, k4 = i3[Q4 + 116 | 0] | i3[Q4 + 117 | 0] << 8 | i3[Q4 + 118 | 0] << 16 | i3[Q4 + 119 | 0] << 24, n4 = i3[Q4 + 100 | 0] | i3[Q4 + 101 | 0] << 8 | i3[Q4 + 102 | 0] << 16 | i3[Q4 + 103 | 0] << 24, s4 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, B4 = i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24, g6 = i3[Q4 + 120 | 0] | i3[Q4 + 121 | 0] << 8 | i3[Q4 + 122 | 0] << 16 | i3[Q4 + 123 | 0] << 24, I7 = i3[Q4 + 104 | 0] | i3[Q4 + 105 | 0] << 8 | i3[Q4 + 106 | 0] << 16 | i3[Q4 + 107 | 0] << 24, Q4 = (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24) ^ (i3[Q4 + 124 | 0] | i3[Q4 + 125 | 0] << 8 | i3[Q4 + 126 | 0] << 16 | i3[Q4 + 127 | 0] << 24) ^ (i3[Q4 + 108 | 0] | i3[Q4 + 109 | 0] << 8 | i3[Q4 + 110 | 0] << 16 | i3[Q4 + 111 | 0] << 24), C3[A8 + 28 | 0] = Q4, C3[A8 + 29 | 0] = Q4 >>> 8, C3[A8 + 30 | 0] = Q4 >>> 16, C3[A8 + 31 | 0] = Q4 >>> 24, I7 = s4 ^ B4 ^ I7 ^ g6, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = t4 ^ h4 ^ k4 ^ n4, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = f4 ^ e4 ^ c4 ^ y4, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24; + break A; + } + VA(A8, 0, I7); + } + r3 = o4 + 288 | 0; + } + function _3(A8, I7) { + var g6, C4, B4, Q4, i4, o4, D4, a4, y4, f4, e4, w4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0; + r3 = g6 = r3 - 48 | 0, U3(A8, I7), U3(A8 + 80 | 0, I7 + 40 | 0), H4 = PA(m4 = (IA2 = E3[I7 + 92 >> 2]) << 1, i4 = m4 >> 31, v4 = (Y4 = E3[I7 + 84 >> 2]) << 1, C4 = v4 >> 31), J4 = t3, AA2 = z2 = E3[I7 + 88 >> 2], G4 = (x4 = PA(z2, O2 = z2 >> 31, z2, O2)) + H4 | 0, H4 = t3 + J4 | 0, H4 = G4 >>> 0 < x4 >>> 0 ? H4 + 1 | 0 : H4, J4 = PA(d4 = E3[I7 + 96 >> 2], o4 = d4 >> 31, x4 = (R4 = E3[I7 + 80 >> 2]) << 1, B4 = x4 >> 31), H4 = t3 + H4 | 0, H4 = (G4 = J4 + G4 | 0) >>> 0 < J4 >>> 0 ? H4 + 1 | 0 : H4, CA2 = E3[I7 + 108 >> 2], J4 = PA(u4 = c3(CA2, 38), e4 = u4 >> 31, CA2, k4 = CA2 >> 31), H4 = t3 + H4 | 0, H4 = (G4 = J4 + G4 | 0) >>> 0 < J4 >>> 0 ? H4 + 1 | 0 : H4, J4 = G4, W2 = E3[I7 + 112 >> 2], L4 = PA(b4 = c3(W2, 19), D4 = b4 >> 31, G4 = (T2 = E3[I7 + 104 >> 2]) << 1, G4 >> 31), G4 = t3 + H4 | 0, G4 = (J4 = J4 + L4 | 0) >>> 0 < L4 >>> 0 ? G4 + 1 | 0 : G4, EA2 = E3[I7 + 116 >> 2], H4 = PA(L4 = c3(EA2, 38), Q4 = L4 >> 31, X2 = (Z2 = E3[I7 + 100 >> 2]) << 1, y4 = X2 >> 31), G4 = t3 + G4 | 0, iA2 = H4 = (H4 >>> 0 > (J4 = H4 + J4 | 0) >>> 0 ? G4 + 1 : G4) << 1 | J4 >>> 31, oA2 = J4 = 33554432 + (n4 = J4 << 1) | 0, cA2 = H4 = J4 >>> 0 < 33554432 ? H4 + 1 | 0 : H4, P4 = (67108863 & H4) << 6 | J4 >>> 26, V2 = H4 >> 26, H4 = PA(v4, C4, d4, o4), J4 = t3, G4 = ($2 = PA(z2 <<= 1, f4 = z2 >> 31, IA2, s4 = IA2 >> 31)) + H4 | 0, H4 = t3 + J4 | 0, H4 = G4 >>> 0 < $2 >>> 0 ? H4 + 1 | 0 : H4, J4 = ($2 = PA(Z2, w4 = Z2 >> 31, x4, B4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = J4 >>> 0 < $2 >>> 0 ? G4 + 1 | 0 : G4, BA2 = PA(b4, D4, $2 = CA2 << 1, F4 = $2 >> 31), H4 = t3 + G4 | 0, H4 = (J4 = BA2 + J4 | 0) >>> 0 < BA2 >>> 0 ? H4 + 1 | 0 : H4, G4 = PA(L4, Q4, T2, a4 = T2 >> 31), H4 = t3 + H4 | 0, G4 = (G4 = (G4 >>> 0 > (J4 = G4 + J4 | 0) >>> 0 ? H4 + 1 : H4) << 1 | J4 >>> 31) + V2 | 0, BA2 = J4 = (H4 = J4 << 1) + P4 | 0, H4 = G4 = H4 >>> 0 > J4 >>> 0 ? G4 + 1 | 0 : G4, DA2 = J4 = J4 + 16777216 | 0, P4 = (33554431 & (H4 = J4 >>> 0 < 16777216 ? H4 + 1 | 0 : H4)) << 7 | J4 >>> 25, V2 = H4 >> 25, H4 = PA(m4, i4, IA2, s4), J4 = t3, G4 = (j2 = PA(d4, o4, z2, f4)) + H4 | 0, H4 = t3 + J4 | 0, H4 = G4 >>> 0 < j2 >>> 0 ? H4 + 1 | 0 : H4, J4 = PA(v4, C4, X2, y4), H4 = t3 + H4 | 0, H4 = (G4 = J4 + G4 | 0) >>> 0 < J4 >>> 0 ? H4 + 1 | 0 : H4, J4 = (j2 = PA(x4, B4, T2, a4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = J4 >>> 0 < j2 >>> 0 ? G4 + 1 | 0 : G4, j2 = PA(b4, D4, W2, h4 = W2 >> 31), H4 = t3 + G4 | 0, H4 = (J4 = j2 + J4 | 0) >>> 0 < j2 >>> 0 ? H4 + 1 | 0 : H4, j2 = PA(L4, Q4, $2, F4), G4 = t3 + H4 | 0, G4 = ((J4 = j2 + J4 | 0) >>> 0 < j2 >>> 0 ? G4 + 1 : G4) << 1 | J4 >>> 31, J4 = (H4 = P4) + (P4 = J4 << 1) | 0, H4 = G4 + V2 | 0, H4 = J4 >>> 0 < P4 >>> 0 ? H4 + 1 | 0 : H4, V2 = J4, j2 = G4 = J4 + 33554432 | 0, J4 = H4 = G4 >>> 0 < 33554432 ? H4 + 1 | 0 : H4, E3[A8 + 144 >> 2] = V2 - (-67108864 & G4), V2 = PA(H4 = c3(Z2, 38), H4 >> 31, Z2, w4), P4 = t3, R4 = PA(H4 = R4, G4 = H4 >> 31, H4, G4), G4 = t3 + P4 | 0, G4 = (H4 = R4 + V2 | 0) >>> 0 < R4 >>> 0 ? G4 + 1 | 0 : G4, P4 = (gA2 = PA(R4 = c3(T2, 19), S4 = R4 >> 31, V2 = d4 << 1, M4 = V2 >> 31)) + H4 | 0, H4 = t3 + G4 | 0, H4 = P4 >>> 0 < gA2 >>> 0 ? H4 + 1 | 0 : H4, G4 = P4, P4 = PA(m4, i4, u4, e4), H4 = t3 + H4 | 0, H4 = (G4 = G4 + P4 | 0) >>> 0 < P4 >>> 0 ? H4 + 1 | 0 : H4, P4 = (gA2 = PA(b4, D4, z2, f4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = P4 >>> 0 < gA2 >>> 0 ? G4 + 1 | 0 : G4, gA2 = PA(v4, C4, L4, Q4), H4 = t3 + G4 | 0, gA2 = H4 = ((P4 = gA2 + P4 | 0) >>> 0 < gA2 >>> 0 ? H4 + 1 : H4) << 1 | P4 >>> 31, _4 = G4 = (P4 = 33554432 + (N4 = P4 << 1) | 0) >>> 0 < 33554432 ? H4 + 1 | 0 : H4, QA2 = (67108863 & G4) << 6 | P4 >>> 26, aA2 = G4 >> 26, H4 = PA(R4, S4, X2, y4), q4 = t3, l3 = Y4, G4 = (Y4 = PA(x4, B4, Y4, K4 = Y4 >> 31)) + H4 | 0, H4 = t3 + q4 | 0, H4 = G4 >>> 0 < Y4 >>> 0 ? H4 + 1 | 0 : H4, Y4 = (q4 = PA(d4, o4, u4, e4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = Y4 >>> 0 < q4 >>> 0 ? G4 + 1 | 0 : G4, q4 = PA(b4, D4, m4, i4), H4 = t3 + G4 | 0, H4 = (Y4 = q4 + Y4 | 0) >>> 0 < q4 >>> 0 ? H4 + 1 | 0 : H4, q4 = PA(L4, Q4, AA2, O2), G4 = t3 + H4 | 0, G4 = ((Y4 = q4 + Y4 | 0) >>> 0 < q4 >>> 0 ? G4 + 1 : G4) << 1 | Y4 >>> 31, Y4 = (H4 = QA2) + (QA2 = Y4 << 1) | 0, H4 = G4 + aA2 | 0, H4 = Y4 >>> 0 < QA2 >>> 0 ? H4 + 1 | 0 : H4, aA2 = Y4, QA2 = Y4 = Y4 + 16777216 | 0, p4 = (33554431 & (H4 = Y4 >>> 0 < 16777216 ? H4 + 1 | 0 : H4)) << 7 | Y4 >>> 25, q4 = H4 >> 25, H4 = PA(x4, B4, AA2, O2), Y4 = t3, G4 = (l3 = PA(v4, C4, l3, K4)) + H4 | 0, H4 = t3 + Y4 | 0, Y4 = (R4 = PA(R4, S4, T2, a4)) + G4 | 0, G4 = t3 + (G4 >>> 0 < l3 >>> 0 ? H4 + 1 | 0 : H4) | 0, G4 = Y4 >>> 0 < R4 >>> 0 ? G4 + 1 | 0 : G4, R4 = PA(X2, y4, u4, e4), H4 = t3 + G4 | 0, H4 = (Y4 = R4 + Y4 | 0) >>> 0 < R4 >>> 0 ? H4 + 1 | 0 : H4, G4 = Y4, Y4 = PA(b4, D4, V2, M4), H4 = t3 + H4 | 0, H4 = (G4 = G4 + Y4 | 0) >>> 0 < Y4 >>> 0 ? H4 + 1 | 0 : H4, Y4 = (R4 = PA(L4, Q4, m4, i4)) + G4 | 0, G4 = t3 + H4 | 0, H4 = (H4 = (Y4 >>> 0 < R4 >>> 0 ? G4 + 1 : G4) << 1 | Y4 >>> 31) + q4 | 0, l3 = Y4 = (G4 = Y4 << 1) + p4 | 0, H4 = G4 >>> 0 > Y4 >>> 0 ? H4 + 1 | 0 : H4, Y4 = (R4 = Y4 + 33554432 | 0) >>> 0 < 33554432 ? H4 + 1 | 0 : H4, E3[A8 + 128 >> 2] = l3 - (-67108864 & R4), H4 = PA(z2, f4, Z2, w4), G4 = t3, l3 = PA(d4, o4, m4, i4), G4 = t3 + G4 | 0, G4 = (H4 = l3 + H4 | 0) >>> 0 < l3 >>> 0 ? G4 + 1 | 0 : G4, l3 = (q4 = PA(v4, C4, T2, a4)) + H4 | 0, H4 = t3 + G4 | 0, H4 = l3 >>> 0 < q4 >>> 0 ? H4 + 1 | 0 : H4, q4 = PA(x4, B4, CA2, k4), G4 = t3 + H4 | 0, G4 = (l3 = q4 + l3 | 0) >>> 0 < q4 >>> 0 ? G4 + 1 | 0 : G4, q4 = PA(L4, Q4, W2, h4), H4 = t3 + G4 | 0, H4 = (G4 = J4 >> 26) + (((l3 = q4 + l3 | 0) >>> 0 < q4 >>> 0 ? H4 + 1 : H4) << 1 | l3 >>> 31) | 0, H4 = (J4 = (j2 = (67108863 & J4) << 6 | j2 >>> 26) + (l3 << 1) | 0) >>> 0 < j2 >>> 0 ? H4 + 1 | 0 : H4, j2 = J4, G4 = H4, l3 = H4 = J4 + 16777216 | 0, J4 = G4 = H4 >>> 0 < 16777216 ? G4 + 1 | 0 : G4, E3[A8 + 148 >> 2] = j2 - (-33554432 & H4), H4 = PA(x4, B4, IA2, s4), IA2 = t3, G4 = (O2 = PA(v4, C4, AA2, O2)) + H4 | 0, H4 = t3 + IA2 | 0, H4 = G4 >>> 0 < O2 >>> 0 ? H4 + 1 | 0 : H4, u4 = PA(T2, a4, u4, e4), H4 = t3 + H4 | 0, H4 = (G4 = u4 + G4 | 0) >>> 0 < u4 >>> 0 ? H4 + 1 | 0 : H4, b4 = (u4 = PA(b4, D4, X2, y4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = b4 >>> 0 < u4 >>> 0 ? G4 + 1 | 0 : G4, H4 = b4, b4 = PA(L4, Q4, d4, o4), G4 = t3 + G4 | 0, G4 = ((H4 = H4 + b4 | 0) >>> 0 < b4 >>> 0 ? G4 + 1 : G4) << 1, b4 = H4, H4 = (H4 = G4 | H4 >>> 31) + (G4 = Y4 >> 26) | 0, H4 = (Y4 = (j2 = b4 << 1) + (b4 = (67108863 & Y4) << 6 | R4 >>> 26) | 0) >>> 0 < b4 >>> 0 ? H4 + 1 | 0 : H4, b4 = Y4, u4 = G4 = Y4 + 16777216 | 0, Y4 = H4 = G4 >>> 0 < 16777216 ? H4 + 1 | 0 : H4, E3[A8 + 132 >> 2] = b4 - (-33554432 & G4), H4 = PA(T2, a4, z2, f4), b4 = t3, G4 = (d4 = PA(d4, o4, d4, o4)) + H4 | 0, H4 = t3 + b4 | 0, H4 = G4 >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = PA(m4, i4, X2, y4), H4 = t3 + H4 | 0, H4 = (G4 = d4 + G4 | 0) >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = PA(v4, C4, $2, F4), H4 = t3 + H4 | 0, H4 = (G4 = d4 + G4 | 0) >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = (b4 = PA(x4, B4, W2, h4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = d4 >>> 0 < b4 >>> 0 ? G4 + 1 | 0 : G4, H4 = d4, d4 = PA(d4 = L4, Q4, L4 = EA2, X2 = L4 >> 31), G4 = t3 + G4 | 0, G4 = ((H4 = H4 + d4 | 0) >>> 0 < d4 >>> 0 ? G4 + 1 : G4) << 1, d4 = H4, H4 = (H4 = G4 | H4 >>> 31) + (G4 = J4 >> 25) | 0, H4 = (J4 = (b4 = d4 << 1) + (d4 = (33554431 & J4) << 7 | l3 >>> 25) | 0) >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = J4, b4 = G4 = J4 + 33554432 | 0, J4 = H4 = G4 >>> 0 < 33554432 ? H4 + 1 | 0 : H4, E3[A8 + 152 >> 2] = d4 - (-67108864 & G4), G4 = n4 - (H4 = -67108864 & oA2) | 0, d4 = iA2 - ((H4 >>> 0 > n4 >>> 0) + cA2 | 0) | 0, H4 = Y4 >> 25, Y4 = (u4 = (33554431 & Y4) << 7 | u4 >>> 25) + G4 | 0, G4 = H4 + d4 | 0, d4 = Y4, H4 = G4 = Y4 >>> 0 < u4 >>> 0 ? G4 + 1 | 0 : G4, H4 = ((67108863 & (H4 = (Y4 = Y4 + 33554432 | 0) >>> 0 < 33554432 ? H4 + 1 | 0 : H4)) << 6 | Y4 >>> 26) + (O2 = BA2 - (-33554432 & DA2) | 0) | 0, E3[A8 + 140 >> 2] = H4, E3[A8 + 136 >> 2] = d4 - (-67108864 & Y4), H4 = PA(m4, i4, T2, a4), G4 = t3, Y4 = PA(Z2, w4, V2, M4), G4 = t3 + G4 | 0, G4 = (H4 = Y4 + H4 | 0) >>> 0 < Y4 >>> 0 ? G4 + 1 | 0 : G4, Y4 = (m4 = PA(z2, f4, CA2, k4)) + H4 | 0, H4 = t3 + G4 | 0, H4 = Y4 >>> 0 < m4 >>> 0 ? H4 + 1 | 0 : H4, v4 = PA(v4, C4, W2, h4), G4 = t3 + H4 | 0, G4 = (Y4 = v4 + Y4 | 0) >>> 0 < v4 >>> 0 ? G4 + 1 | 0 : G4, v4 = PA(x4, B4, L4, X2), H4 = t3 + G4 | 0, H4 = (H4 = ((Y4 = v4 + Y4 | 0) >>> 0 < v4 >>> 0 ? H4 + 1 : H4) << 1 | Y4 >>> 31) + (G4 = J4 >> 26) | 0, G4 = (J4 = (d4 = Y4 << 1) + (Y4 = (67108863 & J4) << 6 | b4 >>> 26) | 0) >>> 0 < Y4 >>> 0 ? H4 + 1 | 0 : H4, G4 = (H4 = J4 + 16777216 | 0) >>> 0 < 16777216 ? G4 + 1 | 0 : G4, E3[A8 + 156 >> 2] = J4 - (-33554432 & H4), Y4 = aA2 - (-33554432 & QA2) | 0, v4 = N4 - (J4 = -67108864 & P4) | 0, x4 = gA2 - ((J4 >>> 0 > N4 >>> 0) + _4 | 0) | 0, J4 = PA((33554431 & G4) << 7 | H4 >>> 25, G4 >> 25, 19, 0), G4 = t3 + x4 | 0, G4 = (H4 = J4 + v4 | 0) >>> 0 < J4 >>> 0 ? G4 + 1 | 0 : G4, J4 = H4, G4 = ((67108863 & (G4 = (H4 = H4 + 33554432 | 0) >>> 0 < 33554432 ? G4 + 1 | 0 : G4)) << 6 | H4 >>> 26) + Y4 | 0, E3[A8 + 124 >> 2] = G4, E3[A8 + 120 >> 2] = J4 - (-67108864 & H4), H4 = E3[I7 + 44 >> 2], G4 = E3[I7 + 4 >> 2], J4 = E3[I7 + 48 >> 2], Y4 = E3[I7 + 8 >> 2], v4 = E3[I7 + 52 >> 2], x4 = E3[I7 + 12 >> 2], L4 = E3[I7 + 56 >> 2], m4 = E3[I7 + 16 >> 2], d4 = E3[I7 + 60 >> 2], b4 = E3[I7 + 20 >> 2], T2 = E3[I7 - -64 >> 2], X2 = E3[I7 + 24 >> 2], z2 = E3[I7 + 68 >> 2], u4 = E3[I7 + 28 >> 2], O2 = E3[I7 + 72 >> 2], Z2 = E3[I7 + 32 >> 2], W2 = E3[I7 + 40 >> 2], AA2 = E3[I7 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] + E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = O2 + Z2, E3[A8 + 68 >> 2] = u4 + z2, E3[(CA2 = A8 - -64 | 0) >> 2] = T2 + X2, E3[A8 + 60 >> 2] = d4 + b4, E3[A8 + 56 >> 2] = L4 + m4, E3[A8 + 52 >> 2] = v4 + x4, E3[A8 + 48 >> 2] = J4 + Y4, E3[A8 + 44 >> 2] = H4 + G4, E3[A8 + 40 >> 2] = W2 + AA2, U3(g6, A8 + 40 | 0), I7 = E3[A8 + 4 >> 2], H4 = E3[A8 + 84 >> 2], G4 = E3[A8 + 8 >> 2], J4 = E3[A8 + 88 >> 2], Y4 = E3[A8 + 12 >> 2], v4 = E3[A8 + 92 >> 2], x4 = E3[A8 + 16 >> 2], L4 = E3[A8 + 96 >> 2], m4 = E3[A8 + 20 >> 2], d4 = E3[A8 + 100 >> 2], b4 = E3[A8 + 24 >> 2], T2 = E3[A8 + 104 >> 2], X2 = E3[A8 + 28 >> 2], z2 = E3[A8 + 108 >> 2], u4 = E3[A8 + 32 >> 2], O2 = E3[A8 + 112 >> 2], Z2 = E3[A8 >> 2], W2 = E3[A8 + 80 >> 2], $2 = (AA2 = E3[A8 + 116 >> 2]) - (IA2 = E3[A8 + 36 >> 2]) | 0, E3[A8 + 116 >> 2] = $2, R4 = O2 - u4 | 0, E3[A8 + 112 >> 2] = R4, V2 = z2 - X2 | 0, E3[A8 + 108 >> 2] = V2, P4 = T2 - b4 | 0, E3[A8 + 104 >> 2] = P4, EA2 = d4 - m4 | 0, E3[A8 + 100 >> 2] = EA2, iA2 = L4 - x4 | 0, E3[A8 + 96 >> 2] = iA2, oA2 = v4 - Y4 | 0, E3[A8 + 92 >> 2] = oA2, cA2 = J4 - G4 | 0, E3[A8 + 88 >> 2] = cA2, BA2 = H4 - I7 | 0, E3[A8 + 84 >> 2] = BA2, DA2 = W2 - Z2 | 0, E3[A8 + 80 >> 2] = DA2, AA2 = AA2 + IA2 | 0, E3[A8 + 76 >> 2] = AA2, u4 = u4 + O2 | 0, E3[A8 + 72 >> 2] = u4, X2 = z2 + X2 | 0, E3[A8 + 68 >> 2] = X2, b4 = b4 + T2 | 0, E3[CA2 >> 2] = b4, m4 = d4 + m4 | 0, E3[A8 + 60 >> 2] = m4, x4 = L4 + x4 | 0, E3[A8 + 56 >> 2] = x4, Y4 = Y4 + v4 | 0, E3[A8 + 52 >> 2] = Y4, G4 = G4 + J4 | 0, E3[A8 + 48 >> 2] = G4, I7 = I7 + H4 | 0, E3[A8 + 44 >> 2] = I7, H4 = Z2 + W2 | 0, E3[A8 + 40 >> 2] = H4, J4 = E3[g6 >> 2], v4 = E3[g6 + 4 >> 2], L4 = E3[g6 + 8 >> 2], d4 = E3[g6 + 12 >> 2], T2 = E3[g6 + 16 >> 2], z2 = E3[g6 + 20 >> 2], O2 = E3[g6 + 24 >> 2], Z2 = E3[g6 + 28 >> 2], W2 = E3[g6 + 32 >> 2], E3[A8 + 36 >> 2] = E3[g6 + 36 >> 2] - AA2, E3[A8 + 32 >> 2] = W2 - u4, E3[A8 + 28 >> 2] = Z2 - X2, E3[A8 + 24 >> 2] = O2 - b4, E3[A8 + 20 >> 2] = z2 - m4, E3[A8 + 16 >> 2] = T2 - x4, E3[A8 + 12 >> 2] = d4 - Y4, E3[A8 + 8 >> 2] = L4 - G4, E3[A8 + 4 >> 2] = v4 - I7, E3[A8 >> 2] = J4 - H4, I7 = E3[A8 + 124 >> 2], H4 = E3[A8 + 128 >> 2], G4 = E3[A8 + 132 >> 2], J4 = E3[A8 + 136 >> 2], Y4 = E3[A8 + 140 >> 2], v4 = E3[A8 + 144 >> 2], x4 = E3[A8 + 148 >> 2], L4 = E3[A8 + 152 >> 2], m4 = E3[A8 + 120 >> 2], E3[A8 + 156 >> 2] = E3[A8 + 156 >> 2] - $2, E3[A8 + 152 >> 2] = L4 - R4, E3[A8 + 148 >> 2] = x4 - V2, E3[A8 + 144 >> 2] = v4 - P4, E3[A8 + 140 >> 2] = Y4 - EA2, E3[A8 + 136 >> 2] = J4 - iA2, E3[A8 + 132 >> 2] = G4 - oA2, E3[A8 + 128 >> 2] = H4 - cA2, E3[A8 + 124 >> 2] = I7 - BA2, E3[A8 + 120 >> 2] = m4 - DA2, r3 = g6 + 48 | 0; + } + function p3(A8, I7, g6, C4) { + var B4 = 0, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0; + for (B4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, E3[g6 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, E3[g6 + 4 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, E3[g6 + 8 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, E3[g6 + 12 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, E3[g6 + 16 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, E3[g6 + 20 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, E3[g6 + 24 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, E3[g6 + 28 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 32 | 0] | i3[I7 + 33 | 0] << 8 | i3[I7 + 34 | 0] << 16 | i3[I7 + 35 | 0] << 24, E3[g6 + 32 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 36 | 0] | i3[I7 + 37 | 0] << 8 | i3[I7 + 38 | 0] << 16 | i3[I7 + 39 | 0] << 24, E3[g6 + 36 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24, E3[g6 + 40 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, E3[g6 + 44 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 48 | 0] | i3[I7 + 49 | 0] << 8 | i3[I7 + 50 | 0] << 16 | i3[I7 + 51 | 0] << 24, E3[g6 + 48 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 52 | 0] | i3[I7 + 53 | 0] << 8 | i3[I7 + 54 | 0] << 16 | i3[I7 + 55 | 0] << 24, E3[g6 + 52 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 56 | 0] | i3[I7 + 57 | 0] << 8 | i3[I7 + 58 | 0] << 16 | i3[I7 + 59 | 0] << 24, E3[g6 + 56 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, I7 = i3[I7 + 60 | 0] | i3[I7 + 61 | 0] << 8 | i3[I7 + 62 | 0] << 16 | i3[I7 + 63 | 0] << 24, E3[g6 + 60 >> 2] = I7 << 24 | (65280 & I7) << 8 | I7 >>> 8 & 65280 | I7 >>> 24, I7 = E3[A8 + 28 >> 2], E3[C4 + 24 >> 2] = E3[A8 + 24 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[A8 + 20 >> 2], E3[C4 + 16 >> 2] = E3[A8 + 16 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[A8 + 12 >> 2], E3[C4 + 8 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 12 >> 2] = I7, I7 = E3[A8 + 4 >> 2], E3[C4 >> 2] = E3[A8 >> 2], E3[C4 + 4 >> 2] = I7; D4 = E3[C4 + 28 >> 2], B4 = (I7 = F4 << 2) + g6 | 0, o4 = E3[C4 + 16 >> 2], a4 = E3[B4 >> 2] + (gI(o4, 26) ^ gI(o4, 21) ^ gI(o4, 7)) | 0, f4 = (D4 = ((Q4 = E3[I7 + 34784 >> 2] + a4 | 0) + (o4 & ((a4 = E3[C4 + 24 >> 2]) ^ (e4 = E3[C4 + 20 >> 2])) ^ a4) | 0) + D4 | 0) + E3[C4 + 12 >> 2] | 0, E3[C4 + 12 >> 2] = f4, D4 = (r4 = D4 + (gI(y4 = E3[C4 >> 2], 30) ^ gI(y4, 19) ^ gI(y4, 10)) | 0) + (y4 & ((Q4 = E3[C4 + 8 >> 2]) | (c4 = E3[C4 + 4 >> 2])) | Q4 & c4) | 0, E3[C4 + 28 >> 2] = D4, Q4 = (r4 = Q4) + (a4 = (E3[(h4 = (Q4 = 4 | I7) + g6 | 0) >> 2] + ((a4 + (e4 ^ f4 & (o4 ^ e4)) | 0) + (gI(f4, 26) ^ gI(f4, 21) ^ gI(f4, 7)) | 0) | 0) + E3[Q4 + 34784 >> 2] | 0) | 0, E3[C4 + 8 >> 2] = Q4, a4 = (a4 + (D4 & (c4 | y4) | c4 & y4) | 0) + (gI(D4, 30) ^ gI(D4, 19) ^ gI(D4, 10)) | 0, E3[C4 + 24 >> 2] = a4, e4 = (r4 = c4) + (c4 = (((e4 + E3[(s4 = (c4 = 8 | I7) + g6 | 0) >> 2] | 0) + E3[c4 + 34784 >> 2] | 0) + (o4 ^ Q4 & (o4 ^ f4)) | 0) + (gI(Q4, 26) ^ gI(Q4, 21) ^ gI(Q4, 7)) | 0) | 0, E3[C4 + 4 >> 2] = e4, c4 = c4 + ((a4 & (D4 | y4) | D4 & y4) + (gI(a4, 30) ^ gI(a4, 19) ^ gI(a4, 10)) | 0) | 0, E3[C4 + 20 >> 2] = c4, o4 = (r4 = y4) + (y4 = (((o4 + E3[(S4 = (y4 = 12 | I7) + g6 | 0) >> 2] | 0) + E3[y4 + 34784 >> 2] | 0) + (f4 ^ e4 & (Q4 ^ f4)) | 0) + (gI(e4, 26) ^ gI(e4, 21) ^ gI(e4, 7)) | 0) | 0, E3[C4 >> 2] = o4, y4 = y4 + ((c4 & (D4 | a4) | D4 & a4) + (gI(c4, 30) ^ gI(c4, 19) ^ gI(c4, 10)) | 0) | 0, E3[C4 + 16 >> 2] = y4, f4 = (w4 = ((((r4 = f4) + E3[(M4 = (f4 = 16 | I7) + g6 | 0) >> 2] | 0) + E3[f4 + 34784 >> 2] | 0) + (Q4 ^ o4 & (Q4 ^ e4)) | 0) + (gI(o4, 26) ^ gI(o4, 21) ^ gI(o4, 7)) | 0) + ((y4 & (c4 | a4) | c4 & a4) + (gI(y4, 30) ^ gI(y4, 19) ^ gI(y4, 10)) | 0) | 0, E3[C4 + 12 >> 2] = f4, w4 = D4 + w4 | 0, E3[C4 + 28 >> 2] = w4, D4 = (Q4 = (((Q4 + E3[(N4 = (D4 = 20 | I7) + g6 | 0) >> 2] | 0) + E3[D4 + 34784 >> 2] | 0) + (e4 ^ w4 & (o4 ^ e4)) | 0) + (gI(w4, 26) ^ gI(w4, 21) ^ gI(w4, 7)) | 0) + ((f4 & (c4 | y4) | c4 & y4) + (gI(f4, 30) ^ gI(f4, 19) ^ gI(f4, 10)) | 0) | 0, E3[C4 + 8 >> 2] = D4, Q4 = Q4 + a4 | 0, E3[C4 + 24 >> 2] = Q4, a4 = (e4 = (((e4 + E3[(K4 = (a4 = 24 | I7) + g6 | 0) >> 2] | 0) + E3[a4 + 34784 >> 2] | 0) + (o4 ^ Q4 & (o4 ^ w4)) | 0) + (gI(Q4, 26) ^ gI(Q4, 21) ^ gI(Q4, 7)) | 0) + ((D4 & (y4 | f4) | y4 & f4) + (gI(D4, 30) ^ gI(D4, 19) ^ gI(D4, 10)) | 0) | 0, E3[C4 + 4 >> 2] = a4, e4 = c4 + e4 | 0, E3[C4 + 20 >> 2] = e4, c4 = (o4 = (((o4 + E3[(_4 = (c4 = 28 | I7) + g6 | 0) >> 2] | 0) + E3[c4 + 34784 >> 2] | 0) + (w4 ^ e4 & (Q4 ^ w4)) | 0) + (gI(e4, 26) ^ gI(e4, 21) ^ gI(e4, 7)) | 0) + ((a4 & (D4 | f4) | D4 & f4) + (gI(a4, 30) ^ gI(a4, 19) ^ gI(a4, 10)) | 0) | 0, E3[C4 >> 2] = c4, o4 = o4 + y4 | 0, E3[C4 + 16 >> 2] = o4, y4 = (w4 = (((w4 + E3[(p4 = (y4 = 32 | I7) + g6 | 0) >> 2] | 0) + E3[y4 + 34784 >> 2] | 0) + (Q4 ^ o4 & (Q4 ^ e4)) | 0) + (gI(o4, 26) ^ gI(o4, 21) ^ gI(o4, 7)) | 0) + ((c4 & (D4 | a4) | D4 & a4) + (gI(c4, 30) ^ gI(c4, 19) ^ gI(c4, 10)) | 0) | 0, E3[C4 + 28 >> 2] = y4, w4 = f4 + w4 | 0, E3[C4 + 12 >> 2] = w4, f4 = (Q4 = (((Q4 + E3[(H4 = (f4 = 36 | I7) + g6 | 0) >> 2] | 0) + E3[f4 + 34784 >> 2] | 0) + (e4 ^ w4 & (o4 ^ e4)) | 0) + (gI(w4, 26) ^ gI(w4, 21) ^ gI(w4, 7)) | 0) + ((y4 & (c4 | a4) | c4 & a4) + (gI(y4, 30) ^ gI(y4, 19) ^ gI(y4, 10)) | 0) | 0, E3[C4 + 24 >> 2] = f4, Q4 = Q4 + D4 | 0, E3[C4 + 8 >> 2] = Q4, D4 = (e4 = (((e4 + E3[(G4 = (D4 = 40 | I7) + g6 | 0) >> 2] | 0) + E3[D4 + 34784 >> 2] | 0) + (o4 ^ Q4 & (o4 ^ w4)) | 0) + (gI(Q4, 26) ^ gI(Q4, 21) ^ gI(Q4, 7)) | 0) + ((f4 & (c4 | y4) | c4 & y4) + (gI(f4, 30) ^ gI(f4, 19) ^ gI(f4, 10)) | 0) | 0, E3[C4 + 20 >> 2] = D4, e4 = a4 + e4 | 0, E3[C4 + 4 >> 2] = e4, r4 = (a4 = 44 | I7) + g6 | 0, a4 = (o4 = ((o4 + (E3[a4 + 34784 >> 2] + E3[r4 >> 2] | 0) | 0) + (w4 ^ e4 & (Q4 ^ w4)) | 0) + (gI(e4, 26) ^ gI(e4, 21) ^ gI(e4, 7)) | 0) + ((D4 & (y4 | f4) | y4 & f4) + (gI(D4, 30) ^ gI(D4, 19) ^ gI(D4, 10)) | 0) | 0, E3[C4 + 16 >> 2] = a4, c4 = c4 + o4 | 0, E3[C4 >> 2] = c4, n4 = (o4 = 48 | I7) + g6 | 0, o4 = (w4 = ((w4 + (E3[o4 + 34784 >> 2] + E3[n4 >> 2] | 0) | 0) + (Q4 ^ c4 & (Q4 ^ e4)) | 0) + (gI(c4, 26) ^ gI(c4, 21) ^ gI(c4, 7)) | 0) + ((a4 & (D4 | f4) | D4 & f4) + (gI(a4, 30) ^ gI(a4, 19) ^ gI(a4, 10)) | 0) | 0, E3[C4 + 12 >> 2] = o4, y4 = y4 + w4 | 0, E3[C4 + 28 >> 2] = y4, k4 = (w4 = 52 | I7) + g6 | 0, Q4 = (w4 = (((E3[w4 + 34784 >> 2] + E3[k4 >> 2] | 0) + Q4 | 0) + (e4 ^ y4 & (c4 ^ e4)) | 0) + (gI(y4, 26) ^ gI(y4, 21) ^ gI(y4, 7)) | 0) + ((o4 & (D4 | a4) | D4 & a4) + (gI(o4, 30) ^ gI(o4, 19) ^ gI(o4, 10)) | 0) | 0, E3[C4 + 8 >> 2] = Q4, f4 = f4 + w4 | 0, E3[C4 + 24 >> 2] = f4, w4 = (t4 = 56 | I7) + g6 | 0, e4 = (t4 = (((E3[t4 + 34784 >> 2] + E3[w4 >> 2] | 0) + e4 | 0) + (c4 ^ f4 & (c4 ^ y4)) | 0) + (gI(f4, 26) ^ gI(f4, 21) ^ gI(f4, 7)) | 0) + ((Q4 & (a4 | o4) | a4 & o4) + (gI(Q4, 30) ^ gI(Q4, 19) ^ gI(Q4, 10)) | 0) | 0, E3[C4 + 4 >> 2] = e4, D4 = D4 + t4 | 0, E3[C4 + 20 >> 2] = D4, t4 = (I7 |= 60) + g6 | 0, D4 = (I7 = ((c4 + (E3[I7 + 34784 >> 2] + E3[t4 >> 2] | 0) | 0) + (y4 ^ D4 & (y4 ^ f4)) | 0) + (gI(D4, 26) ^ gI(D4, 21) ^ gI(D4, 7)) | 0) + ((e4 & (Q4 | o4) | Q4 & o4) + (gI(e4, 30) ^ gI(e4, 19) ^ gI(e4, 10)) | 0) | 0, E3[C4 >> 2] = D4, E3[C4 + 16 >> 2] = I7 + a4, 48 != (0 | F4); ) c4 = E3[H4 >> 2], F4 = F4 + 16 | 0, I7 = E3[w4 >> 2], D4 = (Q4 = E3[B4 >> 2] + (c4 + (gI(I7, 15) ^ gI(I7, 13) ^ I7 >>> 10) | 0) | 0) + (gI(a4 = E3[h4 >> 2], 25) ^ gI(a4, 14) ^ a4 >>> 3) | 0, E3[(F4 << 2) + g6 >> 2] = D4, f4 = (o4 = (Q4 = (y4 = E3[G4 >> 2]) + a4 | 0) + (gI(a4 = E3[t4 >> 2], 15) ^ gI(a4, 13) ^ a4 >>> 10) | 0) + (gI(Q4 = E3[s4 >> 2], 25) ^ gI(Q4, 14) ^ Q4 >>> 3) | 0, E3[B4 + 68 >> 2] = f4, e4 = (r4 = ((o4 = Q4) + (Q4 = E3[r4 >> 2]) | 0) + (gI(D4, 15) ^ gI(D4, 13) ^ D4 >>> 10) | 0) + (gI(o4 = E3[S4 >> 2], 25) ^ gI(o4, 14) ^ o4 >>> 3) | 0, E3[B4 + 72 >> 2] = e4, w4 = (t4 = ((r4 = o4) + (o4 = E3[n4 >> 2]) | 0) + (gI(f4, 15) ^ gI(f4, 13) ^ f4 >>> 10) | 0) + (gI(r4 = E3[M4 >> 2], 25) ^ gI(r4, 14) ^ r4 >>> 3) | 0, E3[B4 + 76 >> 2] = w4, n4 = (t4 = ((t4 = r4) + (r4 = E3[k4 >> 2]) | 0) + (gI(e4, 15) ^ gI(e4, 13) ^ e4 >>> 10) | 0) + (gI(k4 = E3[N4 >> 2], 25) ^ gI(k4, 14) ^ k4 >>> 3) | 0, E3[B4 + 80 >> 2] = n4, k4 = (h4 = (I7 + k4 | 0) + (gI(w4, 15) ^ gI(w4, 13) ^ w4 >>> 10) | 0) + (gI(t4 = E3[K4 >> 2], 25) ^ gI(t4, 14) ^ t4 >>> 3) | 0, E3[B4 + 84 >> 2] = k4, t4 = ((a4 + t4 | 0) + (gI(s4 = E3[_4 >> 2], 25) ^ gI(s4, 14) ^ s4 >>> 3) | 0) + (gI(n4, 15) ^ gI(n4, 13) ^ n4 >>> 10) | 0, E3[B4 + 88 >> 2] = t4, f4 = ((h4 = E3[p4 >> 2]) + (f4 + (gI(c4, 25) ^ gI(c4, 14) ^ c4 >>> 3) | 0) | 0) + (gI(t4, 15) ^ gI(t4, 13) ^ t4 >>> 10) | 0, E3[B4 + 96 >> 2] = f4, h4 = ((D4 + s4 | 0) + (gI(h4, 25) ^ gI(h4, 14) ^ h4 >>> 3) | 0) + (gI(k4, 15) ^ gI(k4, 13) ^ k4 >>> 10) | 0, E3[B4 + 92 >> 2] = h4, w4 = (w4 + (y4 + (gI(Q4, 25) ^ gI(Q4, 14) ^ Q4 >>> 3) | 0) | 0) + (gI(f4, 15) ^ gI(f4, 13) ^ f4 >>> 10) | 0, E3[B4 + 104 >> 2] = w4, c4 = (e4 + (c4 + (gI(y4, 25) ^ gI(y4, 14) ^ y4 >>> 3) | 0) | 0) + (gI(h4, 15) ^ gI(h4, 13) ^ h4 >>> 10) | 0, E3[B4 + 100 >> 2] = c4, y4 = (k4 + (o4 + (gI(r4, 25) ^ gI(r4, 14) ^ r4 >>> 3) | 0) | 0) + (gI(w4, 15) ^ gI(w4, 13) ^ w4 >>> 10) | 0, E3[B4 + 112 >> 2] = y4, c4 = (n4 + (Q4 + (gI(o4, 25) ^ gI(o4, 14) ^ o4 >>> 3) | 0) | 0) + (gI(c4, 15) ^ gI(c4, 13) ^ c4 >>> 10) | 0, E3[B4 + 108 >> 2] = c4, J4 = B4, Y4 = (h4 + (I7 + (gI(a4, 25) ^ gI(a4, 14) ^ a4 >>> 3) | 0) | 0) + (gI(y4, 15) ^ gI(y4, 13) ^ y4 >>> 10) | 0, E3[J4 + 120 >> 2] = Y4, I7 = (t4 + (r4 + (gI(I7, 25) ^ gI(I7, 14) ^ I7 >>> 3) | 0) | 0) + (gI(c4, 15) ^ gI(c4, 13) ^ c4 >>> 10) | 0, E3[B4 + 116 >> 2] = I7, J4 = B4, Y4 = (f4 + (a4 + (gI(D4, 25) ^ gI(D4, 14) ^ D4 >>> 3) | 0) | 0) + (gI(I7, 15) ^ gI(I7, 13) ^ I7 >>> 10) | 0, E3[J4 + 124 >> 2] = Y4; + E3[A8 >> 2] = D4 + E3[A8 >> 2], E3[A8 + 4 >> 2] = E3[A8 + 4 >> 2] + E3[C4 + 4 >> 2], E3[A8 + 8 >> 2] = E3[A8 + 8 >> 2] + E3[C4 + 8 >> 2], E3[A8 + 12 >> 2] = E3[A8 + 12 >> 2] + E3[C4 + 12 >> 2], E3[A8 + 16 >> 2] = E3[A8 + 16 >> 2] + E3[C4 + 16 >> 2], E3[A8 + 20 >> 2] = E3[A8 + 20 >> 2] + E3[C4 + 20 >> 2], E3[A8 + 24 >> 2] = E3[A8 + 24 >> 2] + E3[C4 + 24 >> 2], E3[A8 + 28 >> 2] = E3[A8 + 28 >> 2] + E3[C4 + 28 >> 2]; + } + function H3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0; + r3 = B4 = r3 - 288 | 0, y4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, f4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, e4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, w4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, t4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, h4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, k4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, n4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, d4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, s4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, F4 = i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24, J4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, b4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, S4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, M4 = i3[g6 + 112 | 0] | i3[g6 + 113 | 0] << 8 | i3[g6 + 114 | 0] << 16 | i3[g6 + 115 | 0] << 24, G4 = i3[g6 + 96 | 0] | i3[g6 + 97 | 0] << 8 | i3[g6 + 98 | 0] << 16 | i3[g6 + 99 | 0] << 24, Y4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, P4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, N4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, K4 = i3[g6 + 116 | 0] | i3[g6 + 117 | 0] << 8 | i3[g6 + 118 | 0] << 16 | i3[g6 + 119 | 0] << 24, o4 = i3[g6 + 100 | 0] | i3[g6 + 101 | 0] << 8 | i3[g6 + 102 | 0] << 16 | i3[g6 + 103 | 0] << 24, U4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, v4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, _4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, p4 = i3[g6 + 120 | 0] | i3[g6 + 121 | 0] << 8 | i3[g6 + 122 | 0] << 16 | i3[g6 + 123 | 0] << 24, c4 = i3[g6 + 104 | 0] | i3[g6 + 105 | 0] << 8 | i3[g6 + 106 | 0] << 16 | i3[g6 + 107 | 0] << 24, H4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, Q4 = (D4 = i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) ^ (a4 = i3[g6 + 108 | 0] | i3[g6 + 109 | 0] << 8 | i3[g6 + 110 | 0] << 16 | i3[g6 + 111 | 0] << 24) & (i3[g6 + 124 | 0] | i3[g6 + 125 | 0] << 8 | i3[g6 + 126 | 0] << 16 | i3[g6 + 127 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24) ^ (i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24), C3[A8 + 28 | 0] = Q4, C3[A8 + 29 | 0] = Q4 >>> 8, C3[A8 + 30 | 0] = Q4 >>> 16, C3[A8 + 31 | 0] = Q4 >>> 24, v4 = U4 ^ c4 & p4 ^ v4 ^ _4, C3[A8 + 24 | 0] = v4, C3[A8 + 25 | 0] = v4 >>> 8, C3[A8 + 26 | 0] = v4 >>> 16, C3[A8 + 27 | 0] = v4 >>> 24, P4 = Y4 ^ o4 & K4 ^ P4 ^ N4, C3[A8 + 20 | 0] = P4, C3[A8 + 21 | 0] = P4 >>> 8, C3[A8 + 22 | 0] = P4 >>> 16, C3[A8 + 23 | 0] = P4 >>> 24, b4 = J4 ^ G4 & M4 ^ b4 ^ S4, C3[A8 + 16 | 0] = b4, C3[A8 + 17 | 0] = b4 >>> 8, C3[A8 + 18 | 0] = b4 >>> 16, C3[A8 + 19 | 0] = b4 >>> 24, d4 = F4 & D4 ^ d4 ^ s4 ^ a4, C3[A8 + 12 | 0] = d4, C3[A8 + 13 | 0] = d4 >>> 8, C3[A8 + 14 | 0] = d4 >>> 16, C3[A8 + 15 | 0] = d4 >>> 24, U4 = U4 & n4 ^ h4 ^ k4 ^ c4, C3[A8 + 8 | 0] = U4, C3[A8 + 9 | 0] = U4 >>> 8, C3[A8 + 10 | 0] = U4 >>> 16, C3[A8 + 11 | 0] = U4 >>> 24, Y4 = Y4 & t4 ^ e4 ^ w4 ^ o4, C3[A8 + 4 | 0] = Y4, C3[A8 + 5 | 0] = Y4 >>> 8, C3[A8 + 6 | 0] = Y4 >>> 16, C3[A8 + 7 | 0] = Y4 >>> 24, J4 = G4 ^ J4 & f4 ^ y4 ^ H4, C3[0 | A8] = J4, C3[A8 + 1 | 0] = J4 >>> 8, C3[A8 + 2 | 0] = J4 >>> 16, C3[A8 + 3 | 0] = J4 >>> 24, A8 = E3[g6 + 124 >> 2], E3[B4 + 280 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 284 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 272 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 276 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 248 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 252 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 240 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 244 >> 2] = A8, A8 = E3[g6 + 124 >> 2], E3[B4 + 232 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 224 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 228 >> 2] = A8, aA(I7 = B4 + 256 | 0, B4 + 240 | 0, B4 + 224 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 120 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 124 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 112 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 116 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 200 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 204 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 192 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 196 >> 2] = A8, aA(I7, B4 + 208 | 0, B4 + 192 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 104 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 108 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 96 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 100 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, G4 = E3[4 + (A8 = g6 - -64 | 0) >> 2], E3[B4 + 176 >> 2] = E3[A8 >> 2], E3[B4 + 180 >> 2] = G4, G4 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = G4, G4 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = G4, aA(I7, B4 + 176 | 0, B4 + 160 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 92 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 84 >> 2] = G4, G4 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = G4, G4 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = G4, G4 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = G4, G4 = E3[A8 + 4 >> 2], E3[B4 + 128 >> 2] = E3[A8 >> 2], E3[B4 + 132 >> 2] = G4, aA(I7, B4 + 144 | 0, B4 + 128 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 76 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[A8 >> 2] = E3[B4 + 256 >> 2], E3[A8 + 4 >> 2] = G4, G4 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = G4, G4 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = G4, G4 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = G4, G4 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = G4, aA(I7, B4 + 112 | 0, B4 + 96 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 60 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 52 >> 2] = G4, G4 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = G4, G4 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = G4, G4 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = G4, G4 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = G4, aA(I7, B4 + 80 | 0, B4 - -64 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 44 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 36 >> 2] = G4, G4 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = G4, G4 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = G4, G4 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = G4, G4 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = G4, aA(I7, B4 + 48 | 0, B4 + 32 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 28 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 20 >> 2] = G4, G4 = E3[B4 + 284 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 280 >> 2], E3[B4 + 28 >> 2] = G4, G4 = E3[B4 + 276 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 272 >> 2], E3[B4 + 20 >> 2] = G4, G4 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = G4, G4 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = G4, aA(I7, B4 + 16 | 0, B4), I7 = E3[B4 + 268 >> 2], E3[g6 + 8 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 12 >> 2] = I7, I7 = E3[B4 + 260 >> 2], E3[g6 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 4 >> 2] = I7, E3[g6 + 12 >> 2] = d4 ^ (i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24), E3[g6 + 8 >> 2] = U4 ^ (i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24), E3[g6 + 4 >> 2] = Y4 ^ (i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24), E3[g6 >> 2] = J4 ^ (i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24), E3[A8 >> 2] = b4 ^ (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24), E3[g6 + 68 >> 2] = P4 ^ (i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24), E3[g6 + 72 >> 2] = v4 ^ (i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24), E3[g6 + 76 >> 2] = Q4 ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24), r3 = B4 + 288 | 0; + } + function G3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, v4 = 0; + r3 = B4 = r3 - 288 | 0, S4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, M4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, Q4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, N4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, K4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, o4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, _4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, p4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, c4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, H4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, G4 = i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24, v4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, D4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, J4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, Y4 = i3[g6 + 112 | 0] | i3[g6 + 113 | 0] << 8 | i3[g6 + 114 | 0] << 16 | i3[g6 + 115 | 0] << 24, a4 = i3[g6 + 96 | 0] | i3[g6 + 97 | 0] << 8 | i3[g6 + 98 | 0] << 16 | i3[g6 + 99 | 0] << 24, y4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, f4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, U4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, d4 = i3[g6 + 116 | 0] | i3[g6 + 117 | 0] << 8 | i3[g6 + 118 | 0] << 16 | i3[g6 + 119 | 0] << 24, e4 = i3[g6 + 100 | 0] | i3[g6 + 101 | 0] << 8 | i3[g6 + 102 | 0] << 16 | i3[g6 + 103 | 0] << 24, w4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, t4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, b4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, P4 = i3[g6 + 120 | 0] | i3[g6 + 121 | 0] << 8 | i3[g6 + 122 | 0] << 16 | i3[g6 + 123 | 0] << 24, h4 = i3[g6 + 104 | 0] | i3[g6 + 105 | 0] << 8 | i3[g6 + 106 | 0] << 16 | i3[g6 + 107 | 0] << 24, k4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = (n4 = i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) ^ (s4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24) ^ (F4 = i3[g6 + 108 | 0] | i3[g6 + 109 | 0] << 8 | i3[g6 + 110 | 0] << 16 | i3[g6 + 111 | 0] << 24) & (i3[g6 + 124 | 0] | i3[g6 + 125 | 0] << 8 | i3[g6 + 126 | 0] << 16 | i3[g6 + 127 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24), C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = h4 & P4 ^ b4 ^ t4 ^ w4, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = e4 & d4 ^ U4 ^ f4 ^ y4, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = v4 ^ a4 & Y4 ^ J4 ^ D4, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, I7 = G4 & n4 ^ H4 ^ c4 ^ F4, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = w4 & p4 ^ _4 ^ o4 ^ h4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = y4 & K4 ^ N4 ^ Q4 ^ e4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = v4 & M4 ^ S4 ^ k4 ^ a4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, A8 = E3[g6 + 124 >> 2], E3[B4 + 280 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 284 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 272 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 276 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 248 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 252 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 240 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 244 >> 2] = A8, A8 = E3[g6 + 124 >> 2], E3[B4 + 232 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 224 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 228 >> 2] = A8, aA(I7 = B4 + 256 | 0, B4 + 240 | 0, B4 + 224 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 120 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 124 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 112 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 116 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 200 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 204 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 192 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 196 >> 2] = A8, aA(I7, B4 + 208 | 0, B4 + 192 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 104 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 108 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 96 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 100 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, v4 = E3[4 + (A8 = g6 - -64 | 0) >> 2], E3[B4 + 176 >> 2] = E3[A8 >> 2], E3[B4 + 180 >> 2] = v4, v4 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = v4, v4 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = v4, aA(I7, B4 + 176 | 0, B4 + 160 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 92 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 84 >> 2] = v4, v4 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = v4, v4 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = v4, v4 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = v4, v4 = E3[A8 + 4 >> 2], E3[B4 + 128 >> 2] = E3[A8 >> 2], E3[B4 + 132 >> 2] = v4, aA(I7, B4 + 144 | 0, B4 + 128 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 76 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[A8 >> 2] = E3[B4 + 256 >> 2], E3[A8 + 4 >> 2] = v4, v4 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = v4, v4 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = v4, v4 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = v4, v4 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = v4, aA(I7, B4 + 112 | 0, B4 + 96 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 60 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 52 >> 2] = v4, v4 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = v4, v4 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = v4, v4 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = v4, v4 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = v4, aA(I7, B4 + 80 | 0, B4 - -64 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 44 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 36 >> 2] = v4, v4 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = v4, v4 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = v4, v4 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = v4, v4 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = v4, aA(I7, B4 + 48 | 0, B4 + 32 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 28 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 20 >> 2] = v4, v4 = E3[B4 + 284 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 280 >> 2], E3[B4 + 28 >> 2] = v4, v4 = E3[B4 + 276 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 272 >> 2], E3[B4 + 20 >> 2] = v4, v4 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = v4, v4 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = v4, aA(I7, B4 + 16 | 0, B4), I7 = E3[B4 + 268 >> 2], E3[g6 + 8 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 12 >> 2] = I7, I7 = E3[B4 + 260 >> 2], E3[g6 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 4 >> 2] = I7, E3[g6 + 12 >> 2] = (i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24) ^ c4, E3[g6 + 8 >> 2] = (i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24) ^ o4, E3[g6 + 4 >> 2] = (i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24) ^ Q4, E3[g6 >> 2] = (i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24) ^ k4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ D4, E3[g6 + 68 >> 2] = (i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24) ^ f4, E3[g6 + 72 >> 2] = (i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24) ^ t4, E3[g6 + 76 >> 2] = s4 ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24), r3 = B4 + 288 | 0; + } + function J3(A8, I7, g6, B4, Q4) { + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0; + for (r3 = o4 = r3 - 224 | 0, k4 = (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ B4 >>> 29, n4 = (i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24) ^ B4 << 3, e4 = (i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24) ^ g6 >>> 29, t4 = (i3[0 | (c4 = Q4 + 48 | 0)] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24) ^ g6 << 3, D4 = Q4 + 16 | 0, a4 = Q4 + 32 | 0, y4 = Q4 - -64 | 0, f4 = Q4 + 80 | 0; g6 = E3[f4 + 12 >> 2], E3[o4 + 216 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 220 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 208 >> 2] = E3[f4 >> 2], E3[o4 + 212 >> 2] = g6, g6 = E3[y4 + 12 >> 2], E3[o4 + 184 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 188 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 176 >> 2] = E3[y4 >> 2], E3[o4 + 180 >> 2] = g6, g6 = E3[f4 + 12 >> 2], E3[o4 + 168 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 172 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 160 >> 2] = E3[f4 >> 2], E3[o4 + 164 >> 2] = g6, aA(B4 = o4 + 192 | 0, o4 + 176 | 0, o4 + 160 | 0), g6 = E3[o4 + 204 >> 2], E3[f4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[f4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[f4 >> 2] = E3[o4 + 192 >> 2], E3[f4 + 4 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 152 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 156 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 144 >> 2] = E3[c4 >> 2], E3[o4 + 148 >> 2] = g6, g6 = E3[y4 + 12 >> 2], E3[o4 + 136 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 140 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 128 >> 2] = E3[y4 >> 2], E3[o4 + 132 >> 2] = g6, aA(B4, o4 + 144 | 0, o4 + 128 | 0), g6 = E3[o4 + 204 >> 2], E3[y4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[y4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[y4 >> 2] = E3[o4 + 192 >> 2], E3[y4 + 4 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 120 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 124 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 112 >> 2] = E3[a4 >> 2], E3[o4 + 116 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 104 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 108 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 96 >> 2] = E3[c4 >> 2], E3[o4 + 100 >> 2] = g6, aA(B4, o4 + 112 | 0, o4 + 96 | 0), g6 = E3[o4 + 204 >> 2], E3[c4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[c4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[c4 >> 2] = E3[o4 + 192 >> 2], E3[c4 + 4 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 88 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 92 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 80 >> 2] = E3[D4 >> 2], E3[o4 + 84 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 72 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 76 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 64 >> 2] = E3[a4 >> 2], E3[o4 + 68 >> 2] = g6, aA(B4, o4 + 80 | 0, o4 - -64 | 0), g6 = E3[o4 + 204 >> 2], E3[a4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[a4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[a4 >> 2] = E3[o4 + 192 >> 2], E3[a4 + 4 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 56 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 60 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 + 48 >> 2] = E3[Q4 >> 2], E3[o4 + 52 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 40 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 44 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 32 >> 2] = E3[D4 >> 2], E3[o4 + 36 >> 2] = g6, aA(B4, o4 + 48 | 0, o4 + 32 | 0), g6 = E3[o4 + 204 >> 2], E3[D4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[D4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[D4 >> 2] = E3[o4 + 192 >> 2], E3[D4 + 4 >> 2] = g6, g6 = E3[o4 + 220 >> 2], E3[o4 + 24 >> 2] = E3[o4 + 216 >> 2], E3[o4 + 28 >> 2] = g6, g6 = E3[o4 + 212 >> 2], E3[o4 + 16 >> 2] = E3[o4 + 208 >> 2], E3[o4 + 20 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 8 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 12 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 >> 2] = E3[Q4 >> 2], E3[o4 + 4 >> 2] = g6, aA(B4, o4 + 16 | 0, o4), h4 = E3[o4 + 192 >> 2], B4 = E3[o4 + 196 >> 2], g6 = E3[o4 + 200 >> 2], s4 = k4 ^ E3[o4 + 204 >> 2], E3[Q4 + 12 >> 2] = s4, F4 = g6 ^ n4, E3[Q4 + 8 >> 2] = F4, S4 = B4 ^ e4, E3[Q4 + 4 >> 2] = S4, M4 = t4 ^ h4, E3[Q4 >> 2] = M4, 7 != (0 | (w4 = w4 + 1 | 0)); ) ; + A: { + I: { + g: { + if (g6 = I7 - 16 | 0) { + if (16 == (0 | g6)) break g; + break I; + } + N4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, c4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, D4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, a4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, y4 = i3[0 | (I7 = Q4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, f4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, k4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, n4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, e4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, t4 = i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24, h4 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, w4 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, B4 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, g6 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, I7 = i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24, Q4 = s4 ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24) ^ (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24), C3[A8 + 12 | 0] = Q4, C3[A8 + 13 | 0] = Q4 >>> 8, C3[A8 + 14 | 0] = Q4 >>> 16, C3[A8 + 15 | 0] = Q4 >>> 24, I7 = F4 ^ h4 ^ I7 ^ g6 ^ B4 ^ w4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = S4 ^ f4 ^ k4 ^ n4 ^ e4 ^ t4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = M4 ^ N4 ^ c4 ^ D4 ^ a4 ^ y4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24; + break A; + } + t4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, h4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, w4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, B4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, g6 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, I7 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, e4 = s4 ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24), C3[A8 + 12 | 0] = e4, C3[A8 + 13 | 0] = e4 >>> 8, C3[A8 + 14 | 0] = e4 >>> 16, C3[A8 + 15 | 0] = e4 >>> 24, I7 = F4 ^ I7 ^ g6, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = S4 ^ B4 ^ w4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = M4 ^ t4 ^ h4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, k4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, n4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, e4 = i3[0 | (I7 = Q4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, t4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, h4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, w4 = i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24, B4 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, g6 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, I7 = i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24, Q4 = (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24), C3[A8 + 28 | 0] = Q4, C3[A8 + 29 | 0] = Q4 >>> 8, C3[A8 + 30 | 0] = Q4 >>> 16, C3[A8 + 31 | 0] = Q4 >>> 24, I7 = B4 ^ I7 ^ g6, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = t4 ^ h4 ^ w4, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = k4 ^ e4 ^ n4, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24; + break A; + } + VA(A8, 0, I7); + } + r3 = o4 + 224 | 0; + } + function Y3(A8, I7, g6, C4) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0; + r3 = B4 = r3 - 320 | 0, E3[B4 + 280 >> 2] = 0, E3[B4 + 284 >> 2] = 0, E3[B4 + 272 >> 2] = 0, E3[B4 + 276 >> 2] = 0, E3[B4 + 264 >> 2] = 0, E3[B4 + 268 >> 2] = 0, E3[B4 + 256 >> 2] = 0, E3[B4 + 260 >> 2] = 0, TA(G4 = B4 + 256 | 0, I7, g6), P4 = i3[C4 + 16 | 0] | i3[C4 + 17 | 0] << 8 | i3[C4 + 18 | 0] << 16 | i3[C4 + 19 | 0] << 24, H4 = i3[C4 + 48 | 0] | i3[C4 + 49 | 0] << 8 | i3[C4 + 50 | 0] << 16 | i3[C4 + 51 | 0] << 24, c4 = i3[C4 + 20 | 0] | i3[C4 + 21 | 0] << 8 | i3[C4 + 22 | 0] << 16 | i3[C4 + 23 | 0] << 24, D4 = i3[C4 + 52 | 0] | i3[C4 + 53 | 0] << 8 | i3[C4 + 54 | 0] << 16 | i3[C4 + 55 | 0] << 24, a4 = i3[C4 + 24 | 0] | i3[C4 + 25 | 0] << 8 | i3[C4 + 26 | 0] << 16 | i3[C4 + 27 | 0] << 24, y4 = i3[C4 + 56 | 0] | i3[C4 + 57 | 0] << 8 | i3[C4 + 58 | 0] << 16 | i3[C4 + 59 | 0] << 24, f4 = i3[C4 + 28 | 0] | i3[C4 + 29 | 0] << 8 | i3[C4 + 30 | 0] << 16 | i3[C4 + 31 | 0] << 24, e4 = i3[C4 + 60 | 0] | i3[C4 + 61 | 0] << 8 | i3[C4 + 62 | 0] << 16 | i3[C4 + 63 | 0] << 24, I7 = i3[C4 + 36 | 0] | i3[C4 + 37 | 0] << 8 | i3[C4 + 38 | 0] << 16 | i3[C4 + 39 | 0] << 24, w4 = i3[C4 + 84 | 0] | i3[C4 + 85 | 0] << 8 | i3[C4 + 86 | 0] << 16 | i3[C4 + 87 | 0] << 24, t4 = i3[C4 + 116 | 0] | i3[C4 + 117 | 0] << 8 | i3[C4 + 118 | 0] << 16 | i3[C4 + 119 | 0] << 24, J4 = i3[C4 + 100 | 0] | i3[C4 + 101 | 0] << 8 | i3[C4 + 102 | 0] << 16 | i3[C4 + 103 | 0] << 24, Y4 = i3[C4 + 44 | 0] | i3[C4 + 45 | 0] << 8 | i3[C4 + 46 | 0] << 16 | i3[C4 + 47 | 0] << 24, h4 = i3[C4 + 92 | 0] | i3[C4 + 93 | 0] << 8 | i3[C4 + 94 | 0] << 16 | i3[C4 + 95 | 0] << 24, k4 = i3[C4 + 124 | 0] | i3[C4 + 125 | 0] << 8 | i3[C4 + 126 | 0] << 16 | i3[C4 + 127 | 0] << 24, U4 = i3[C4 + 108 | 0] | i3[C4 + 109 | 0] << 8 | i3[C4 + 110 | 0] << 16 | i3[C4 + 111 | 0] << 24, d4 = i3[C4 + 32 | 0] | i3[C4 + 33 | 0] << 8 | i3[C4 + 34 | 0] << 16 | i3[C4 + 35 | 0] << 24, n4 = i3[C4 + 80 | 0] | i3[C4 + 81 | 0] << 8 | i3[C4 + 82 | 0] << 16 | i3[C4 + 83 | 0] << 24, s4 = i3[C4 + 112 | 0] | i3[C4 + 113 | 0] << 8 | i3[C4 + 114 | 0] << 16 | i3[C4 + 115 | 0] << 24, b4 = i3[C4 + 96 | 0] | i3[C4 + 97 | 0] << 8 | i3[C4 + 98 | 0] << 16 | i3[C4 + 99 | 0] << 24, F4 = E3[B4 + 272 >> 2], S4 = E3[B4 + 256 >> 2], M4 = E3[B4 + 260 >> 2], N4 = E3[B4 + 264 >> 2], K4 = E3[B4 + 268 >> 2], _4 = E3[B4 + 276 >> 2], p4 = E3[B4 + 284 >> 2], Q4 = i3[C4 + 40 | 0] | i3[C4 + 41 | 0] << 8 | i3[C4 + 42 | 0] << 16 | i3[C4 + 43 | 0] << 24, o4 = i3[C4 + 104 | 0] | i3[C4 + 105 | 0] << 8 | i3[C4 + 106 | 0] << 16 | i3[C4 + 107 | 0] << 24, E3[B4 + 280 >> 2] = Q4 ^ o4 & (i3[C4 + 120 | 0] | i3[C4 + 121 | 0] << 8 | i3[C4 + 122 | 0] << 16 | i3[C4 + 123 | 0] << 24) ^ E3[B4 + 280 >> 2] ^ (i3[C4 + 88 | 0] | i3[C4 + 89 | 0] << 8 | i3[C4 + 90 | 0] << 16 | i3[C4 + 91 | 0] << 24), E3[B4 + 272 >> 2] = d4 ^ b4 & s4 ^ n4 ^ F4, E3[B4 + 284 >> 2] = Y4 ^ U4 & k4 ^ h4 ^ p4, E3[B4 + 276 >> 2] = I7 ^ J4 & t4 ^ w4 ^ _4, E3[B4 + 268 >> 2] = U4 ^ Y4 & e4 ^ f4 ^ K4, E3[B4 + 264 >> 2] = y4 & Q4 ^ a4 ^ N4 ^ o4, E3[B4 + 260 >> 2] = J4 ^ I7 & D4 ^ c4 ^ M4, E3[B4 + 256 >> 2] = b4 ^ H4 & d4 ^ P4 ^ S4, VA(g6 + G4 | 0, 0, 32 - g6 | 0), TA(A8, G4, g6), g6 = E3[B4 + 280 >> 2], G4 = E3[B4 + 272 >> 2], J4 = E3[B4 + 284 >> 2], Y4 = E3[B4 + 276 >> 2], U4 = E3[B4 + 256 >> 2], d4 = E3[B4 + 260 >> 2], b4 = E3[B4 + 264 >> 2], P4 = E3[B4 + 268 >> 2], A8 = E3[C4 + 124 >> 2], E3[B4 + 312 >> 2] = E3[C4 + 120 >> 2], E3[B4 + 316 >> 2] = A8, A8 = E3[C4 + 116 >> 2], E3[B4 + 304 >> 2] = E3[C4 + 112 >> 2], E3[B4 + 308 >> 2] = A8, A8 = E3[C4 + 108 >> 2], E3[B4 + 248 >> 2] = E3[C4 + 104 >> 2], E3[B4 + 252 >> 2] = A8, A8 = E3[C4 + 100 >> 2], E3[B4 + 240 >> 2] = E3[C4 + 96 >> 2], E3[B4 + 244 >> 2] = A8, A8 = E3[C4 + 124 >> 2], E3[B4 + 232 >> 2] = E3[C4 + 120 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[C4 + 116 >> 2], E3[B4 + 224 >> 2] = E3[C4 + 112 >> 2], E3[B4 + 228 >> 2] = A8, aA(I7 = B4 + 288 | 0, B4 + 240 | 0, B4 + 224 | 0), A8 = E3[B4 + 300 >> 2], E3[C4 + 120 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 124 >> 2] = A8, A8 = E3[B4 + 292 >> 2], E3[C4 + 112 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 116 >> 2] = A8, A8 = E3[C4 + 92 >> 2], E3[B4 + 216 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[C4 + 84 >> 2], E3[B4 + 208 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[C4 + 108 >> 2], E3[B4 + 200 >> 2] = E3[C4 + 104 >> 2], E3[B4 + 204 >> 2] = A8, A8 = E3[C4 + 100 >> 2], E3[B4 + 192 >> 2] = E3[C4 + 96 >> 2], E3[B4 + 196 >> 2] = A8, aA(I7, B4 + 208 | 0, B4 + 192 | 0), A8 = E3[B4 + 300 >> 2], E3[C4 + 104 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 108 >> 2] = A8, A8 = E3[B4 + 292 >> 2], E3[C4 + 96 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 100 >> 2] = A8, A8 = E3[C4 + 76 >> 2], E3[B4 + 184 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 188 >> 2] = A8, H4 = E3[4 + (A8 = C4 - -64 | 0) >> 2], E3[B4 + 176 >> 2] = E3[A8 >> 2], E3[B4 + 180 >> 2] = H4, H4 = E3[C4 + 92 >> 2], E3[B4 + 168 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 172 >> 2] = H4, H4 = E3[C4 + 84 >> 2], E3[B4 + 160 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 164 >> 2] = H4, aA(I7, B4 + 176 | 0, B4 + 160 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 88 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 92 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 80 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 84 >> 2] = H4, H4 = E3[C4 + 60 >> 2], E3[B4 + 152 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 156 >> 2] = H4, H4 = E3[C4 + 52 >> 2], E3[B4 + 144 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 148 >> 2] = H4, H4 = E3[C4 + 76 >> 2], E3[B4 + 136 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 140 >> 2] = H4, H4 = E3[A8 + 4 >> 2], E3[B4 + 128 >> 2] = E3[A8 >> 2], E3[B4 + 132 >> 2] = H4, aA(I7, B4 + 144 | 0, B4 + 128 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 72 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 76 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[A8 >> 2] = E3[B4 + 288 >> 2], E3[A8 + 4 >> 2] = H4, H4 = E3[C4 + 44 >> 2], E3[B4 + 120 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 124 >> 2] = H4, H4 = E3[C4 + 36 >> 2], E3[B4 + 112 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 116 >> 2] = H4, H4 = E3[C4 + 60 >> 2], E3[B4 + 104 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 108 >> 2] = H4, H4 = E3[C4 + 52 >> 2], E3[B4 + 96 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 100 >> 2] = H4, aA(I7, B4 + 112 | 0, B4 + 96 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 56 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 60 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 48 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 52 >> 2] = H4, H4 = E3[C4 + 28 >> 2], E3[B4 + 88 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 92 >> 2] = H4, H4 = E3[C4 + 20 >> 2], E3[B4 + 80 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 84 >> 2] = H4, H4 = E3[C4 + 44 >> 2], E3[B4 + 72 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 76 >> 2] = H4, H4 = E3[C4 + 36 >> 2], E3[B4 + 64 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 68 >> 2] = H4, aA(I7, B4 + 80 | 0, B4 - -64 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 40 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 44 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 32 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 36 >> 2] = H4, H4 = E3[C4 + 12 >> 2], E3[B4 + 56 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 60 >> 2] = H4, H4 = E3[C4 + 4 >> 2], E3[B4 + 48 >> 2] = E3[C4 >> 2], E3[B4 + 52 >> 2] = H4, H4 = E3[C4 + 28 >> 2], E3[B4 + 40 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 44 >> 2] = H4, H4 = E3[C4 + 20 >> 2], E3[B4 + 32 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 36 >> 2] = H4, aA(I7, B4 + 48 | 0, B4 + 32 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 24 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 28 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 16 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 20 >> 2] = H4, H4 = E3[B4 + 316 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 312 >> 2], E3[B4 + 28 >> 2] = H4, H4 = E3[B4 + 308 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 304 >> 2], E3[B4 + 20 >> 2] = H4, H4 = E3[C4 + 12 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 12 >> 2] = H4, H4 = E3[C4 + 4 >> 2], E3[B4 >> 2] = E3[C4 >> 2], E3[B4 + 4 >> 2] = H4, aA(I7, B4 + 16 | 0, B4), I7 = E3[B4 + 300 >> 2], E3[C4 + 8 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 12 >> 2] = I7, I7 = E3[B4 + 292 >> 2], E3[C4 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 4 >> 2] = I7, E3[C4 + 12 >> 2] = P4 ^ (i3[C4 + 12 | 0] | i3[C4 + 13 | 0] << 8 | i3[C4 + 14 | 0] << 16 | i3[C4 + 15 | 0] << 24), E3[C4 + 8 >> 2] = b4 ^ (i3[C4 + 8 | 0] | i3[C4 + 9 | 0] << 8 | i3[C4 + 10 | 0] << 16 | i3[C4 + 11 | 0] << 24), E3[C4 + 4 >> 2] = d4 ^ (i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24), E3[C4 >> 2] = U4 ^ (i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24), E3[A8 >> 2] = G4 ^ (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24), E3[C4 + 68 >> 2] = Y4 ^ (i3[C4 + 68 | 0] | i3[C4 + 69 | 0] << 8 | i3[C4 + 70 | 0] << 16 | i3[C4 + 71 | 0] << 24), E3[C4 + 72 >> 2] = g6 ^ (i3[C4 + 72 | 0] | i3[C4 + 73 | 0] << 8 | i3[C4 + 74 | 0] << 16 | i3[C4 + 75 | 0] << 24), E3[C4 + 76 >> 2] = J4 ^ (i3[C4 + 76 | 0] | i3[C4 + 77 | 0] << 8 | i3[C4 + 78 | 0] << 16 | i3[C4 + 79 | 0] << 24), r3 = B4 + 320 | 0; + } + function U3(A8, I7) { + var g6, C4, B4, Q4, i4, o4, D4, a4, y4, f4, e4, w4, r4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0; + v4 = PA(C4 = (n4 = E3[I7 + 12 >> 2]) << 1, o4 = C4 >> 31, n4, N4 = n4 >> 31), L4 = t3, R4 = (z2 = PA(u4 = E3[I7 + 16 >> 2], D4 = u4 >> 31, a4 = (x4 = E3[I7 + 8 >> 2]) << 1, w4 = a4 >> 31)) + v4 | 0, v4 = t3 + L4 | 0, v4 = R4 >>> 0 < z2 >>> 0 ? v4 + 1 | 0 : v4, L4 = (j2 = PA(T2 = (y4 = E3[I7 + 20 >> 2]) << 1, r4 = T2 >> 31, z2 = (m4 = E3[I7 + 4 >> 2]) << 1, B4 = z2 >> 31)) + R4 | 0, R4 = t3 + v4 | 0, R4 = L4 >>> 0 < j2 >>> 0 ? R4 + 1 | 0 : R4, q4 = PA(g6 = E3[I7 + 24 >> 2], f4 = g6 >> 31, j2 = (W2 = E3[I7 >> 2]) << 1, Q4 = j2 >> 31), v4 = t3 + R4 | 0, v4 = (L4 = q4 + L4 | 0) >>> 0 < q4 >>> 0 ? v4 + 1 | 0 : v4, R4 = L4, h4 = E3[I7 + 32 >> 2], L4 = PA(X2 = c3(h4, 19), e4 = X2 >> 31, h4, F4 = h4 >> 31), v4 = t3 + v4 | 0, v4 = (R4 = R4 + L4 | 0) >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, G4 = E3[I7 + 36 >> 2], L4 = PA(q4 = c3(G4, 38), i4 = q4 >> 31, S4 = (k4 = E3[I7 + 28 >> 2]) << 1, K4 = S4 >> 31), I7 = t3 + v4 | 0, Z2 = R4 = L4 + R4 | 0, L4 = R4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(z2, B4, u4, D4), v4 = t3, R4 = PA(a4, w4, n4, N4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, l3 = PA(y4, M4 = y4 >> 31, j2, Q4), R4 = t3 + v4 | 0, R4 = (I7 = l3 + I7 | 0) >>> 0 < l3 >>> 0 ? R4 + 1 | 0 : R4, l3 = PA(X2, e4, S4, K4), v4 = t3 + R4 | 0, v4 = (I7 = l3 + I7 | 0) >>> 0 < l3 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(q4, i4, g6, f4), v4 = t3 + v4 | 0, CA2 = I7 = R4 + I7 | 0, O2 = I7 >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, v4 = PA(z2, B4, C4, o4), R4 = t3, _4 = I7 = x4, x4 = PA(I7, V2 = I7 >> 31, I7, V2), I7 = t3 + R4 | 0, I7 = (v4 = x4 + v4 | 0) >>> 0 < x4 >>> 0 ? I7 + 1 | 0 : I7, R4 = (x4 = PA(j2, Q4, u4, D4)) + v4 | 0, v4 = t3 + I7 | 0, v4 = R4 >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, I7 = (x4 = PA(l3 = c3(k4, 38), s4 = l3 >> 31, k4, p4 = k4 >> 31)) + R4 | 0, R4 = t3 + v4 | 0, R4 = I7 >>> 0 < x4 >>> 0 ? R4 + 1 | 0 : R4, I7 = (v4 = I7) + (x4 = PA(X2, e4, I7 = g6 << 1, I7 >> 31)) | 0, v4 = t3 + R4 | 0, v4 = I7 >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, R4 = I7, I7 = PA(q4, i4, T2, r4), v4 = t3 + v4 | 0, J4 = R4 = R4 + I7 | 0, Y4 = v4 = I7 >>> 0 > R4 >>> 0 ? v4 + 1 | 0 : v4, I7 = v4, U4 = R4 = R4 + 33554432 | 0, d4 = I7 = R4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, v4 = (v4 = I7 >> 26) + O2 | 0, CA2 = I7 = (R4 = (67108863 & I7) << 6 | R4 >>> 26) + CA2 | 0, v4 = I7 >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, b4 = I7 = I7 + 16777216 | 0, v4 = (v4 = (R4 = I7 >>> 0 < 16777216 ? v4 + 1 | 0 : v4) >> 25) + L4 | 0, I7 = (I7 = (33554431 & R4) << 7 | I7 >>> 25) >>> 0 > (R4 = I7 + Z2 | 0) >>> 0 ? v4 + 1 | 0 : v4, Z2 = v4 = R4 + 33554432 | 0, x4 = I7 = v4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[A8 + 24 >> 2] = R4 - (-67108864 & v4), I7 = PA(j2, Q4, _4, V2), v4 = t3, L4 = PA(z2, B4, m4, $2 = m4 >> 31), R4 = t3 + v4 | 0, R4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? R4 + 1 | 0 : R4, O2 = PA(L4 = c3(g6, 19), gA2 = L4 >> 31, g6, f4), v4 = t3 + R4 | 0, v4 = (I7 = O2 + I7 | 0) >>> 0 < O2 >>> 0 ? v4 + 1 | 0 : v4, R4 = (O2 = PA(T2, r4, l3, s4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < O2 >>> 0 ? I7 + 1 | 0 : I7, AA2 = PA(X2, e4, O2 = u4 << 1, H4 = O2 >> 31), v4 = t3 + I7 | 0, v4 = (R4 = AA2 + R4 | 0) >>> 0 < AA2 >>> 0 ? v4 + 1 | 0 : v4, I7 = R4, R4 = PA(q4, i4, C4, o4), v4 = t3 + v4 | 0, IA2 = I7 = I7 + R4 | 0, AA2 = I7 >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, I7 = PA(T2, r4, L4, gA2), v4 = t3, m4 = PA(j2, Q4, m4, $2), R4 = t3 + v4 | 0, R4 = (I7 = m4 + I7 | 0) >>> 0 < m4 >>> 0 ? R4 + 1 | 0 : R4, m4 = PA(u4, D4, l3, s4), v4 = t3 + R4 | 0, v4 = (I7 = m4 + I7 | 0) >>> 0 < m4 >>> 0 ? v4 + 1 | 0 : v4, R4 = (m4 = PA(X2, e4, C4, o4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, m4 = PA(q4, i4, _4, V2), v4 = t3 + I7 | 0, BA2 = R4 = m4 + R4 | 0, $2 = R4 >>> 0 < m4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(I7 = c3(y4, 38), I7 >> 31, y4, M4), m4 = t3, I7 = W2, W2 = R4, R4 = PA(I7, v4 = I7 >> 31, I7, v4), v4 = t3 + m4 | 0, v4 = (I7 = W2 + R4 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, L4 = PA(L4, gA2, O2, H4), R4 = t3 + v4 | 0, R4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? R4 + 1 | 0 : R4, L4 = PA(C4, o4, l3, s4), v4 = t3 + R4 | 0, v4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, R4 = (L4 = PA(X2, e4, a4, w4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, L4 = PA(z2, B4, q4, i4), v4 = t3 + I7 | 0, m4 = R4 = L4 + R4 | 0, W2 = v4 = R4 >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, gA2 = R4 = R4 + 33554432 | 0, P4 = v4 = R4 >>> 0 < 33554432 ? v4 + 1 | 0 : v4, I7 = v4 >> 26, v4 = (67108863 & v4) << 6 | R4 >>> 26, R4 = I7 + $2 | 0, $2 = L4 = v4 + BA2 | 0, v4 = v4 >>> 0 > L4 >>> 0 ? R4 + 1 | 0 : R4, BA2 = R4 = L4 + 16777216 | 0, L4 = (33554431 & (v4 = R4 >>> 0 < 16777216 ? v4 + 1 | 0 : v4)) << 7 | R4 >>> 25, v4 = (v4 >> 25) + AA2 | 0, v4 = (R4 = L4 + IA2 | 0) >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, AA2 = I7 = R4 + 33554432 | 0, L4 = v4 = I7 >>> 0 < 33554432 ? v4 + 1 | 0 : v4, E3[A8 + 8 >> 2] = R4 - (-67108864 & I7), I7 = PA(a4, w4, y4, M4), v4 = t3, R4 = PA(u4, D4, C4, o4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(z2, B4, g6, f4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(j2, Q4, k4, p4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, IA2 = (R4 = PA(q4, i4, h4, F4)) + I7 | 0, I7 = t3 + v4 | 0, R4 = (v4 = x4 >> 26) + (R4 = R4 >>> 0 > IA2 >>> 0 ? I7 + 1 | 0 : I7) | 0, Z2 = I7 = (x4 = (67108863 & x4) << 6 | Z2 >>> 26) + IA2 | 0, v4 = I7 >>> 0 < x4 >>> 0 ? R4 + 1 | 0 : R4, IA2 = I7 = I7 + 16777216 | 0, x4 = v4 = I7 >>> 0 < 16777216 ? v4 + 1 | 0 : v4, E3[A8 + 28 >> 2] = Z2 - (-33554432 & I7), I7 = PA(j2, Q4, n4, N4), R4 = t3, v4 = (V2 = PA(z2, B4, _4, V2)) + I7 | 0, I7 = t3 + R4 | 0, I7 = v4 >>> 0 < V2 >>> 0 ? I7 + 1 | 0 : I7, v4 = (l3 = PA(g6, f4, l3, s4)) + v4 | 0, R4 = t3 + I7 | 0, I7 = (X2 = PA(X2, e4, T2, r4)) + v4 | 0, v4 = t3 + (v4 >>> 0 < l3 >>> 0 ? R4 + 1 | 0 : R4) | 0, v4 = I7 >>> 0 < X2 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(q4, i4, u4, D4), v4 = t3 + v4 | 0, v4 = (v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4) + (R4 = L4 >> 26) | 0, I7 = (R4 = L4 = (Z2 = I7) + (I7 = (67108863 & L4) << 6 | AA2 >>> 26) | 0) >>> 0 < I7 >>> 0 ? v4 + 1 | 0 : v4, X2 = v4 = R4 + 16777216 | 0, L4 = I7 = v4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 12 >> 2] = R4 - (-33554432 & v4), I7 = PA(g6, f4, a4, w4), v4 = t3, R4 = PA(u4, D4, u4, D4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(C4, o4, T2, r4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = (u4 = PA(z2, B4, S4, K4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7, v4 = (u4 = PA(j2, Q4, h4, F4)) + R4 | 0, R4 = t3 + I7 | 0, R4 = v4 >>> 0 < u4 >>> 0 ? R4 + 1 | 0 : R4, I7 = (u4 = PA(I7 = q4, i4, q4 = G4, T2 = q4 >> 31)) + v4 | 0, v4 = t3 + R4 | 0, v4 = I7 >>> 0 < u4 >>> 0 ? v4 + 1 | 0 : v4, R4 = I7, v4 = (I7 = x4 >> 25) + v4 | 0, v4 = (R4 = R4 + (x4 = (33554431 & x4) << 7 | IA2 >>> 25) | 0) >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, u4 = I7 = R4 + 33554432 | 0, x4 = v4 = I7 >>> 0 < 33554432 ? v4 + 1 | 0 : v4, E3[A8 + 32 >> 2] = R4 - (-67108864 & I7), v4 = L4 >> 25, R4 = (L4 = (33554431 & L4) << 7 | X2 >>> 25) + (J4 - (I7 = -67108864 & U4) | 0) | 0, I7 = v4 + (Y4 - ((I7 >>> 0 > J4 >>> 0) + d4 | 0) | 0) | 0, I7 = R4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, L4 = R4, I7 = ((67108863 & (v4 = (R4 = R4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | R4 >>> 26) + (l3 = CA2 - (-33554432 & b4) | 0) | 0, E3[A8 + 20 >> 2] = I7, E3[A8 + 16 >> 2] = L4 - (-67108864 & R4), I7 = PA(C4, o4, g6, f4), R4 = t3, v4 = (L4 = PA(y4, M4, O2, H4)) + I7 | 0, I7 = t3 + R4 | 0, I7 = v4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, R4 = (L4 = PA(a4, w4, k4, p4)) + v4 | 0, v4 = t3 + I7 | 0, v4 = R4 >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, I7 = (L4 = PA(z2, B4, h4, F4)) + R4 | 0, R4 = t3 + v4 | 0, R4 = I7 >>> 0 < L4 >>> 0 ? R4 + 1 | 0 : R4, L4 = (v4 = I7) + (I7 = PA(j2, Q4, q4, T2)) | 0, v4 = t3 + R4 | 0, v4 = (I7 = I7 >>> 0 > L4 >>> 0 ? v4 + 1 | 0 : v4) + (v4 = x4 >> 26) | 0, I7 = (R4 = (x4 = (67108863 & x4) << 6 | u4 >>> 26) + L4 | 0) >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, I7 = (v4 = R4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 36 >> 2] = R4 - (-33554432 & v4), x4 = $2 - (-33554432 & BA2) | 0, L4 = m4 - (R4 = -67108864 & gA2) | 0, z2 = W2 - ((R4 >>> 0 > m4 >>> 0) + P4 | 0) | 0, I7 = PA((33554431 & I7) << 7 | v4 >>> 25, I7 >> 25, 19, 0), v4 = t3 + z2 | 0, I7 = I7 >>> 0 > (R4 = I7 + L4 | 0) >>> 0 ? v4 + 1 | 0 : v4, I7 = ((67108863 & (I7 = (v4 = R4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | v4 >>> 26) + x4 | 0, E3[A8 + 4 >> 2] = I7, E3[A8 >> 2] = R4 - (-67108864 & v4); + } + function d3(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, t4 = 0; + r3 = g6 = r3 - 416 | 0, C4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, B4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, Q4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, o4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, t4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, c4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, D4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, a4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, A8 = E3[I7 + 92 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 412 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 400 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 404 >> 2] = A8, A8 = E3[I7 + 76 >> 2], E3[g6 + 376 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 380 >> 2] = A8, e4 = E3[4 + (A8 = w4 = I7 - -64 | 0) >> 2], E3[g6 + 368 >> 2] = E3[A8 >> 2], E3[g6 + 372 >> 2] = e4, A8 = E3[I7 + 92 >> 2], E3[g6 + 360 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 364 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 352 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 356 >> 2] = A8, aA(A8 = g6 + 384 | 0, g6 + 368 | 0, g6 + 352 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 92 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 84 >> 2] = e4, e4 = E3[I7 + 60 >> 2], E3[g6 + 344 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 348 >> 2] = e4, e4 = E3[I7 + 52 >> 2], E3[g6 + 336 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 340 >> 2] = e4, e4 = E3[I7 + 76 >> 2], E3[g6 + 328 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 332 >> 2] = e4, e4 = E3[w4 + 4 >> 2], E3[g6 + 320 >> 2] = E3[w4 >> 2], E3[g6 + 324 >> 2] = e4, aA(A8, g6 + 336 | 0, g6 + 320 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 76 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[w4 >> 2] = E3[g6 + 384 >> 2], E3[w4 + 4 >> 2] = e4, e4 = E3[I7 + 44 >> 2], E3[g6 + 312 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 316 >> 2] = e4, e4 = E3[I7 + 36 >> 2], E3[g6 + 304 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 308 >> 2] = e4, e4 = E3[I7 + 60 >> 2], E3[g6 + 296 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 300 >> 2] = e4, e4 = E3[I7 + 52 >> 2], E3[g6 + 288 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 292 >> 2] = e4, aA(A8, g6 + 304 | 0, g6 + 288 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 60 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 52 >> 2] = e4, e4 = E3[I7 + 28 >> 2], E3[g6 + 280 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 284 >> 2] = e4, e4 = E3[I7 + 20 >> 2], E3[g6 + 272 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 276 >> 2] = e4, e4 = E3[I7 + 44 >> 2], E3[g6 + 264 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 268 >> 2] = e4, e4 = E3[I7 + 36 >> 2], E3[g6 + 256 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 260 >> 2] = e4, aA(A8, g6 + 272 | 0, g6 + 256 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 44 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 36 >> 2] = e4, e4 = E3[I7 + 12 >> 2], E3[g6 + 248 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 252 >> 2] = e4, e4 = E3[I7 + 4 >> 2], E3[g6 + 240 >> 2] = E3[I7 >> 2], E3[g6 + 244 >> 2] = e4, e4 = E3[I7 + 28 >> 2], E3[g6 + 232 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 236 >> 2] = e4, e4 = E3[I7 + 20 >> 2], E3[g6 + 224 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 228 >> 2] = e4, aA(A8, g6 + 240 | 0, g6 + 224 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 28 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 20 >> 2] = e4, e4 = E3[g6 + 412 >> 2], E3[g6 + 216 >> 2] = E3[g6 + 408 >> 2], E3[g6 + 220 >> 2] = e4, e4 = E3[g6 + 404 >> 2], E3[g6 + 208 >> 2] = E3[g6 + 400 >> 2], E3[g6 + 212 >> 2] = e4, e4 = E3[I7 + 12 >> 2], E3[g6 + 200 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 204 >> 2] = e4, e4 = E3[I7 + 4 >> 2], E3[g6 + 192 >> 2] = E3[I7 >> 2], E3[g6 + 196 >> 2] = e4, aA(A8, g6 + 208 | 0, g6 + 192 | 0), e4 = E3[g6 + 384 >> 2], y4 = E3[g6 + 388 >> 2], f4 = E3[g6 + 392 >> 2], E3[I7 + 12 >> 2] = E3[g6 + 396 >> 2] ^ D4, E3[I7 + 8 >> 2] = c4 ^ f4, E3[I7 + 4 >> 2] = t4 ^ y4, E3[I7 >> 2] = e4 ^ a4, t4 = E3[I7 + 92 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 412 >> 2] = t4, t4 = E3[I7 + 84 >> 2], E3[g6 + 400 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 404 >> 2] = t4, t4 = E3[I7 + 76 >> 2], E3[g6 + 184 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 188 >> 2] = t4, t4 = E3[w4 + 4 >> 2], E3[g6 + 176 >> 2] = E3[w4 >> 2], E3[g6 + 180 >> 2] = t4, t4 = E3[I7 + 92 >> 2], E3[g6 + 168 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 172 >> 2] = t4, t4 = E3[I7 + 84 >> 2], E3[g6 + 160 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 164 >> 2] = t4, aA(A8, g6 + 176 | 0, g6 + 160 | 0), t4 = E3[g6 + 396 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 92 >> 2] = t4, t4 = E3[g6 + 388 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 84 >> 2] = t4, t4 = E3[I7 + 60 >> 2], E3[g6 + 152 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 156 >> 2] = t4, t4 = E3[I7 + 52 >> 2], E3[g6 + 144 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 148 >> 2] = t4, t4 = E3[I7 + 76 >> 2], E3[g6 + 136 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 140 >> 2] = t4, t4 = E3[w4 + 4 >> 2], E3[g6 + 128 >> 2] = E3[w4 >> 2], E3[g6 + 132 >> 2] = t4, aA(A8, g6 + 144 | 0, g6 + 128 | 0), t4 = E3[g6 + 396 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 76 >> 2] = t4, t4 = E3[g6 + 388 >> 2], E3[w4 >> 2] = E3[g6 + 384 >> 2], E3[w4 + 4 >> 2] = t4, w4 = E3[I7 + 44 >> 2], E3[g6 + 120 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 124 >> 2] = w4, w4 = E3[I7 + 36 >> 2], E3[g6 + 112 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 116 >> 2] = w4, w4 = E3[I7 + 60 >> 2], E3[g6 + 104 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 108 >> 2] = w4, w4 = E3[I7 + 52 >> 2], E3[g6 + 96 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 100 >> 2] = w4, aA(A8, g6 + 112 | 0, g6 + 96 | 0), w4 = E3[g6 + 396 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 60 >> 2] = w4, w4 = E3[g6 + 388 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 52 >> 2] = w4, w4 = E3[I7 + 28 >> 2], E3[g6 + 88 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 92 >> 2] = w4, w4 = E3[I7 + 20 >> 2], E3[g6 + 80 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 84 >> 2] = w4, w4 = E3[I7 + 44 >> 2], E3[g6 + 72 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 76 >> 2] = w4, w4 = E3[I7 + 36 >> 2], E3[g6 + 64 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 68 >> 2] = w4, aA(A8, g6 + 80 | 0, g6 - -64 | 0), w4 = E3[g6 + 396 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 44 >> 2] = w4, w4 = E3[g6 + 388 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 36 >> 2] = w4, w4 = E3[I7 + 12 >> 2], E3[g6 + 56 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 60 >> 2] = w4, w4 = E3[I7 + 4 >> 2], E3[g6 + 48 >> 2] = E3[I7 >> 2], E3[g6 + 52 >> 2] = w4, w4 = E3[I7 + 28 >> 2], E3[g6 + 40 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 44 >> 2] = w4, w4 = E3[I7 + 20 >> 2], E3[g6 + 32 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 36 >> 2] = w4, aA(A8, g6 + 48 | 0, g6 + 32 | 0), w4 = E3[g6 + 396 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 28 >> 2] = w4, w4 = E3[g6 + 388 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 20 >> 2] = w4, w4 = E3[g6 + 412 >> 2], E3[g6 + 24 >> 2] = E3[g6 + 408 >> 2], E3[g6 + 28 >> 2] = w4, w4 = E3[g6 + 404 >> 2], E3[g6 + 16 >> 2] = E3[g6 + 400 >> 2], E3[g6 + 20 >> 2] = w4, w4 = E3[I7 + 12 >> 2], E3[g6 + 8 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 12 >> 2] = w4, w4 = E3[I7 + 4 >> 2], E3[g6 >> 2] = E3[I7 >> 2], E3[g6 + 4 >> 2] = w4, aA(A8, g6 + 16 | 0, g6), A8 = E3[g6 + 384 >> 2], w4 = E3[g6 + 388 >> 2], t4 = E3[g6 + 392 >> 2], E3[I7 + 12 >> 2] = E3[g6 + 396 >> 2] ^ o4, E3[I7 + 8 >> 2] = t4 ^ Q4, E3[I7 + 4 >> 2] = w4 ^ B4, E3[I7 >> 2] = A8 ^ C4, r3 = g6 + 416 | 0; + } + function b3(A8, I7, g6) { + var C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4 = 0, s4 = 0, F4 = 0; + for (r3 = C4 = r3 - 288 | 0, w4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, t4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, h4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, a4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, y4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, f4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, k4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = g6 + 112 | 0, A8 = 33620224 ^ (e4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24), E3[I7 >> 2] = A8, E3[(c4 = g6 + 96 | 0) >> 2] = 1427652059 ^ e4, E3[(D4 = g6 + 80 | 0) >> 2] = A8, s4 = e4 ^ k4, E3[(A8 = g6 - -64 | 0) >> 2] = s4, E3[g6 + 56 >> 2] = 1110511904, E3[g6 + 60 >> 2] = -584534669, E3[(B4 = g6 + 48 | 0) >> 2] = 1427652059, E3[B4 + 4 >> 2] = -248528275, E3[g6 + 40 >> 2] = 1496785429, E3[g6 + 44 >> 2] = 1652156816, E3[(Q4 = g6 + 32 | 0) >> 2] = 33620224, E3[Q4 + 4 >> 2] = 218629379, E3[g6 + 24 >> 2] = 1110511904, E3[g6 + 28 >> 2] = -584534669, E3[(o4 = g6 + 16 | 0) >> 2] = 1427652059, E3[o4 + 4 >> 2] = -248528275, E3[g6 >> 2] = s4, s4 = 1652156816 ^ f4, E3[g6 + 124 >> 2] = s4, F4 = 1496785429 ^ y4, E3[g6 + 120 >> 2] = F4, n4 = 218629379 ^ a4, E3[g6 + 116 >> 2] = n4, E3[g6 + 108 >> 2] = -584534669 ^ f4, E3[g6 + 104 >> 2] = 1110511904 ^ y4, E3[g6 + 100 >> 2] = -248528275 ^ a4, E3[g6 + 92 >> 2] = s4, E3[g6 + 88 >> 2] = F4, E3[g6 + 84 >> 2] = n4, s4 = f4 ^ h4, E3[g6 + 76 >> 2] = s4, F4 = y4 ^ t4, E3[g6 + 72 >> 2] = F4, n4 = a4 ^ w4, E3[g6 + 68 >> 2] = n4, E3[g6 + 12 >> 2] = s4, E3[g6 + 8 >> 2] = F4, E3[g6 + 4 >> 2] = n4, F4 = 0; s4 = E3[I7 + 12 >> 2], E3[C4 + 280 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 284 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[C4 + 272 >> 2] = E3[I7 >> 2], E3[C4 + 276 >> 2] = s4, s4 = E3[c4 + 12 >> 2], E3[C4 + 248 >> 2] = E3[c4 + 8 >> 2], E3[C4 + 252 >> 2] = s4, s4 = E3[c4 + 4 >> 2], E3[C4 + 240 >> 2] = E3[c4 >> 2], E3[C4 + 244 >> 2] = s4, s4 = E3[I7 + 12 >> 2], E3[C4 + 232 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 236 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[C4 + 224 >> 2] = E3[I7 >> 2], E3[C4 + 228 >> 2] = s4, aA(s4 = C4 + 256 | 0, C4 + 240 | 0, C4 + 224 | 0), n4 = E3[C4 + 268 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 264 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[I7 >> 2] = E3[C4 + 256 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[D4 + 12 >> 2], E3[C4 + 216 >> 2] = E3[D4 + 8 >> 2], E3[C4 + 220 >> 2] = n4, n4 = E3[D4 + 4 >> 2], E3[C4 + 208 >> 2] = E3[D4 >> 2], E3[C4 + 212 >> 2] = n4, n4 = E3[c4 + 12 >> 2], E3[C4 + 200 >> 2] = E3[c4 + 8 >> 2], E3[C4 + 204 >> 2] = n4, n4 = E3[c4 + 4 >> 2], E3[C4 + 192 >> 2] = E3[c4 >> 2], E3[C4 + 196 >> 2] = n4, aA(s4, C4 + 208 | 0, C4 + 192 | 0), n4 = E3[C4 + 268 >> 2], E3[c4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[c4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[c4 >> 2] = E3[C4 + 256 >> 2], E3[c4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 184 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 188 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 176 >> 2] = E3[A8 >> 2], E3[C4 + 180 >> 2] = n4, n4 = E3[D4 + 12 >> 2], E3[C4 + 168 >> 2] = E3[D4 + 8 >> 2], E3[C4 + 172 >> 2] = n4, n4 = E3[D4 + 4 >> 2], E3[C4 + 160 >> 2] = E3[D4 >> 2], E3[C4 + 164 >> 2] = n4, aA(s4, C4 + 176 | 0, C4 + 160 | 0), n4 = E3[C4 + 268 >> 2], E3[D4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[D4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[D4 >> 2] = E3[C4 + 256 >> 2], E3[D4 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 152 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 156 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 144 >> 2] = E3[B4 >> 2], E3[C4 + 148 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 136 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 140 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 128 >> 2] = E3[A8 >> 2], E3[C4 + 132 >> 2] = n4, aA(s4, C4 + 144 | 0, C4 + 128 | 0), n4 = E3[C4 + 268 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 264 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[A8 >> 2] = E3[C4 + 256 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[Q4 + 12 >> 2], E3[C4 + 120 >> 2] = E3[Q4 + 8 >> 2], E3[C4 + 124 >> 2] = n4, n4 = E3[Q4 + 4 >> 2], E3[C4 + 112 >> 2] = E3[Q4 >> 2], E3[C4 + 116 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 104 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 108 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 96 >> 2] = E3[B4 >> 2], E3[C4 + 100 >> 2] = n4, aA(s4, C4 + 112 | 0, C4 + 96 | 0), n4 = E3[C4 + 268 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[B4 >> 2] = E3[C4 + 256 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[o4 + 12 >> 2], E3[C4 + 88 >> 2] = E3[o4 + 8 >> 2], E3[C4 + 92 >> 2] = n4, n4 = E3[o4 + 4 >> 2], E3[C4 + 80 >> 2] = E3[o4 >> 2], E3[C4 + 84 >> 2] = n4, n4 = E3[Q4 + 12 >> 2], E3[C4 + 72 >> 2] = E3[Q4 + 8 >> 2], E3[C4 + 76 >> 2] = n4, n4 = E3[Q4 + 4 >> 2], E3[C4 + 64 >> 2] = E3[Q4 >> 2], E3[C4 + 68 >> 2] = n4, aA(s4, C4 + 80 | 0, C4 - -64 | 0), n4 = E3[C4 + 268 >> 2], E3[Q4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[Q4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[Q4 >> 2] = E3[C4 + 256 >> 2], E3[Q4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 60 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 48 >> 2] = E3[g6 >> 2], E3[C4 + 52 >> 2] = n4, n4 = E3[o4 + 12 >> 2], E3[C4 + 40 >> 2] = E3[o4 + 8 >> 2], E3[C4 + 44 >> 2] = n4, n4 = E3[o4 + 4 >> 2], E3[C4 + 32 >> 2] = E3[o4 >> 2], E3[C4 + 36 >> 2] = n4, aA(s4, C4 + 48 | 0, C4 + 32 | 0), n4 = E3[C4 + 268 >> 2], E3[o4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[o4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[o4 >> 2] = E3[C4 + 256 >> 2], E3[o4 + 4 >> 2] = n4, n4 = E3[C4 + 284 >> 2], E3[C4 + 24 >> 2] = E3[C4 + 280 >> 2], E3[C4 + 28 >> 2] = n4, n4 = E3[C4 + 276 >> 2], E3[C4 + 16 >> 2] = E3[C4 + 272 >> 2], E3[C4 + 20 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 12 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 >> 2] = E3[g6 >> 2], E3[C4 + 4 >> 2] = n4, aA(s4, C4 + 16 | 0, C4), s4 = E3[C4 + 268 >> 2], E3[g6 + 8 >> 2] = E3[C4 + 264 >> 2], E3[g6 + 12 >> 2] = s4, s4 = E3[C4 + 260 >> 2], E3[g6 >> 2] = E3[C4 + 256 >> 2], E3[g6 + 4 >> 2] = s4, E3[g6 + 12 >> 2] = (i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24) ^ h4, E3[g6 + 8 >> 2] = (i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24) ^ t4, E3[g6 + 4 >> 2] = (i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24) ^ w4, E3[g6 >> 2] = (i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24) ^ k4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ e4, E3[g6 + 68 >> 2] = (i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24) ^ a4, E3[g6 + 72 >> 2] = (i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24) ^ y4, E3[g6 + 76 >> 2] = (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24) ^ f4, 10 != (0 | (F4 = F4 + 1 | 0)); ) ; + r3 = C4 + 288 | 0; + } + function P3(A8, I7, g6, B4, Q4) { + var o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0; + for (o4 = r3 + -64 | 0, c4 = E3[A8 + 60 >> 2], D4 = E3[A8 + 56 >> 2], q4 = E3[A8 + 52 >> 2], m4 = E3[A8 + 48 >> 2], a4 = E3[A8 + 44 >> 2], y4 = E3[A8 + 40 >> 2], f4 = E3[A8 + 36 >> 2], e4 = E3[A8 + 32 >> 2], w4 = E3[A8 + 28 >> 2], t4 = E3[A8 + 24 >> 2], h4 = E3[A8 + 20 >> 2], k4 = E3[A8 + 16 >> 2], n4 = E3[A8 + 12 >> 2], s4 = E3[A8 + 8 >> 2], F4 = E3[A8 + 4 >> 2], S4 = E3[A8 >> 2]; ; ) { + if (!Q4 & B4 >>> 0 > 63 | Q4) M4 = g6; + else { + if (E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, E3[o4 + 24 >> 2] = 0, E3[o4 + 28 >> 2] = 0, E3[o4 + 16 >> 2] = 0, E3[o4 + 20 >> 2] = 0, E3[o4 + 8 >> 2] = 0, E3[o4 + 12 >> 2] = 0, E3[o4 >> 2] = 0, E3[o4 + 4 >> 2] = 0, K4 = 0, B4 | Q4) for (; C3[K4 + o4 | 0] = i3[I7 + K4 | 0], !Q4 & (K4 = K4 + 1 | 0) >>> 0 < B4 >>> 0 | Q4; ) ; + I7 = M4 = o4, O2 = g6; + } + for (l3 = 20, N4 = S4, U4 = F4, d4 = s4, v4 = n4, K4 = k4, g6 = h4, p4 = t4, H4 = w4, G4 = e4, L4 = f4, b4 = y4, _4 = c4, x4 = D4, R4 = q4, P4 = m4, J4 = a4; Y4 = K4, N4 = gI((K4 = N4 + K4 | 0) ^ P4, 16), Y4 = P4 = gI(Y4 ^ (G4 = N4 + G4 | 0), 12), P4 = gI((u4 = K4 + P4 | 0) ^ N4, 8), K4 = gI(Y4 ^ (G4 = P4 + G4 | 0), 7), _4 = gI((N4 = H4 + v4 | 0) ^ _4, 16), H4 = gI((J4 = _4 + J4 | 0) ^ H4, 12), v4 = gI((d4 = p4 + d4 | 0) ^ x4, 16), p4 = gI((b4 = v4 + b4 | 0) ^ p4, 12), x4 = (z2 = N4 + H4 | 0) + K4 | 0, j2 = gI((d4 = p4 + d4 | 0) ^ v4, 8), N4 = gI(x4 ^ j2, 16), v4 = gI((U4 = g6 + U4 | 0) ^ R4, 16), g6 = gI((L4 = v4 + L4 | 0) ^ g6, 12), Y4 = K4, R4 = gI((U4 = g6 + U4 | 0) ^ v4, 8), Y4 = gI(Y4 ^ (K4 = (X2 = R4 + L4 | 0) + N4 | 0), 12), x4 = gI(N4 ^ (v4 = Y4 + x4 | 0), 8), K4 = gI((L4 = x4 + K4 | 0) ^ Y4, 7), Y4 = G4, G4 = d4, N4 = gI(_4 ^ z2, 8), d4 = gI((_4 = N4 + J4 | 0) ^ H4, 7), R4 = gI((G4 = G4 + d4 | 0) ^ R4, 16), J4 = gI((H4 = Y4 + R4 | 0) ^ d4, 12), R4 = gI(R4 ^ (d4 = J4 + G4 | 0), 8), H4 = gI((G4 = H4 + R4 | 0) ^ J4, 7), J4 = _4, _4 = U4, U4 = gI((b4 = b4 + j2 | 0) ^ p4, 7), p4 = J4 + (P4 = gI((_4 = _4 + U4 | 0) ^ P4, 16)) | 0, J4 = _4, _4 = gI(p4 ^ U4, 12), P4 = gI(P4 ^ (U4 = J4 + _4 | 0), 8), p4 = gI((J4 = p4 + P4 | 0) ^ _4, 7), Y4 = b4, _4 = N4, N4 = gI(g6 ^ X2, 7), _4 = gI(_4 ^ (b4 = N4 + u4 | 0), 16), u4 = gI((g6 = Y4 + _4 | 0) ^ N4, 12), _4 = gI(_4 ^ (N4 = u4 + b4 | 0), 8), g6 = gI((b4 = g6 + _4 | 0) ^ u4, 7), l3 = l3 - 2 | 0; ) ; + if (l3 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, u4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, z2 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, j2 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, X2 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, Y4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, T2 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, V2 = i3[I7 + 32 | 0] | i3[I7 + 33 | 0] << 8 | i3[I7 + 34 | 0] << 16 | i3[I7 + 35 | 0] << 24, Z2 = i3[I7 + 36 | 0] | i3[I7 + 37 | 0] << 8 | i3[I7 + 38 | 0] << 16 | i3[I7 + 39 | 0] << 24, W2 = i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24, $2 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, AA2 = i3[I7 + 48 | 0] | i3[I7 + 49 | 0] << 8 | i3[I7 + 50 | 0] << 16 | i3[I7 + 51 | 0] << 24, IA2 = i3[I7 + 52 | 0] | i3[I7 + 53 | 0] << 8 | i3[I7 + 54 | 0] << 16 | i3[I7 + 55 | 0] << 24, gA2 = i3[I7 + 56 | 0] | i3[I7 + 57 | 0] << 8 | i3[I7 + 58 | 0] << 16 | i3[I7 + 59 | 0] << 24, CA2 = i3[I7 + 60 | 0] | i3[I7 + 61 | 0] << 8 | i3[I7 + 62 | 0] << 16 | i3[I7 + 63 | 0] << 24, N4 = N4 + S4 ^ (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24), C3[0 | M4] = N4, C3[M4 + 1 | 0] = N4 >>> 8, C3[M4 + 2 | 0] = N4 >>> 16, C3[M4 + 3 | 0] = N4 >>> 24, N4 = _4 + c4 ^ CA2, C3[M4 + 60 | 0] = N4, C3[M4 + 61 | 0] = N4 >>> 8, C3[M4 + 62 | 0] = N4 >>> 16, C3[M4 + 63 | 0] = N4 >>> 24, N4 = x4 + D4 ^ gA2, C3[M4 + 56 | 0] = N4, C3[M4 + 57 | 0] = N4 >>> 8, C3[M4 + 58 | 0] = N4 >>> 16, C3[M4 + 59 | 0] = N4 >>> 24, N4 = R4 + q4 ^ IA2, C3[M4 + 52 | 0] = N4, C3[M4 + 53 | 0] = N4 >>> 8, C3[M4 + 54 | 0] = N4 >>> 16, C3[M4 + 55 | 0] = N4 >>> 24, N4 = P4 + m4 ^ AA2, C3[M4 + 48 | 0] = N4, C3[M4 + 49 | 0] = N4 >>> 8, C3[M4 + 50 | 0] = N4 >>> 16, C3[M4 + 51 | 0] = N4 >>> 24, N4 = J4 + a4 ^ $2, C3[M4 + 44 | 0] = N4, C3[M4 + 45 | 0] = N4 >>> 8, C3[M4 + 46 | 0] = N4 >>> 16, C3[M4 + 47 | 0] = N4 >>> 24, N4 = b4 + y4 ^ W2, C3[M4 + 40 | 0] = N4, C3[M4 + 41 | 0] = N4 >>> 8, C3[M4 + 42 | 0] = N4 >>> 16, C3[M4 + 43 | 0] = N4 >>> 24, N4 = L4 + f4 ^ Z2, C3[M4 + 36 | 0] = N4, C3[M4 + 37 | 0] = N4 >>> 8, C3[M4 + 38 | 0] = N4 >>> 16, C3[M4 + 39 | 0] = N4 >>> 24, N4 = G4 + e4 ^ V2, C3[M4 + 32 | 0] = N4, C3[M4 + 33 | 0] = N4 >>> 8, C3[M4 + 34 | 0] = N4 >>> 16, C3[M4 + 35 | 0] = N4 >>> 24, H4 = H4 + w4 ^ T2, C3[M4 + 28 | 0] = H4, C3[M4 + 29 | 0] = H4 >>> 8, C3[M4 + 30 | 0] = H4 >>> 16, C3[M4 + 31 | 0] = H4 >>> 24, p4 = Y4 ^ p4 + t4, C3[M4 + 24 | 0] = p4, C3[M4 + 25 | 0] = p4 >>> 8, C3[M4 + 26 | 0] = p4 >>> 16, C3[M4 + 27 | 0] = p4 >>> 24, g6 = X2 ^ g6 + h4, C3[M4 + 20 | 0] = g6, C3[M4 + 21 | 0] = g6 >>> 8, C3[M4 + 22 | 0] = g6 >>> 16, C3[M4 + 23 | 0] = g6 >>> 24, g6 = j2 ^ K4 + k4, C3[M4 + 16 | 0] = g6, C3[M4 + 17 | 0] = g6 >>> 8, C3[M4 + 18 | 0] = g6 >>> 16, C3[M4 + 19 | 0] = g6 >>> 24, g6 = z2 ^ v4 + n4, C3[M4 + 12 | 0] = g6, C3[M4 + 13 | 0] = g6 >>> 8, C3[M4 + 14 | 0] = g6 >>> 16, C3[M4 + 15 | 0] = g6 >>> 24, g6 = u4 ^ d4 + s4, C3[M4 + 8 | 0] = g6, C3[M4 + 9 | 0] = g6 >>> 8, C3[M4 + 10 | 0] = g6 >>> 16, C3[M4 + 11 | 0] = g6 >>> 24, g6 = l3 ^ U4 + F4, C3[M4 + 4 | 0] = g6, C3[M4 + 5 | 0] = g6 >>> 8, C3[M4 + 6 | 0] = g6 >>> 16, C3[M4 + 7 | 0] = g6 >>> 24, q4 = !(m4 = m4 + 1 | 0) + q4 | 0, !Q4 & B4 >>> 0 <= 64) { + if (!(!(B4 | Q4) | !Q4 & B4 >>> 0 > 63 | !!(0 | Q4))) for (K4 = 0; C3[K4 + O2 | 0] = i3[M4 + K4 | 0], B4 >>> 0 > (K4 = K4 + 1 | 0) >>> 0; ) ; + E3[A8 + 52 >> 2] = q4, E3[A8 + 48 >> 2] = m4; + break; + } + I7 = I7 - -64 | 0, g6 = M4 - -64 | 0, Q4 = Q4 - 1 | 0, Q4 = (B4 = B4 + -64 | 0) >>> 0 < 4294967232 ? Q4 + 1 | 0 : Q4; + } + } + function v3(A8, I7) { + var g6, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0; + r3 = g6 = r3 - 704 | 0, B4 = 80 + ((Q4 = E3[A8 + 72 >> 2] >>> 3 & 127) + A8 | 0) | 0, Q4 >>> 0 >= 112 ? (TA(B4, 34608, 128 - Q4 | 0), n3(A8, Q4 = A8 + 80 | 0, g6, g6 + 640 | 0), VA(Q4, 0, 112)) : TA(B4, 34608, 112 - Q4 | 0), D4 = (i4 = E3[A8 + 64 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 68 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[A8 + 192 | 0] = B4, C3[A8 + 193 | 0] = B4 >>> 8, C3[A8 + 194 | 0] = B4 >>> 16, C3[A8 + 195 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[A8 + 196 | 0] = Q4, C3[A8 + 197 | 0] = Q4 >>> 8, C3[A8 + 198 | 0] = Q4 >>> 16, C3[A8 + 199 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 72 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 76 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[A8 + 200 | 0] = B4, C3[A8 + 201 | 0] = B4 >>> 8, C3[A8 + 202 | 0] = B4 >>> 16, C3[A8 + 203 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[A8 + 204 | 0] = Q4, C3[A8 + 205 | 0] = Q4 >>> 8, C3[A8 + 206 | 0] = Q4 >>> 16, C3[A8 + 207 | 0] = Q4 >>> 24, n3(A8, A8 + 80 | 0, g6, g6 + 640 | 0), D4 = (i4 = E3[A8 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 4 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[0 | I7] = B4, C3[I7 + 1 | 0] = B4 >>> 8, C3[I7 + 2 | 0] = B4 >>> 16, C3[I7 + 3 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 4 | 0] = Q4, C3[I7 + 5 | 0] = Q4 >>> 8, C3[I7 + 6 | 0] = Q4 >>> 16, C3[I7 + 7 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 8 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 12 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 8 | 0] = B4, C3[I7 + 9 | 0] = B4 >>> 8, C3[I7 + 10 | 0] = B4 >>> 16, C3[I7 + 11 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 12 | 0] = Q4, C3[I7 + 13 | 0] = Q4 >>> 8, C3[I7 + 14 | 0] = Q4 >>> 16, C3[I7 + 15 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 16 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 20 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 16 | 0] = B4, C3[I7 + 17 | 0] = B4 >>> 8, C3[I7 + 18 | 0] = B4 >>> 16, C3[I7 + 19 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 20 | 0] = Q4, C3[I7 + 21 | 0] = Q4 >>> 8, C3[I7 + 22 | 0] = Q4 >>> 16, C3[I7 + 23 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 24 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 28 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 24 | 0] = B4, C3[I7 + 25 | 0] = B4 >>> 8, C3[I7 + 26 | 0] = B4 >>> 16, C3[I7 + 27 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 28 | 0] = Q4, C3[I7 + 29 | 0] = Q4 >>> 8, C3[I7 + 30 | 0] = Q4 >>> 16, C3[I7 + 31 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 32 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 36 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 32 | 0] = B4, C3[I7 + 33 | 0] = B4 >>> 8, C3[I7 + 34 | 0] = B4 >>> 16, C3[I7 + 35 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 36 | 0] = Q4, C3[I7 + 37 | 0] = Q4 >>> 8, C3[I7 + 38 | 0] = Q4 >>> 16, C3[I7 + 39 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 40 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 44 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 40 | 0] = B4, C3[I7 + 41 | 0] = B4 >>> 8, C3[I7 + 42 | 0] = B4 >>> 16, C3[I7 + 43 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 44 | 0] = Q4, C3[I7 + 45 | 0] = Q4 >>> 8, C3[I7 + 46 | 0] = Q4 >>> 16, C3[I7 + 47 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 48 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 52 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 48 | 0] = B4, C3[I7 + 49 | 0] = B4 >>> 8, C3[I7 + 50 | 0] = B4 >>> 16, C3[I7 + 51 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 52 | 0] = Q4, C3[I7 + 53 | 0] = Q4 >>> 8, C3[I7 + 54 | 0] = Q4 >>> 16, C3[I7 + 55 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 56 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, B4 = I7, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, I7 = a4 | c4 << 8 | -16777216 & ((255 & (I7 = E3[A8 + 60 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & I7) << 8 | i4 >>> 24) | I7 >>> 8 & 65280 | I7 >>> 24, C3[B4 + 56 | 0] = I7, C3[B4 + 57 | 0] = I7 >>> 8, C3[B4 + 58 | 0] = I7 >>> 16, C3[B4 + 59 | 0] = I7 >>> 24, I7 = Q4 | o4 | D4, I7 |= Q4 = 0, C3[B4 + 60 | 0] = I7, C3[B4 + 61 | 0] = I7 >>> 8, C3[B4 + 62 | 0] = I7 >>> 16, C3[B4 + 63 | 0] = I7 >>> 24, MI(g6, 704), MI(A8, 208), r3 = g6 + 704 | 0; + } + function R3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4 = 0; + r3 = B4 = r3 - 224 | 0, a4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, y4 = i3[0 | (_4 = g6 - -64 | 0)] | i3[_4 + 1 | 0] << 8 | i3[_4 + 2 | 0] << 16 | i3[_4 + 3 | 0] << 24, f4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, e4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, w4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, Q4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, t4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, h4 = i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24, k4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, n4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, s4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, o4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, F4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, S4 = i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24, M4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, N4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, K4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, c4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = (D4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ (i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) & (i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24) ^ (i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24) ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24), C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = N4 & K4 ^ S4 ^ M4 ^ F4 ^ o4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = n4 & s4 ^ h4 ^ k4 ^ t4 ^ Q4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = e4 & w4 ^ a4 ^ y4 ^ f4 ^ c4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, A8 = E3[_4 + 4 >> 2], E3[B4 + 176 >> 2] = E3[_4 >> 2], E3[B4 + 180 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = A8, aA(A8 = B4 + 192 | 0, B4 + 176 | 0, B4 + 160 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 92 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 84 >> 2] = I7, I7 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = I7, I7 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = I7, I7 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = I7, I7 = E3[_4 + 4 >> 2], E3[B4 + 128 >> 2] = E3[_4 >> 2], E3[B4 + 132 >> 2] = I7, aA(A8, B4 + 144 | 0, B4 + 128 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 76 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[_4 >> 2] = E3[B4 + 192 >> 2], E3[_4 + 4 >> 2] = I7, I7 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = I7, I7 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = I7, I7 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = I7, I7 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = I7, aA(A8, B4 + 112 | 0, B4 + 96 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 60 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 52 >> 2] = I7, I7 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = I7, I7 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = I7, I7 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = I7, I7 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = I7, aA(A8, B4 + 80 | 0, B4 - -64 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 44 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 36 >> 2] = I7, I7 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = I7, I7 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = I7, I7 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = I7, I7 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = I7, aA(A8, B4 + 48 | 0, B4 + 32 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 28 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 20 >> 2] = I7, I7 = E3[B4 + 220 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 216 >> 2], E3[B4 + 28 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 208 >> 2], E3[B4 + 20 >> 2] = I7, I7 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = I7, I7 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = I7, aA(A8, B4 + 16 | 0, B4), A8 = E3[B4 + 192 >> 2], I7 = E3[B4 + 196 >> 2], _4 = E3[B4 + 200 >> 2], E3[g6 + 12 >> 2] = D4 ^ E3[B4 + 204 >> 2], E3[g6 + 8 >> 2] = _4 ^ o4, E3[g6 + 4 >> 2] = I7 ^ Q4, E3[g6 >> 2] = A8 ^ c4, r3 = B4 + 224 | 0; + } + function L3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0; + r3 = B4 = r3 - 224 | 0, M4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, S4 = i3[0 | (F4 = g6 - -64 | 0)] | i3[F4 + 1 | 0] << 8 | i3[F4 + 2 | 0] << 16 | i3[F4 + 3 | 0] << 24, Q4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, o4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, c4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, N4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, D4 = i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24, a4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, y4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, f4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, e4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, K4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, w4 = i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24, t4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, h4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, k4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, n4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, s4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = (i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) & (i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24) ^ (i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24) ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24) ^ (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24), C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, K4 = k4 & n4 ^ K4 ^ t4 ^ h4 ^ w4, C3[A8 + 8 | 0] = K4, C3[A8 + 9 | 0] = K4 >>> 8, C3[A8 + 10 | 0] = K4 >>> 16, C3[A8 + 11 | 0] = K4 >>> 24, N4 = f4 & e4 ^ N4 ^ a4 ^ y4 ^ D4, C3[A8 + 4 | 0] = N4, C3[A8 + 5 | 0] = N4 >>> 8, C3[A8 + 6 | 0] = N4 >>> 16, C3[A8 + 7 | 0] = N4 >>> 24, M4 = o4 & c4 ^ M4 ^ S4 ^ Q4 ^ s4, C3[0 | A8] = M4, C3[A8 + 1 | 0] = M4 >>> 8, C3[A8 + 2 | 0] = M4 >>> 16, C3[A8 + 3 | 0] = M4 >>> 24, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, A8 = E3[F4 + 4 >> 2], E3[B4 + 176 >> 2] = E3[F4 >> 2], E3[B4 + 180 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = A8, aA(A8 = B4 + 192 | 0, B4 + 176 | 0, B4 + 160 | 0), S4 = E3[B4 + 204 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 92 >> 2] = S4, S4 = E3[B4 + 196 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 84 >> 2] = S4, S4 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = S4, S4 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = S4, S4 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = S4, S4 = E3[F4 + 4 >> 2], E3[B4 + 128 >> 2] = E3[F4 >> 2], E3[B4 + 132 >> 2] = S4, aA(A8, B4 + 144 | 0, B4 + 128 | 0), S4 = E3[B4 + 204 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 76 >> 2] = S4, S4 = E3[B4 + 196 >> 2], E3[F4 >> 2] = E3[B4 + 192 >> 2], E3[F4 + 4 >> 2] = S4, F4 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = F4, F4 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = F4, F4 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = F4, F4 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = F4, aA(A8, B4 + 112 | 0, B4 + 96 | 0), F4 = E3[B4 + 204 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 60 >> 2] = F4, F4 = E3[B4 + 196 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 52 >> 2] = F4, F4 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = F4, F4 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = F4, F4 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = F4, F4 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = F4, aA(A8, B4 + 80 | 0, B4 - -64 | 0), F4 = E3[B4 + 204 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 44 >> 2] = F4, F4 = E3[B4 + 196 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 36 >> 2] = F4, F4 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = F4, F4 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = F4, F4 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = F4, F4 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = F4, aA(A8, B4 + 48 | 0, B4 + 32 | 0), F4 = E3[B4 + 204 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 28 >> 2] = F4, F4 = E3[B4 + 196 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 20 >> 2] = F4, F4 = E3[B4 + 220 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 216 >> 2], E3[B4 + 28 >> 2] = F4, F4 = E3[B4 + 212 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 208 >> 2], E3[B4 + 20 >> 2] = F4, F4 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = F4, F4 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = F4, aA(A8, B4 + 16 | 0, B4), A8 = E3[B4 + 192 >> 2], F4 = E3[B4 + 196 >> 2], S4 = E3[B4 + 200 >> 2], E3[g6 + 12 >> 2] = I7 ^ E3[B4 + 204 >> 2], E3[g6 + 8 >> 2] = S4 ^ K4, E3[g6 + 4 >> 2] = F4 ^ N4, E3[g6 >> 2] = A8 ^ M4, r3 = B4 + 224 | 0; + } + function x3(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4 = 0, e4 = 0; + r3 = g6 = r3 - 288 | 0, C4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, B4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, Q4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, o4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, c4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, D4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, a4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, y4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, A8 = E3[I7 + 124 >> 2], E3[g6 + 280 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 284 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 272 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 276 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 248 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 252 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 240 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 244 >> 2] = A8, A8 = E3[I7 + 124 >> 2], E3[g6 + 232 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 236 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 224 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 228 >> 2] = A8, aA(e4 = g6 + 256 | 0, g6 + 240 | 0, g6 + 224 | 0), A8 = E3[g6 + 268 >> 2], E3[I7 + 120 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 124 >> 2] = A8, A8 = E3[g6 + 260 >> 2], E3[I7 + 112 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 116 >> 2] = A8, A8 = E3[I7 + 92 >> 2], E3[g6 + 216 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 220 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 208 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 212 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 200 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 204 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 192 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 196 >> 2] = A8, aA(e4, g6 + 208 | 0, g6 + 192 | 0), A8 = E3[g6 + 268 >> 2], E3[I7 + 104 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 108 >> 2] = A8, A8 = E3[g6 + 260 >> 2], E3[I7 + 96 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 100 >> 2] = A8, A8 = E3[I7 + 76 >> 2], E3[g6 + 184 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 188 >> 2] = A8, f4 = E3[4 + (A8 = I7 - -64 | 0) >> 2], E3[g6 + 176 >> 2] = E3[A8 >> 2], E3[g6 + 180 >> 2] = f4, f4 = E3[I7 + 92 >> 2], E3[g6 + 168 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 172 >> 2] = f4, f4 = E3[I7 + 84 >> 2], E3[g6 + 160 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 164 >> 2] = f4, aA(e4, g6 + 176 | 0, g6 + 160 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 92 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 84 >> 2] = f4, f4 = E3[I7 + 60 >> 2], E3[g6 + 152 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 156 >> 2] = f4, f4 = E3[I7 + 52 >> 2], E3[g6 + 144 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 148 >> 2] = f4, f4 = E3[I7 + 76 >> 2], E3[g6 + 136 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 140 >> 2] = f4, f4 = E3[A8 + 4 >> 2], E3[g6 + 128 >> 2] = E3[A8 >> 2], E3[g6 + 132 >> 2] = f4, aA(e4, g6 + 144 | 0, g6 + 128 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 76 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[A8 >> 2] = E3[g6 + 256 >> 2], E3[A8 + 4 >> 2] = f4, f4 = E3[I7 + 44 >> 2], E3[g6 + 120 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 124 >> 2] = f4, f4 = E3[I7 + 36 >> 2], E3[g6 + 112 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 116 >> 2] = f4, f4 = E3[I7 + 60 >> 2], E3[g6 + 104 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 108 >> 2] = f4, f4 = E3[I7 + 52 >> 2], E3[g6 + 96 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 100 >> 2] = f4, aA(e4, g6 + 112 | 0, g6 + 96 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 60 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 52 >> 2] = f4, f4 = E3[I7 + 28 >> 2], E3[g6 + 88 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 92 >> 2] = f4, f4 = E3[I7 + 20 >> 2], E3[g6 + 80 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 84 >> 2] = f4, f4 = E3[I7 + 44 >> 2], E3[g6 + 72 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 76 >> 2] = f4, f4 = E3[I7 + 36 >> 2], E3[g6 + 64 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 68 >> 2] = f4, aA(e4, g6 + 80 | 0, g6 - -64 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 44 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 36 >> 2] = f4, f4 = E3[I7 + 12 >> 2], E3[g6 + 56 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 60 >> 2] = f4, f4 = E3[I7 + 4 >> 2], E3[g6 + 48 >> 2] = E3[I7 >> 2], E3[g6 + 52 >> 2] = f4, f4 = E3[I7 + 28 >> 2], E3[g6 + 40 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 44 >> 2] = f4, f4 = E3[I7 + 20 >> 2], E3[g6 + 32 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 36 >> 2] = f4, aA(e4, g6 + 48 | 0, g6 + 32 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 28 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 20 >> 2] = f4, f4 = E3[g6 + 284 >> 2], E3[g6 + 24 >> 2] = E3[g6 + 280 >> 2], E3[g6 + 28 >> 2] = f4, f4 = E3[g6 + 276 >> 2], E3[g6 + 16 >> 2] = E3[g6 + 272 >> 2], E3[g6 + 20 >> 2] = f4, f4 = E3[I7 + 12 >> 2], E3[g6 + 8 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 12 >> 2] = f4, f4 = E3[I7 + 4 >> 2], E3[g6 >> 2] = E3[I7 >> 2], E3[g6 + 4 >> 2] = f4, aA(e4, g6 + 16 | 0, g6), e4 = E3[g6 + 268 >> 2], E3[I7 + 8 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 12 >> 2] = e4, e4 = E3[g6 + 260 >> 2], E3[I7 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 4 >> 2] = e4, E3[I7 + 12 >> 2] = (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ a4, E3[I7 + 8 >> 2] = (i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24) ^ D4, E3[I7 + 4 >> 2] = (i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) ^ c4, E3[I7 >> 2] = (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) ^ y4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ o4, E3[I7 + 68 >> 2] = (i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24) ^ Q4, E3[I7 + 72 >> 2] = (i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) ^ B4, E3[I7 + 76 >> 2] = (i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) ^ C4, r3 = g6 + 288 | 0; + } + function u3(A8, I7, g6, C4) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4 = 0, M4 = 0, N4 = 0, K4 = 0; + r3 = B4 = r3 - 240 | 0, E3[B4 + 200 >> 2] = 0, E3[B4 + 204 >> 2] = 0, E3[B4 + 192 >> 2] = 0, E3[B4 + 196 >> 2] = 0, TA(M4 = B4 + 192 | 0, I7, g6), N4 = i3[C4 + 16 | 0] | i3[C4 + 17 | 0] << 8 | i3[C4 + 18 | 0] << 16 | i3[C4 + 19 | 0] << 24, K4 = i3[0 | (I7 = C4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, S4 = i3[C4 + 80 | 0] | i3[C4 + 81 | 0] << 8 | i3[C4 + 82 | 0] << 16 | i3[C4 + 83 | 0] << 24, Q4 = i3[C4 + 32 | 0] | i3[C4 + 33 | 0] << 8 | i3[C4 + 34 | 0] << 16 | i3[C4 + 35 | 0] << 24, o4 = i3[C4 + 48 | 0] | i3[C4 + 49 | 0] << 8 | i3[C4 + 50 | 0] << 16 | i3[C4 + 51 | 0] << 24, c4 = i3[C4 + 20 | 0] | i3[C4 + 21 | 0] << 8 | i3[C4 + 22 | 0] << 16 | i3[C4 + 23 | 0] << 24, D4 = i3[C4 + 68 | 0] | i3[C4 + 69 | 0] << 8 | i3[C4 + 70 | 0] << 16 | i3[C4 + 71 | 0] << 24, a4 = i3[C4 + 84 | 0] | i3[C4 + 85 | 0] << 8 | i3[C4 + 86 | 0] << 16 | i3[C4 + 87 | 0] << 24, y4 = i3[C4 + 36 | 0] | i3[C4 + 37 | 0] << 8 | i3[C4 + 38 | 0] << 16 | i3[C4 + 39 | 0] << 24, f4 = i3[C4 + 52 | 0] | i3[C4 + 53 | 0] << 8 | i3[C4 + 54 | 0] << 16 | i3[C4 + 55 | 0] << 24, e4 = i3[C4 + 24 | 0] | i3[C4 + 25 | 0] << 8 | i3[C4 + 26 | 0] << 16 | i3[C4 + 27 | 0] << 24, w4 = i3[C4 + 72 | 0] | i3[C4 + 73 | 0] << 8 | i3[C4 + 74 | 0] << 16 | i3[C4 + 75 | 0] << 24, t4 = i3[C4 + 88 | 0] | i3[C4 + 89 | 0] << 8 | i3[C4 + 90 | 0] << 16 | i3[C4 + 91 | 0] << 24, h4 = i3[C4 + 40 | 0] | i3[C4 + 41 | 0] << 8 | i3[C4 + 42 | 0] << 16 | i3[C4 + 43 | 0] << 24, k4 = i3[C4 + 56 | 0] | i3[C4 + 57 | 0] << 8 | i3[C4 + 58 | 0] << 16 | i3[C4 + 59 | 0] << 24, n4 = E3[B4 + 192 >> 2], s4 = E3[B4 + 196 >> 2], F4 = E3[B4 + 200 >> 2], E3[B4 + 204 >> 2] = (i3[C4 + 44 | 0] | i3[C4 + 45 | 0] << 8 | i3[C4 + 46 | 0] << 16 | i3[C4 + 47 | 0] << 24) & (i3[C4 + 60 | 0] | i3[C4 + 61 | 0] << 8 | i3[C4 + 62 | 0] << 16 | i3[C4 + 63 | 0] << 24) ^ (i3[C4 + 28 | 0] | i3[C4 + 29 | 0] << 8 | i3[C4 + 30 | 0] << 16 | i3[C4 + 31 | 0] << 24) ^ (i3[C4 + 76 | 0] | i3[C4 + 77 | 0] << 8 | i3[C4 + 78 | 0] << 16 | i3[C4 + 79 | 0] << 24) ^ E3[B4 + 204 >> 2] ^ (i3[C4 + 92 | 0] | i3[C4 + 93 | 0] << 8 | i3[C4 + 94 | 0] << 16 | i3[C4 + 95 | 0] << 24), E3[B4 + 200 >> 2] = h4 & k4 ^ t4 ^ F4 ^ w4 ^ e4, E3[B4 + 196 >> 2] = y4 & f4 ^ a4 ^ s4 ^ D4 ^ c4, E3[B4 + 192 >> 2] = Q4 & o4 ^ N4 ^ K4 ^ S4 ^ n4, VA(g6 + M4 | 0, 0, 16 - g6 | 0), TA(A8, M4, g6), g6 = E3[B4 + 192 >> 2], M4 = E3[B4 + 196 >> 2], N4 = E3[B4 + 200 >> 2], K4 = E3[B4 + 204 >> 2], A8 = E3[C4 + 92 >> 2], E3[B4 + 232 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[C4 + 84 >> 2], E3[B4 + 224 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 228 >> 2] = A8, A8 = E3[C4 + 76 >> 2], E3[B4 + 184 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 188 >> 2] = A8, A8 = E3[I7 + 4 >> 2], E3[B4 + 176 >> 2] = E3[I7 >> 2], E3[B4 + 180 >> 2] = A8, A8 = E3[C4 + 92 >> 2], E3[B4 + 168 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 172 >> 2] = A8, A8 = E3[C4 + 84 >> 2], E3[B4 + 160 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 164 >> 2] = A8, aA(A8 = B4 + 208 | 0, B4 + 176 | 0, B4 + 160 | 0), S4 = E3[B4 + 220 >> 2], E3[C4 + 88 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 92 >> 2] = S4, S4 = E3[B4 + 212 >> 2], E3[C4 + 80 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 84 >> 2] = S4, S4 = E3[C4 + 60 >> 2], E3[B4 + 152 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 156 >> 2] = S4, S4 = E3[C4 + 52 >> 2], E3[B4 + 144 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 148 >> 2] = S4, S4 = E3[C4 + 76 >> 2], E3[B4 + 136 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 140 >> 2] = S4, S4 = E3[I7 + 4 >> 2], E3[B4 + 128 >> 2] = E3[I7 >> 2], E3[B4 + 132 >> 2] = S4, aA(A8, B4 + 144 | 0, B4 + 128 | 0), S4 = E3[B4 + 220 >> 2], E3[C4 + 72 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 76 >> 2] = S4, S4 = E3[B4 + 212 >> 2], E3[I7 >> 2] = E3[B4 + 208 >> 2], E3[I7 + 4 >> 2] = S4, I7 = E3[C4 + 44 >> 2], E3[B4 + 120 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 124 >> 2] = I7, I7 = E3[C4 + 36 >> 2], E3[B4 + 112 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 116 >> 2] = I7, I7 = E3[C4 + 60 >> 2], E3[B4 + 104 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 108 >> 2] = I7, I7 = E3[C4 + 52 >> 2], E3[B4 + 96 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 100 >> 2] = I7, aA(A8, B4 + 112 | 0, B4 + 96 | 0), I7 = E3[B4 + 220 >> 2], E3[C4 + 56 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 60 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[C4 + 48 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 52 >> 2] = I7, I7 = E3[C4 + 28 >> 2], E3[B4 + 88 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 92 >> 2] = I7, I7 = E3[C4 + 20 >> 2], E3[B4 + 80 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 84 >> 2] = I7, I7 = E3[C4 + 44 >> 2], E3[B4 + 72 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 76 >> 2] = I7, I7 = E3[C4 + 36 >> 2], E3[B4 + 64 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 68 >> 2] = I7, aA(A8, B4 + 80 | 0, B4 - -64 | 0), I7 = E3[B4 + 220 >> 2], E3[C4 + 40 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 44 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[C4 + 32 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 36 >> 2] = I7, I7 = E3[C4 + 12 >> 2], E3[B4 + 56 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 60 >> 2] = I7, I7 = E3[C4 + 4 >> 2], E3[B4 + 48 >> 2] = E3[C4 >> 2], E3[B4 + 52 >> 2] = I7, I7 = E3[C4 + 28 >> 2], E3[B4 + 40 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 44 >> 2] = I7, I7 = E3[C4 + 20 >> 2], E3[B4 + 32 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 36 >> 2] = I7, aA(A8, B4 + 48 | 0, B4 + 32 | 0), I7 = E3[B4 + 220 >> 2], E3[C4 + 24 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[C4 + 16 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[B4 + 236 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 232 >> 2], E3[B4 + 28 >> 2] = I7, I7 = E3[B4 + 228 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 224 >> 2], E3[B4 + 20 >> 2] = I7, I7 = E3[C4 + 12 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 12 >> 2] = I7, I7 = E3[C4 + 4 >> 2], E3[B4 >> 2] = E3[C4 >> 2], E3[B4 + 4 >> 2] = I7, aA(A8, B4 + 16 | 0, B4), A8 = E3[B4 + 208 >> 2], I7 = E3[B4 + 212 >> 2], S4 = E3[B4 + 216 >> 2], E3[C4 + 12 >> 2] = K4 ^ E3[B4 + 220 >> 2], E3[C4 + 8 >> 2] = S4 ^ N4, E3[C4 + 4 >> 2] = I7 ^ M4, E3[C4 >> 2] = A8 ^ g6, r3 = B4 + 240 | 0; + } + function m3(A8, I7, g6) { + var B4, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + r3 = B4 = r3 + -64 | 0; + A: { + if ((g6 - 65 & 255) >>> 0 > 191) { + if (c4 = -1, !(i3[A8 + 80 | 0] | i3[A8 + 81 | 0] << 8 | i3[A8 + 82 | 0] << 16 | i3[A8 + 83 | 0] << 24 | i3[A8 + 84 | 0] | i3[A8 + 85 | 0] << 8 | i3[A8 + 86 | 0] << 16 | i3[A8 + 87 | 0] << 24)) { + if ((D4 = i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) >>> 0 >= 129) { + if (a4 = o4 = i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24, o4 = (D4 = 128 + (c4 = i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) | 0) >>> 0 < 128 ? o4 + 1 | 0 : o4, C3[A8 + 64 | 0] = D4, C3[A8 + 65 | 0] = D4 >>> 8, C3[A8 + 66 | 0] = D4 >>> 16, C3[A8 + 67 | 0] = D4 >>> 24, C3[A8 + 68 | 0] = o4, C3[A8 + 69 | 0] = o4 >>> 8, C3[A8 + 70 | 0] = o4 >>> 16, C3[A8 + 71 | 0] = o4 >>> 24, o4 = i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24, o4 = (y4 = c4 = -1 == (0 | a4) & c4 >>> 0 > 4294967167) >>> 0 > (c4 = c4 + (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) | 0) >>> 0 ? o4 + 1 | 0 : o4, C3[A8 + 72 | 0] = c4, C3[A8 + 73 | 0] = c4 >>> 8, C3[A8 + 74 | 0] = c4 >>> 16, C3[A8 + 75 | 0] = c4 >>> 24, C3[A8 + 76 | 0] = o4, C3[A8 + 77 | 0] = o4 >>> 8, C3[A8 + 78 | 0] = o4 >>> 16, C3[A8 + 79 | 0] = o4 >>> 24, h3(A8, o4 = A8 + 96 | 0), c4 = (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) - 128 | 0, C3[A8 + 352 | 0] = c4, C3[A8 + 353 | 0] = c4 >>> 8, C3[A8 + 354 | 0] = c4 >>> 16, C3[A8 + 355 | 0] = c4 >>> 24, c4 >>> 0 >= 129) break A; + TA(o4, A8 + 224 | 0, c4), D4 = i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24; + } + c4 = y4 = i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24, c4 = (a4 = D4 + (o4 = i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, C3[A8 + 64 | 0] = a4, C3[A8 + 65 | 0] = a4 >>> 8, C3[A8 + 66 | 0] = a4 >>> 16, C3[A8 + 67 | 0] = a4 >>> 24, C3[A8 + 68 | 0] = c4, C3[A8 + 69 | 0] = c4 >>> 8, C3[A8 + 70 | 0] = c4 >>> 16, C3[A8 + 71 | 0] = c4 >>> 24, c4 = (0 | c4) == (0 | y4) & o4 >>> 0 > a4 >>> 0 | c4 >>> 0 < y4 >>> 0, o4 = i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24, o4 = (y4 = c4) >>> 0 > (c4 = c4 + (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) | 0) >>> 0 ? o4 + 1 | 0 : o4, C3[A8 + 72 | 0] = c4, C3[A8 + 73 | 0] = c4 >>> 8, C3[A8 + 74 | 0] = c4 >>> 16, C3[A8 + 75 | 0] = c4 >>> 24, C3[A8 + 76 | 0] = o4, C3[A8 + 77 | 0] = o4 >>> 8, C3[A8 + 78 | 0] = o4 >>> 16, C3[A8 + 79 | 0] = o4 >>> 24, i3[A8 + 356 | 0] && (C3[A8 + 88 | 0] = 255, C3[A8 + 89 | 0] = 255, C3[A8 + 90 | 0] = 255, C3[A8 + 91 | 0] = 255, C3[A8 + 92 | 0] = 255, C3[A8 + 93 | 0] = 255, C3[A8 + 94 | 0] = 255, C3[A8 + 95 | 0] = 255), C3[A8 + 80 | 0] = 255, C3[A8 + 81 | 0] = 255, C3[A8 + 82 | 0] = 255, C3[A8 + 83 | 0] = 255, C3[A8 + 84 | 0] = 255, C3[A8 + 85 | 0] = 255, C3[A8 + 86 | 0] = 255, C3[A8 + 87 | 0] = 255, VA((c4 = A8 + 96 | 0) + D4 | 0, 0, 256 - D4 | 0), h3(A8, c4), o4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[B4 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[B4 + 4 >> 2] = o4, o4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[B4 + 8 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[B4 + 12 >> 2] = o4, o4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[B4 + 16 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[B4 + 20 >> 2] = o4, o4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[B4 + 24 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[B4 + 28 >> 2] = o4, o4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[B4 + 32 >> 2] = i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24, E3[B4 + 36 >> 2] = o4, o4 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24, E3[B4 + 40 >> 2] = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[B4 + 44 >> 2] = o4, o4 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24, E3[B4 + 48 >> 2] = i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24, E3[B4 + 52 >> 2] = o4, o4 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24, E3[B4 + 56 >> 2] = i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24, E3[B4 + 60 >> 2] = o4, TA(I7, B4, g6), MI(A8, 64), MI(c4, 256), c4 = 0; + } + return r3 = B4 - -64 | 0, c4; + } + iI(), Q3(); + } + f3(1268, 1130, 306, 1074), Q3(); + } + function q3(A8, I7) { + var g6, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0; + for (r3 = g6 = r3 - 320 | 0, V(B4 = A8 + 40 | 0, I7), E3[A8 + 84 >> 2] = 0, E3[A8 + 88 >> 2] = 0, E3[A8 + 80 >> 2] = 1, E3[A8 + 92 >> 2] = 0, E3[A8 + 96 >> 2] = 0, E3[A8 + 100 >> 2] = 0, E3[A8 + 104 >> 2] = 0, E3[A8 + 108 >> 2] = 0, E3[A8 + 112 >> 2] = 0, E3[A8 + 116 >> 2] = 0, U3(p4 = g6 + 240 | 0, B4), M3(K4 = g6 + 192 | 0, p4, 1328), H4 = -1, Q4 = E3[g6 + 240 >> 2] - 1 | 0, E3[g6 + 240 >> 2] = Q4, E3[g6 + 192 >> 2] = E3[g6 + 192 >> 2] + 1, o4 = E3[g6 + 244 >> 2], c4 = E3[g6 + 248 >> 2], D4 = E3[g6 + 252 >> 2], a4 = E3[g6 + 256 >> 2], y4 = E3[g6 + 260 >> 2], f4 = E3[g6 + 264 >> 2], e4 = E3[g6 + 268 >> 2], w4 = E3[g6 + 272 >> 2], t4 = E3[g6 + 276 >> 2], U3(_4 = g6 + 144 | 0, K4), M3(_4, _4, K4), U3(A8, _4), M3(A8, A8, K4), M3(A8, A8, p4), r3 = S4 = r3 - 144 | 0, U3(N4 = S4 + 96 | 0, A8), U3(F4 = S4 + 48 | 0, N4), U3(F4, F4), M3(F4, A8, F4), M3(N4, N4, F4), U3(N4, N4), M3(N4, F4, N4), U3(F4, N4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(N4, F4, N4), U3(F4, N4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(F4, F4, N4), U3(S4, F4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), M3(F4, S4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(N4, F4, N4), U3(F4, N4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(F4, F4, N4), U3(S4, F4), F4 = 1; U3(S4, S4), 100 != (0 | (F4 = F4 + 1 | 0)); ) ; + M3(F4 = S4 + 48 | 0, S4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(N4 = S4 + 96 | 0, F4, N4), U3(N4, N4), U3(N4, N4), M3(A8, N4, A8), r3 = S4 + 144 | 0, M3(A8, A8, _4), M3(A8, A8, p4), U3(F4 = g6 + 96 | 0, A8), M3(F4, F4, K4), F4 = E3[g6 + 132 >> 2], E3[g6 + 84 >> 2] = F4 - t4, S4 = E3[g6 + 128 >> 2], E3[g6 + 80 >> 2] = S4 - w4, N4 = E3[g6 + 124 >> 2], E3[g6 + 76 >> 2] = N4 - e4, K4 = E3[g6 + 120 >> 2], E3[g6 + 72 >> 2] = K4 - f4, _4 = E3[g6 + 116 >> 2], E3[g6 + 68 >> 2] = _4 - y4, p4 = E3[g6 + 112 >> 2], E3[g6 + 64 >> 2] = p4 - a4, h4 = E3[g6 + 108 >> 2], E3[g6 + 60 >> 2] = h4 - D4, k4 = E3[g6 + 104 >> 2], E3[g6 + 56 >> 2] = k4 - c4, n4 = E3[g6 + 100 >> 2], E3[g6 + 52 >> 2] = n4 - o4, s4 = E3[g6 + 96 >> 2], E3[g6 + 48 >> 2] = s4 - Q4, eA(g6, g6 + 48 | 0); + A: { + if (!SA(g6, 32)) { + if (E3[g6 + 36 >> 2] = F4 + t4, E3[g6 + 32 >> 2] = S4 + w4, E3[g6 + 28 >> 2] = N4 + e4, E3[g6 + 24 >> 2] = K4 + f4, E3[g6 + 20 >> 2] = _4 + y4, E3[g6 + 16 >> 2] = p4 + a4, E3[g6 + 12 >> 2] = D4 + h4, E3[g6 + 8 >> 2] = c4 + k4, E3[g6 + 4 >> 2] = o4 + n4, E3[g6 >> 2] = Q4 + s4, eA(F4 = g6 + 288 | 0, g6), !SA(F4, 32)) break A; + M3(A8, A8, 1376); + } + eA(g6 + 288 | 0, A8), (1 & C3[g6 + 288 | 0]) == (i3[I7 + 31 | 0] >>> 7 | 0) && (E3[A8 >> 2] = 0 - E3[A8 >> 2], E3[A8 + 36 >> 2] = 0 - E3[A8 + 36 >> 2], E3[A8 + 32 >> 2] = 0 - E3[A8 + 32 >> 2], E3[A8 + 28 >> 2] = 0 - E3[A8 + 28 >> 2], E3[A8 + 24 >> 2] = 0 - E3[A8 + 24 >> 2], E3[A8 + 20 >> 2] = 0 - E3[A8 + 20 >> 2], E3[A8 + 16 >> 2] = 0 - E3[A8 + 16 >> 2], E3[A8 + 12 >> 2] = 0 - E3[A8 + 12 >> 2], E3[A8 + 8 >> 2] = 0 - E3[A8 + 8 >> 2], E3[A8 + 4 >> 2] = 0 - E3[A8 + 4 >> 2]), M3(A8 + 120 | 0, A8, B4), H4 = 0; + } + return r3 = g6 + 320 | 0, H4; + } + function l2(A8, I7, g6) { + var B4, Q4, E4, o4, c4, D4, a4, y4, f4, e4, w4, r4, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0; + for (s4 = 1634760805, h4 = B4 = i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24, F4 = Q4 = i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24, S4 = E4 = i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24, M4 = o4 = i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24, p4 = 857760878, N4 = c4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, k4 = D4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, _4 = a4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, G4 = y4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, I7 = 2036477234, n4 = f4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, t4 = 1797285236, J4 = e4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, H4 = w4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, g6 = r4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24; K4 = gI(h4 + p4 | 0, 7) ^ G4, Y4 = gI(K4 + p4 | 0, 9) ^ H4, M4 = gI(g6 + s4 | 0, 7) ^ M4, U4 = gI(M4 + s4 | 0, 9) ^ _4, b4 = gI(U4 + M4 | 0, 13) ^ g6, S4 = gI(t4 + n4 | 0, 7) ^ S4, d4 = gI(S4 + t4 | 0, 9) ^ k4, _4 = gI(S4 + d4 | 0, 13) ^ n4, n4 = gI(d4 + _4 | 0, 18) ^ t4, k4 = gI(I7 + N4 | 0, 7) ^ J4, g6 = b4 ^ gI(n4 + k4 | 0, 7), H4 = Y4 ^ gI(g6 + n4 | 0, 9), J4 = gI(g6 + H4 | 0, 13) ^ k4, t4 = gI(H4 + J4 | 0, 18) ^ n4, F4 = gI(I7 + k4 | 0, 9) ^ F4, N4 = gI(F4 + k4 | 0, 13) ^ N4, I7 = gI(N4 + F4 | 0, 18) ^ I7, n4 = gI(I7 + K4 | 0, 7) ^ _4, _4 = gI(n4 + I7 | 0, 9) ^ U4, G4 = gI(n4 + _4 | 0, 13) ^ K4, I7 = gI(_4 + G4 | 0, 18) ^ I7, K4 = gI(K4 + Y4 | 0, 13) ^ h4, h4 = gI(K4 + Y4 | 0, 18) ^ p4, N4 = gI(h4 + M4 | 0, 7) ^ N4, k4 = gI(N4 + h4 | 0, 9) ^ d4, M4 = gI(k4 + N4 | 0, 13) ^ M4, p4 = gI(k4 + M4 | 0, 18) ^ h4, s4 = gI(U4 + b4 | 0, 18) ^ s4, h4 = gI(s4 + S4 | 0, 7) ^ K4, F4 = gI(h4 + s4 | 0, 9) ^ F4, S4 = gI(h4 + F4 | 0, 13) ^ S4, s4 = gI(F4 + S4 | 0, 18) ^ s4, K4 = P4 >>> 0 < 18, P4 = P4 + 2 | 0, K4; ) ; + t4 = t4 + 1797285236 | 0, C3[A8 + 60 | 0] = t4, C3[A8 + 61 | 0] = t4 >>> 8, C3[A8 + 62 | 0] = t4 >>> 16, C3[A8 + 63 | 0] = t4 >>> 24, t4 = J4 + e4 | 0, C3[A8 + 56 | 0] = t4, C3[A8 + 57 | 0] = t4 >>> 8, C3[A8 + 58 | 0] = t4 >>> 16, C3[A8 + 59 | 0] = t4 >>> 24, t4 = H4 + w4 | 0, C3[A8 + 52 | 0] = t4, C3[A8 + 53 | 0] = t4 >>> 8, C3[A8 + 54 | 0] = t4 >>> 16, C3[A8 + 55 | 0] = t4 >>> 24, g6 = g6 + r4 | 0, C3[A8 + 48 | 0] = g6, C3[A8 + 49 | 0] = g6 >>> 8, C3[A8 + 50 | 0] = g6 >>> 16, C3[A8 + 51 | 0] = g6 >>> 24, g6 = n4 + f4 | 0, C3[A8 + 44 | 0] = g6, C3[A8 + 45 | 0] = g6 >>> 8, C3[A8 + 46 | 0] = g6 >>> 16, C3[A8 + 47 | 0] = g6 >>> 24, I7 = I7 + 2036477234 | 0, C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, I7 = G4 + y4 | 0, C3[A8 + 36 | 0] = I7, C3[A8 + 37 | 0] = I7 >>> 8, C3[A8 + 38 | 0] = I7 >>> 16, C3[A8 + 39 | 0] = I7 >>> 24, I7 = _4 + a4 | 0, C3[A8 + 32 | 0] = I7, C3[A8 + 33 | 0] = I7 >>> 8, C3[A8 + 34 | 0] = I7 >>> 16, C3[A8 + 35 | 0] = I7 >>> 24, I7 = k4 + D4 | 0, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = N4 + c4 | 0, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = p4 + 857760878 | 0, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = M4 + o4 | 0, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, I7 = S4 + E4 | 0, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = F4 + Q4 | 0, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = h4 + B4 | 0, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = s4 + 1634760805 | 0, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24; + } + function z(A8, I7, g6, C4) { + var B4 = 0, Q4 = 0, o4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0; + if (h4 = E3[A8 + 36 >> 2], w4 = E3[A8 + 32 >> 2], r4 = E3[A8 + 28 >> 2], f4 = E3[A8 + 24 >> 2], e4 = E3[A8 + 20 >> 2], !C4 & g6 >>> 0 >= 16 | C4) for (p4 = !i3[A8 + 80 | 0] << 24, n4 = E3[A8 + 4 >> 2], H4 = c3(n4, 5), F4 = E3[A8 + 8 >> 2], K4 = c3(F4, 5), M4 = E3[A8 + 12 >> 2], N4 = c3(M4, 5), _4 = E3[A8 + 16 >> 2], S4 = c3(_4, 5), s4 = E3[A8 >> 2]; B4 = PA(o4 = ((i3[I7 + 3 | 0] | i3[I7 + 4 | 0] << 8 | i3[I7 + 5 | 0] << 16 | i3[I7 + 6 | 0] << 24) >>> 2 & 67108863) + f4 | 0, 0, M4, 0), a4 = t3, e4 = (D4 = PA(f4 = (67108863 & (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24)) + e4 | 0, 0, _4, 0)) + B4 | 0, B4 = t3 + a4 | 0, B4 = D4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4, a4 = PA(r4 = ((i3[I7 + 6 | 0] | i3[I7 + 7 | 0] << 8 | i3[I7 + 8 | 0] << 16 | i3[I7 + 9 | 0] << 24) >>> 4 & 67108863) + r4 | 0, 0, F4, 0), B4 = t3 + B4 | 0, B4 = a4 >>> 0 > (e4 = a4 + e4 | 0) >>> 0 ? B4 + 1 | 0 : B4, a4 = PA(w4 = ((i3[I7 + 9 | 0] | i3[I7 + 10 | 0] << 8 | i3[I7 + 11 | 0] << 16 | i3[I7 + 12 | 0] << 24) >>> 6 | 0) + w4 | 0, 0, n4, 0), B4 = t3 + B4 | 0, B4 = a4 >>> 0 > (e4 = a4 + e4 | 0) >>> 0 ? B4 + 1 | 0 : B4, a4 = PA(h4 = h4 + p4 + ((i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) >>> 8) | 0, 0, s4, 0), B4 = t3 + B4 | 0, G4 = e4 = a4 + e4 | 0, e4 = a4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4, B4 = PA(o4, 0, F4, 0), a4 = t3, D4 = PA(f4, 0, M4, 0), Q4 = t3 + a4 | 0, Q4 = (B4 = D4 + B4 | 0) >>> 0 < D4 >>> 0 ? Q4 + 1 | 0 : Q4, a4 = (D4 = PA(r4, 0, n4, 0)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = D4 >>> 0 > a4 >>> 0 ? B4 + 1 | 0 : B4, D4 = PA(w4, 0, s4, 0), B4 = t3 + B4 | 0, B4 = D4 >>> 0 > (a4 = D4 + a4 | 0) >>> 0 ? B4 + 1 | 0 : B4, D4 = PA(h4, 0, S4, 0), B4 = t3 + B4 | 0, J4 = a4 = D4 + a4 | 0, a4 = D4 >>> 0 > a4 >>> 0 ? B4 + 1 | 0 : B4, B4 = PA(o4, 0, n4, 0), y4 = t3, D4 = (Q4 = PA(f4, 0, F4, 0)) + B4 | 0, B4 = t3 + y4 | 0, B4 = Q4 >>> 0 > D4 >>> 0 ? B4 + 1 | 0 : B4, y4 = PA(r4, 0, s4, 0), Q4 = t3 + B4 | 0, Q4 = (D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, y4 = PA(w4, 0, S4, 0), B4 = t3 + Q4 | 0, B4 = (D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, y4 = PA(h4, 0, N4, 0), B4 = t3 + B4 | 0, Y4 = D4 = y4 + D4 | 0, D4 = D4 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, B4 = PA(o4, 0, s4, 0), Q4 = t3, y4 = (k4 = PA(f4, 0, n4, 0)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = y4 >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = PA(r4, 0, S4, 0), B4 = t3 + B4 | 0, B4 = Q4 >>> 0 > (y4 = Q4 + y4 | 0) >>> 0 ? B4 + 1 | 0 : B4, k4 = PA(w4, 0, N4, 0), Q4 = t3 + B4 | 0, Q4 = (y4 = k4 + y4 | 0) >>> 0 < k4 >>> 0 ? Q4 + 1 | 0 : Q4, k4 = PA(h4, 0, K4, 0), B4 = t3 + Q4 | 0, B4 = (y4 = k4 + y4 | 0) >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, k4 = y4, y4 = B4, B4 = PA(o4, 0, S4, 0), Q4 = t3, o4 = (f4 = PA(f4, 0, s4, 0)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = o4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, f4 = PA(r4, 0, N4, 0), B4 = t3 + B4 | 0, B4 = (o4 = f4 + o4 | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, f4 = PA(w4, 0, K4, 0), B4 = t3 + B4 | 0, B4 = (o4 = f4 + o4 | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, f4 = PA(h4, 0, H4, 0), Q4 = t3 + B4 | 0, Q4 = (o4 = f4 + o4 | 0) >>> 0 < f4 >>> 0 ? Q4 + 1 | 0 : Q4, f4 = o4, B4 = y4, B4 = (o4 = (r4 = (67108863 & Q4) << 6 | o4 >>> 26) + k4 | 0) >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, r4 = o4, w4 = (67108863 & B4) << 6 | o4 >>> 26, B4 = D4, B4 = (o4 = w4 + Y4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, w4 = o4, Q4 = a4, h4 = B4 = (o4 = (67108863 & B4) << 6 | o4 >>> 26) + J4 | 0, a4 = (67108863 & (Q4 = B4 >>> 0 < o4 >>> 0 ? Q4 + 1 | 0 : Q4)) << 6 | B4 >>> 26, B4 = e4, f4 = (67108863 & r4) + ((B4 = c3((67108863 & ((o4 = a4 + G4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 : B4)) << 6 | o4 >>> 26, 5) + (67108863 & f4) | 0) >>> 26 | 0) | 0, r4 = 67108863 & w4, w4 = 67108863 & h4, h4 = 67108863 & o4, e4 = 67108863 & B4, I7 = I7 + 16 | 0, !(C4 = C4 - (g6 >>> 0 < 16) | 0) & (g6 = g6 - 16 | 0) >>> 0 > 15 | C4; ) ; + E3[A8 + 20 >> 2] = e4, E3[A8 + 36 >> 2] = h4, E3[A8 + 32 >> 2] = w4, E3[A8 + 28 >> 2] = r4, E3[A8 + 24 >> 2] = f4; + } + function j(A8, I7, g6, B4) { + A8 |= 0, I7 |= 0; + var E4 = 0; + return E4 = -1, (B4 |= 0) - 65 >>> 0 < 4294967232 | (g6 |= 0) >>> 0 > 64 || (g6 && I7 ? (r3 = E4 = r3 - 128 | 0, !I7 | ((B4 &= 255) - 65 & 255) >>> 0 <= 191 | ((g6 &= 255) - 65 & 255) >>> 0 <= 191 ? (iI(), Q3()) : (VA(A8 - -64 | 0, 0, 293), C3[A8 + 56 | 0] = 121, C3[A8 + 57 | 0] = 33, C3[A8 + 58 | 0] = 126, C3[A8 + 59 | 0] = 19, C3[A8 + 60 | 0] = 25, C3[A8 + 61 | 0] = 205, C3[A8 + 62 | 0] = 224, C3[A8 + 63 | 0] = 91, C3[A8 + 48 | 0] = 107, C3[A8 + 49 | 0] = 189, C3[A8 + 50 | 0] = 65, C3[A8 + 51 | 0] = 251, C3[A8 + 52 | 0] = 171, C3[A8 + 53 | 0] = 217, C3[A8 + 54 | 0] = 131, C3[A8 + 55 | 0] = 31, C3[A8 + 40 | 0] = 31, C3[A8 + 41 | 0] = 108, C3[A8 + 42 | 0] = 62, C3[A8 + 43 | 0] = 43, C3[A8 + 44 | 0] = 140, C3[A8 + 45 | 0] = 104, C3[A8 + 46 | 0] = 5, C3[A8 + 47 | 0] = 155, C3[A8 + 32 | 0] = 209, C3[A8 + 33 | 0] = 130, C3[A8 + 34 | 0] = 230, C3[A8 + 35 | 0] = 173, C3[A8 + 36 | 0] = 127, C3[A8 + 37 | 0] = 82, C3[A8 + 38 | 0] = 14, C3[A8 + 39 | 0] = 81, C3[A8 + 24 | 0] = 241, C3[A8 + 25 | 0] = 54, C3[A8 + 26 | 0] = 29, C3[A8 + 27 | 0] = 95, C3[A8 + 28 | 0] = 58, C3[A8 + 29 | 0] = 245, C3[A8 + 30 | 0] = 79, C3[A8 + 31 | 0] = 165, C3[A8 + 16 | 0] = 43, C3[A8 + 17 | 0] = 248, C3[A8 + 18 | 0] = 148, C3[A8 + 19 | 0] = 254, C3[A8 + 20 | 0] = 114, C3[A8 + 21 | 0] = 243, C3[A8 + 22 | 0] = 110, C3[A8 + 23 | 0] = 60, C3[A8 + 8 | 0] = 59, C3[A8 + 9 | 0] = 167, C3[A8 + 10 | 0] = 202, C3[A8 + 11 | 0] = 132, C3[A8 + 12 | 0] = 133, C3[A8 + 13 | 0] = 174, C3[A8 + 14 | 0] = 103, C3[A8 + 15 | 0] = 187, B4 = -222443256 ^ (g6 << 8 | B4), C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, B4 = g6 >>> 24 ^ 1779033703, C3[A8 + 4 | 0] = B4, C3[A8 + 5 | 0] = B4 >>> 8, C3[A8 + 6 | 0] = B4 >>> 16, C3[A8 + 7 | 0] = B4 >>> 24, g6 = TA(VA(E4, 0, 128), I7, g6), TA(A8 + 96 | 0, g6, 128), I7 = 128 + (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) | 0, C3[A8 + 352 | 0] = I7, C3[A8 + 353 | 0] = I7 >>> 8, C3[A8 + 354 | 0] = I7 >>> 16, C3[A8 + 355 | 0] = I7 >>> 24, MI(g6, 128), r3 = g6 + 128 | 0)) : (((I7 = 255 & B4) - 65 & 255) >>> 0 <= 191 && (iI(), Q3()), VA(A8 - -64 | 0, 0, 293), C3[A8 + 56 | 0] = 121, C3[A8 + 57 | 0] = 33, C3[A8 + 58 | 0] = 126, C3[A8 + 59 | 0] = 19, C3[A8 + 60 | 0] = 25, C3[A8 + 61 | 0] = 205, C3[A8 + 62 | 0] = 224, C3[A8 + 63 | 0] = 91, C3[A8 + 48 | 0] = 107, C3[A8 + 49 | 0] = 189, C3[A8 + 50 | 0] = 65, C3[A8 + 51 | 0] = 251, C3[A8 + 52 | 0] = 171, C3[A8 + 53 | 0] = 217, C3[A8 + 54 | 0] = 131, C3[A8 + 55 | 0] = 31, C3[A8 + 40 | 0] = 31, C3[A8 + 41 | 0] = 108, C3[A8 + 42 | 0] = 62, C3[A8 + 43 | 0] = 43, C3[A8 + 44 | 0] = 140, C3[A8 + 45 | 0] = 104, C3[A8 + 46 | 0] = 5, C3[A8 + 47 | 0] = 155, C3[A8 + 32 | 0] = 209, C3[A8 + 33 | 0] = 130, C3[A8 + 34 | 0] = 230, C3[A8 + 35 | 0] = 173, C3[A8 + 36 | 0] = 127, C3[A8 + 37 | 0] = 82, C3[A8 + 38 | 0] = 14, C3[A8 + 39 | 0] = 81, C3[A8 + 24 | 0] = 241, C3[A8 + 25 | 0] = 54, C3[A8 + 26 | 0] = 29, C3[A8 + 27 | 0] = 95, C3[A8 + 28 | 0] = 58, C3[A8 + 29 | 0] = 245, C3[A8 + 30 | 0] = 79, C3[A8 + 31 | 0] = 165, C3[A8 + 16 | 0] = 43, C3[A8 + 17 | 0] = 248, C3[A8 + 18 | 0] = 148, C3[A8 + 19 | 0] = 254, C3[A8 + 20 | 0] = 114, C3[A8 + 21 | 0] = 243, C3[A8 + 22 | 0] = 110, C3[A8 + 23 | 0] = 60, C3[A8 + 8 | 0] = 59, C3[A8 + 9 | 0] = 167, C3[A8 + 10 | 0] = 202, C3[A8 + 11 | 0] = 132, C3[A8 + 12 | 0] = 133, C3[A8 + 13 | 0] = 174, C3[A8 + 14 | 0] = 103, C3[A8 + 15 | 0] = 187, I7 ^= -222443256, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, C3[A8 + 4 | 0] = 103, C3[A8 + 5 | 0] = 230, C3[A8 + 6 | 0] = 9, C3[A8 + 7 | 0] = 106), E4 = 0), 0 | E4; + } + function X(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0; + w4 = E3[I7 + 4 >> 2], e4 = E3[I7 + 44 >> 2], t4 = E3[I7 + 8 >> 2], h4 = E3[I7 + 48 >> 2], k4 = E3[I7 + 12 >> 2], n4 = E3[I7 + 52 >> 2], s4 = E3[I7 + 16 >> 2], F4 = E3[I7 + 56 >> 2], S4 = E3[I7 + 20 >> 2], N4 = E3[I7 + 60 >> 2], K4 = E3[I7 + 24 >> 2], _4 = E3[(r4 = I7 - -64 | 0) >> 2], p4 = E3[I7 + 28 >> 2], H4 = E3[I7 + 68 >> 2], G4 = E3[I7 + 32 >> 2], J4 = E3[I7 + 72 >> 2], Y4 = E3[I7 + 36 >> 2], U4 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = Y4 + U4, E3[A8 + 32 >> 2] = G4 + J4, E3[A8 + 28 >> 2] = p4 + H4, E3[A8 + 24 >> 2] = K4 + _4, E3[A8 + 20 >> 2] = S4 + N4, E3[A8 + 16 >> 2] = s4 + F4, E3[A8 + 12 >> 2] = k4 + n4, E3[A8 + 8 >> 2] = t4 + h4, E3[A8 + 4 >> 2] = e4 + w4, e4 = E3[I7 + 4 >> 2], t4 = E3[I7 + 44 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 48 >> 2], n4 = E3[I7 + 12 >> 2], s4 = E3[I7 + 52 >> 2], F4 = E3[I7 + 16 >> 2], S4 = E3[I7 + 56 >> 2], N4 = E3[I7 + 20 >> 2], K4 = E3[I7 + 60 >> 2], _4 = E3[I7 + 24 >> 2], r4 = E3[r4 >> 2], w4 = E3[I7 + 28 >> 2], p4 = E3[I7 + 68 >> 2], H4 = E3[I7 + 32 >> 2], G4 = E3[I7 + 72 >> 2], J4 = E3[I7 >> 2], Y4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = G4 - H4, E3[A8 + 68 >> 2] = p4 - w4, E3[(w4 = A8 - -64 | 0) >> 2] = r4 - _4, E3[A8 + 60 >> 2] = K4 - N4, E3[A8 + 56 >> 2] = S4 - F4, E3[A8 + 52 >> 2] = s4 - n4, E3[A8 + 48 >> 2] = k4 - h4, E3[A8 + 44 >> 2] = t4 - e4, E3[A8 + 40 >> 2] = Y4 - J4, M3(A8 + 80 | 0, A8, g6), M3(e4 = A8 + 40 | 0, e4, g6 + 40 | 0), M3(A8 + 120 | 0, g6 + 120 | 0, I7 + 120 | 0), M3(A8, I7 + 80 | 0, g6 + 80 | 0), Y4 = E3[A8 + 4 >> 2], U4 = E3[A8 + 8 >> 2], Q4 = E3[A8 + 12 >> 2], i4 = E3[A8 + 16 >> 2], o4 = E3[A8 + 20 >> 2], c4 = E3[A8 + 24 >> 2], D4 = E3[A8 + 28 >> 2], a4 = E3[A8 + 32 >> 2], y4 = E3[A8 + 36 >> 2], I7 = E3[A8 + 44 >> 2], g6 = E3[A8 + 84 >> 2], e4 = E3[A8 + 48 >> 2], t4 = E3[A8 + 88 >> 2], h4 = E3[A8 + 52 >> 2], k4 = E3[A8 + 92 >> 2], n4 = E3[A8 + 56 >> 2], s4 = E3[A8 + 96 >> 2], F4 = E3[A8 + 60 >> 2], S4 = E3[A8 + 100 >> 2], N4 = E3[w4 >> 2], K4 = E3[A8 + 104 >> 2], r4 = E3[A8 + 68 >> 2], _4 = E3[A8 + 108 >> 2], p4 = E3[A8 + 72 >> 2], H4 = E3[A8 + 112 >> 2], f4 = E3[A8 >> 2], G4 = E3[A8 + 40 >> 2], J4 = E3[A8 + 80 >> 2], C4 = E3[A8 + 76 >> 2], B4 = E3[A8 + 116 >> 2], E3[A8 + 76 >> 2] = C4 + B4, E3[A8 + 72 >> 2] = p4 + H4, E3[A8 + 68 >> 2] = r4 + _4, E3[w4 >> 2] = N4 + K4, E3[A8 + 60 >> 2] = F4 + S4, E3[A8 + 56 >> 2] = n4 + s4, E3[A8 + 52 >> 2] = h4 + k4, E3[A8 + 48 >> 2] = e4 + t4, E3[A8 + 44 >> 2] = I7 + g6, E3[A8 + 40 >> 2] = G4 + J4, E3[A8 + 36 >> 2] = B4 - C4, E3[A8 + 32 >> 2] = H4 - p4, E3[A8 + 28 >> 2] = _4 - r4, E3[A8 + 24 >> 2] = K4 - N4, E3[A8 + 20 >> 2] = S4 - F4, E3[A8 + 16 >> 2] = s4 - n4, E3[A8 + 12 >> 2] = k4 - h4, E3[A8 + 8 >> 2] = t4 - e4, E3[A8 + 4 >> 2] = g6 - I7, E3[A8 >> 2] = J4 - G4, I7 = y4 << 1, g6 = E3[A8 + 156 >> 2], E3[A8 + 156 >> 2] = I7 - g6, w4 = a4 << 1, e4 = E3[A8 + 152 >> 2], E3[A8 + 152 >> 2] = w4 - e4, t4 = D4 << 1, h4 = E3[A8 + 148 >> 2], E3[A8 + 148 >> 2] = t4 - h4, k4 = c4 << 1, n4 = E3[A8 + 144 >> 2], E3[A8 + 144 >> 2] = k4 - n4, s4 = o4 << 1, F4 = E3[A8 + 140 >> 2], E3[A8 + 140 >> 2] = s4 - F4, S4 = i4 << 1, N4 = E3[A8 + 136 >> 2], E3[A8 + 136 >> 2] = S4 - N4, K4 = Q4 << 1, r4 = E3[A8 + 132 >> 2], E3[A8 + 132 >> 2] = K4 - r4, _4 = U4 << 1, p4 = E3[A8 + 128 >> 2], E3[A8 + 128 >> 2] = _4 - p4, H4 = Y4 << 1, G4 = E3[A8 + 124 >> 2], E3[A8 + 124 >> 2] = H4 - G4, J4 = f4 << 1, Y4 = E3[A8 + 120 >> 2], E3[A8 + 120 >> 2] = J4 - Y4, E3[A8 + 112 >> 2] = e4 + w4, E3[A8 + 108 >> 2] = t4 + h4, E3[A8 + 104 >> 2] = k4 + n4, E3[A8 + 100 >> 2] = s4 + F4, E3[A8 + 96 >> 2] = S4 + N4, E3[A8 + 92 >> 2] = K4 + r4, E3[A8 + 88 >> 2] = _4 + p4, E3[A8 + 84 >> 2] = H4 + G4, E3[A8 + 80 >> 2] = J4 + Y4, E3[A8 + 116 >> 2] = I7 + g6; + } + function O(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0; + w4 = E3[I7 + 4 >> 2], e4 = E3[I7 + 44 >> 2], t4 = E3[I7 + 8 >> 2], h4 = E3[I7 + 48 >> 2], k4 = E3[I7 + 12 >> 2], n4 = E3[I7 + 52 >> 2], s4 = E3[I7 + 16 >> 2], F4 = E3[I7 + 56 >> 2], S4 = E3[I7 + 20 >> 2], N4 = E3[I7 + 60 >> 2], K4 = E3[I7 + 24 >> 2], _4 = E3[(r4 = I7 - -64 | 0) >> 2], p4 = E3[I7 + 28 >> 2], H4 = E3[I7 + 68 >> 2], G4 = E3[I7 + 32 >> 2], J4 = E3[I7 + 72 >> 2], Y4 = E3[I7 + 36 >> 2], U4 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = Y4 + U4, E3[A8 + 32 >> 2] = G4 + J4, E3[A8 + 28 >> 2] = p4 + H4, E3[A8 + 24 >> 2] = K4 + _4, E3[A8 + 20 >> 2] = S4 + N4, E3[A8 + 16 >> 2] = s4 + F4, E3[A8 + 12 >> 2] = k4 + n4, E3[A8 + 8 >> 2] = t4 + h4, E3[A8 + 4 >> 2] = e4 + w4, e4 = E3[I7 + 4 >> 2], t4 = E3[I7 + 44 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 48 >> 2], n4 = E3[I7 + 12 >> 2], s4 = E3[I7 + 52 >> 2], F4 = E3[I7 + 16 >> 2], S4 = E3[I7 + 56 >> 2], N4 = E3[I7 + 20 >> 2], K4 = E3[I7 + 60 >> 2], _4 = E3[I7 + 24 >> 2], r4 = E3[r4 >> 2], w4 = E3[I7 + 28 >> 2], p4 = E3[I7 + 68 >> 2], H4 = E3[I7 + 32 >> 2], G4 = E3[I7 + 72 >> 2], J4 = E3[I7 >> 2], Y4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = G4 - H4, E3[A8 + 68 >> 2] = p4 - w4, E3[(w4 = A8 - -64 | 0) >> 2] = r4 - _4, E3[A8 + 60 >> 2] = K4 - N4, E3[A8 + 56 >> 2] = S4 - F4, E3[A8 + 52 >> 2] = s4 - n4, E3[A8 + 48 >> 2] = k4 - h4, E3[A8 + 44 >> 2] = t4 - e4, E3[A8 + 40 >> 2] = Y4 - J4, M3(A8 + 80 | 0, A8, g6 + 40 | 0), M3(e4 = A8 + 40 | 0, e4, g6), M3(A8 + 120 | 0, g6 + 120 | 0, I7 + 120 | 0), M3(A8, I7 + 80 | 0, g6 + 80 | 0), Y4 = E3[A8 + 4 >> 2], U4 = E3[A8 + 8 >> 2], Q4 = E3[A8 + 12 >> 2], i4 = E3[A8 + 16 >> 2], o4 = E3[A8 + 20 >> 2], c4 = E3[A8 + 24 >> 2], D4 = E3[A8 + 28 >> 2], a4 = E3[A8 + 32 >> 2], y4 = E3[A8 + 36 >> 2], I7 = E3[A8 + 44 >> 2], g6 = E3[A8 + 84 >> 2], e4 = E3[A8 + 48 >> 2], t4 = E3[A8 + 88 >> 2], h4 = E3[A8 + 52 >> 2], k4 = E3[A8 + 92 >> 2], n4 = E3[A8 + 56 >> 2], s4 = E3[A8 + 96 >> 2], F4 = E3[A8 + 60 >> 2], S4 = E3[A8 + 100 >> 2], N4 = E3[w4 >> 2], K4 = E3[A8 + 104 >> 2], r4 = E3[A8 + 68 >> 2], _4 = E3[A8 + 108 >> 2], p4 = E3[A8 + 72 >> 2], H4 = E3[A8 + 112 >> 2], f4 = E3[A8 >> 2], G4 = E3[A8 + 40 >> 2], J4 = E3[A8 + 80 >> 2], C4 = E3[A8 + 76 >> 2], B4 = E3[A8 + 116 >> 2], E3[A8 + 76 >> 2] = C4 + B4, E3[A8 + 72 >> 2] = p4 + H4, E3[A8 + 68 >> 2] = r4 + _4, E3[w4 >> 2] = N4 + K4, E3[A8 + 60 >> 2] = F4 + S4, E3[A8 + 56 >> 2] = n4 + s4, E3[A8 + 52 >> 2] = h4 + k4, E3[A8 + 48 >> 2] = e4 + t4, E3[A8 + 44 >> 2] = I7 + g6, E3[A8 + 40 >> 2] = G4 + J4, E3[A8 + 36 >> 2] = B4 - C4, E3[A8 + 32 >> 2] = H4 - p4, E3[A8 + 28 >> 2] = _4 - r4, E3[A8 + 24 >> 2] = K4 - N4, E3[A8 + 20 >> 2] = S4 - F4, E3[A8 + 16 >> 2] = s4 - n4, E3[A8 + 12 >> 2] = k4 - h4, E3[A8 + 8 >> 2] = t4 - e4, E3[A8 + 4 >> 2] = g6 - I7, E3[A8 >> 2] = J4 - G4, I7 = E3[A8 + 156 >> 2], g6 = y4 << 1, E3[A8 + 156 >> 2] = I7 + g6, w4 = E3[A8 + 152 >> 2], e4 = a4 << 1, E3[A8 + 152 >> 2] = w4 + e4, t4 = E3[A8 + 148 >> 2], h4 = D4 << 1, E3[A8 + 148 >> 2] = t4 + h4, k4 = E3[A8 + 144 >> 2], n4 = c4 << 1, E3[A8 + 144 >> 2] = k4 + n4, s4 = E3[A8 + 140 >> 2], F4 = o4 << 1, E3[A8 + 140 >> 2] = s4 + F4, S4 = E3[A8 + 136 >> 2], N4 = i4 << 1, E3[A8 + 136 >> 2] = S4 + N4, K4 = E3[A8 + 132 >> 2], r4 = Q4 << 1, E3[A8 + 132 >> 2] = K4 + r4, _4 = E3[A8 + 128 >> 2], p4 = U4 << 1, E3[A8 + 128 >> 2] = _4 + p4, H4 = E3[A8 + 124 >> 2], G4 = Y4 << 1, E3[A8 + 124 >> 2] = H4 + G4, J4 = E3[A8 + 120 >> 2], Y4 = f4 << 1, E3[A8 + 120 >> 2] = J4 + Y4, E3[A8 + 112 >> 2] = e4 - w4, E3[A8 + 108 >> 2] = h4 - t4, E3[A8 + 104 >> 2] = n4 - k4, E3[A8 + 100 >> 2] = F4 - s4, E3[A8 + 96 >> 2] = N4 - S4, E3[A8 + 92 >> 2] = r4 - K4, E3[A8 + 88 >> 2] = p4 - _4, E3[A8 + 84 >> 2] = G4 - H4, E3[A8 + 80 >> 2] = Y4 - J4, E3[A8 + 116 >> 2] = g6 - I7; + } + function T(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0; + w4 = E3[I7 + 4 >> 2], e4 = E3[I7 + 44 >> 2], t4 = E3[I7 + 8 >> 2], h4 = E3[I7 + 48 >> 2], k4 = E3[I7 + 12 >> 2], n4 = E3[I7 + 52 >> 2], s4 = E3[I7 + 16 >> 2], F4 = E3[I7 + 56 >> 2], S4 = E3[I7 + 20 >> 2], N4 = E3[I7 + 60 >> 2], K4 = E3[I7 + 24 >> 2], _4 = E3[(r4 = I7 - -64 | 0) >> 2], p4 = E3[I7 + 28 >> 2], H4 = E3[I7 + 68 >> 2], G4 = E3[I7 + 32 >> 2], J4 = E3[I7 + 72 >> 2], Y4 = E3[I7 + 36 >> 2], U4 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = Y4 + U4, E3[A8 + 32 >> 2] = G4 + J4, E3[A8 + 28 >> 2] = p4 + H4, E3[A8 + 24 >> 2] = K4 + _4, E3[A8 + 20 >> 2] = S4 + N4, E3[A8 + 16 >> 2] = s4 + F4, E3[A8 + 12 >> 2] = k4 + n4, E3[A8 + 8 >> 2] = t4 + h4, E3[A8 + 4 >> 2] = e4 + w4, e4 = E3[I7 + 4 >> 2], t4 = E3[I7 + 44 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 48 >> 2], n4 = E3[I7 + 12 >> 2], s4 = E3[I7 + 52 >> 2], F4 = E3[I7 + 16 >> 2], S4 = E3[I7 + 56 >> 2], N4 = E3[I7 + 20 >> 2], K4 = E3[I7 + 60 >> 2], _4 = E3[I7 + 24 >> 2], r4 = E3[r4 >> 2], w4 = E3[I7 + 28 >> 2], p4 = E3[I7 + 68 >> 2], H4 = E3[I7 + 32 >> 2], G4 = E3[I7 + 72 >> 2], J4 = E3[I7 >> 2], Y4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = G4 - H4, E3[A8 + 68 >> 2] = p4 - w4, E3[(w4 = A8 - -64 | 0) >> 2] = r4 - _4, E3[A8 + 60 >> 2] = K4 - N4, E3[A8 + 56 >> 2] = S4 - F4, E3[A8 + 52 >> 2] = s4 - n4, E3[A8 + 48 >> 2] = k4 - h4, E3[A8 + 44 >> 2] = t4 - e4, E3[A8 + 40 >> 2] = Y4 - J4, M3(A8 + 80 | 0, A8, g6), M3(e4 = A8 + 40 | 0, e4, g6 + 40 | 0), M3(A8 + 120 | 0, g6 + 80 | 0, I7 + 120 | 0), Y4 = E3[I7 + 84 >> 2], U4 = E3[I7 + 88 >> 2], Q4 = E3[I7 + 92 >> 2], i4 = E3[I7 + 96 >> 2], o4 = E3[I7 + 100 >> 2], c4 = E3[I7 + 104 >> 2], D4 = E3[I7 + 108 >> 2], a4 = E3[I7 + 112 >> 2], y4 = E3[I7 + 116 >> 2], g6 = E3[A8 + 44 >> 2], e4 = E3[A8 + 84 >> 2], t4 = E3[A8 + 48 >> 2], h4 = E3[A8 + 88 >> 2], k4 = E3[A8 + 52 >> 2], n4 = E3[A8 + 92 >> 2], s4 = E3[A8 + 56 >> 2], F4 = E3[A8 + 96 >> 2], S4 = E3[A8 + 60 >> 2], N4 = E3[A8 + 100 >> 2], K4 = E3[w4 >> 2], r4 = E3[A8 + 104 >> 2], _4 = E3[A8 + 68 >> 2], p4 = E3[A8 + 108 >> 2], H4 = E3[A8 + 72 >> 2], G4 = E3[A8 + 112 >> 2], f4 = E3[I7 + 80 >> 2], I7 = E3[A8 + 40 >> 2], J4 = E3[A8 + 80 >> 2], C4 = E3[A8 + 76 >> 2], B4 = E3[A8 + 116 >> 2], E3[A8 + 76 >> 2] = C4 + B4, E3[A8 + 72 >> 2] = H4 + G4, E3[A8 + 68 >> 2] = _4 + p4, E3[w4 >> 2] = K4 + r4, E3[A8 + 60 >> 2] = S4 + N4, E3[A8 + 56 >> 2] = s4 + F4, E3[A8 + 52 >> 2] = k4 + n4, E3[A8 + 48 >> 2] = t4 + h4, E3[A8 + 44 >> 2] = g6 + e4, E3[A8 + 40 >> 2] = I7 + J4, E3[A8 + 36 >> 2] = B4 - C4, E3[A8 + 32 >> 2] = G4 - H4, E3[A8 + 28 >> 2] = p4 - _4, E3[A8 + 24 >> 2] = r4 - K4, E3[A8 + 20 >> 2] = N4 - S4, E3[A8 + 16 >> 2] = F4 - s4, E3[A8 + 12 >> 2] = n4 - k4, E3[A8 + 8 >> 2] = h4 - t4, E3[A8 + 4 >> 2] = e4 - g6, E3[A8 >> 2] = J4 - I7, I7 = y4 << 1, g6 = E3[A8 + 156 >> 2], E3[A8 + 156 >> 2] = I7 - g6, w4 = a4 << 1, e4 = E3[A8 + 152 >> 2], E3[A8 + 152 >> 2] = w4 - e4, t4 = D4 << 1, h4 = E3[A8 + 148 >> 2], E3[A8 + 148 >> 2] = t4 - h4, k4 = c4 << 1, n4 = E3[A8 + 144 >> 2], E3[A8 + 144 >> 2] = k4 - n4, s4 = o4 << 1, F4 = E3[A8 + 140 >> 2], E3[A8 + 140 >> 2] = s4 - F4, S4 = i4 << 1, N4 = E3[A8 + 136 >> 2], E3[A8 + 136 >> 2] = S4 - N4, K4 = Q4 << 1, r4 = E3[A8 + 132 >> 2], E3[A8 + 132 >> 2] = K4 - r4, _4 = U4 << 1, p4 = E3[A8 + 128 >> 2], E3[A8 + 128 >> 2] = _4 - p4, H4 = Y4 << 1, G4 = E3[A8 + 124 >> 2], E3[A8 + 124 >> 2] = H4 - G4, J4 = f4 << 1, Y4 = E3[A8 + 120 >> 2], E3[A8 + 120 >> 2] = J4 - Y4, E3[A8 + 112 >> 2] = e4 + w4, E3[A8 + 108 >> 2] = t4 + h4, E3[A8 + 104 >> 2] = k4 + n4, E3[A8 + 100 >> 2] = s4 + F4, E3[A8 + 96 >> 2] = S4 + N4, E3[A8 + 92 >> 2] = K4 + r4, E3[A8 + 88 >> 2] = _4 + p4, E3[A8 + 84 >> 2] = H4 + G4, E3[A8 + 80 >> 2] = J4 + Y4, E3[A8 + 116 >> 2] = I7 + g6; + } + function V(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, r4, h4, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0; + r4 = i3[I7 + 31 | 0], g6 = i3[I7 + 30 | 0], C4 = i3[I7 + 29 | 0], B4 = i3[I7 + 6 | 0], Q4 = i3[I7 + 5 | 0], o4 = i3[I7 + 4 | 0], c4 = i3[I7 + 9 | 0], D4 = i3[I7 + 8 | 0], a4 = i3[I7 + 7 | 0], y4 = i3[I7 + 12 | 0], H4 = i3[I7 + 11 | 0], G4 = i3[I7 + 10 | 0], f4 = i3[I7 + 15 | 0], J4 = i3[I7 + 14 | 0], e4 = i3[I7 + 13 | 0], N4 = i3[I7 + 28 | 0], p4 = i3[I7 + 27 | 0], K4 = i3[I7 + 26 | 0], M4 = i3[I7 + 25 | 0], F4 = i3[I7 + 24 | 0], s4 = i3[I7 + 23 | 0], h4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, S4 = (n4 = i3[I7 + 21 | 0]) << 15, n4 = k4 = n4 >>> 17 | 0, _4 = S4, _4 |= (S4 = i3[I7 + 20 | 0]) << 7, S4 = (k4 = S4 >>> 25 | 0) | n4, n4 = (k4 = i3[I7 + 22 | 0]) >>> 9 | 0, k4 = k4 << 23 | _4, n4 |= S4, w4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, I7 = 0, S4 = k4, k4 = (33554431 & (I7 = (_4 = w4 + 16777216 | 0) >>> 0 < 16777216 ? 1 : I7)) << 7 | _4 >>> 25, I7 = (I7 >>> 25 | 0) + n4 | 0, k4 = (n4 = S4 = S4 + k4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, I7 = (S4 = n4 + 33554432 | 0) >>> 0 < 33554432 ? k4 + 1 | 0 : k4, E3[A8 + 24 >> 2] = n4 - (-67108864 & S4), k4 = (n4 = s4 >>> 27 | 0) | F4 >>> 19 | M4 >>> 11, n4 = s4 = (F4 = M4 << 21 | (s4 = F4 << 13 | s4 << 5)) + (n4 = (67108863 & (n4 = I7)) << 6 | S4 >>> 26) | 0, I7 = k4, k4 = (s4 = F4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 28 >> 2] = n4 - (1040187392 & s4), n4 = (k4 = (I7 = k4) >>> 25 | 0) + (n4 = p4 >>> 20 | K4 >>> 28 | N4 >>> 12) | 0, I7 = n4 = (k4 = s4 = (I7 = (33554431 & I7) << 7 | s4 >>> 25) + (p4 << 12 | K4 << 4 | N4 << 20) | 0) >>> 0 < I7 >>> 0 ? n4 + 1 | 0 : n4, s4 = (N4 = k4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[A8 + 32 >> 2] = k4 - (-67108864 & N4), n4 = y4 >>> 13 | (k4 = H4 >>> 21 | G4 >>> 29), I7 = (n4 = (p4 = 16777216 + (H4 = H4 << 11 | G4 << 3 | y4 << 19) | 0) >>> 0 < 16777216 ? n4 + 1 | 0 : n4) >>> 25 | 0, n4 = (k4 = F4 = J4 << 10 | e4 << 2 | f4 << 18) + (F4 = (33554431 & n4) << 7 | p4 >>> 25) | 0, k4 = I7 + (M4 = J4 >>> 22 | e4 >>> 30 | f4 >>> 14) | 0, I7 = k4 = n4 >>> 0 < F4 >>> 0 ? k4 + 1 | 0 : k4, F4 = ((67108863 & (I7 = (F4 = n4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | (k4 = F4) >>> 26) + (K4 = w4 - (-33554432 & _4) | 0) | 0, E3[A8 + 20 >> 2] = F4, E3[A8 + 16 >> 2] = n4 - (-67108864 & k4), k4 = Q4 >>> 18 | o4 >>> 26 | B4 >>> 10, n4 = (k4 = (K4 = 16777216 + (G4 = Q4 << 14 | o4 << 6 | B4 << 22) | 0) >>> 0 < 16777216 ? k4 + 1 | 0 : k4) >>> 25 | 0, k4 = (I7 = F4 = D4 << 13 | a4 << 5 | c4 << 21) + (F4 = (33554431 & k4) << 7 | K4 >>> 25) | 0, I7 = n4 + (M4 = D4 >>> 19 | a4 >>> 27 | c4 >>> 11) | 0, I7 = k4 >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, n4 = (M4 = k4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[A8 + 8 >> 2] = k4 - (-67108864 & M4), N4 = (s4 = (67108863 & s4) << 6 | N4 >>> 26) + (J4 = r4 << 18 & 33292288 | g6 << 10 | C4 << 2) | 0, I7 = k4 = g6 >>> 22 | C4 >>> 30, k4 = (s4 = J4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 36 >> 2] = N4 - (33554432 & s4), n4 = H4 + ((67108863 & n4) << 6 | M4 >>> 26) | 0, E3[A8 + 12 >> 2] = n4 - (234881024 & p4), F4 = G4 - (2113929216 & K4) | 0, n4 = PA((33554431 & (I7 = k4)) << 7 | s4 >>> 25, k4 = I7 >>> 25 | 0, 19, 0), I7 = t3, n4 = (k4 = n4 + h4 | 0) >>> 0 < n4 >>> 0 ? I7 + 1 | 0 : I7, s4 = ((67108863 & (n4 = (I7 = k4 + 33554432 | 0) >>> 0 < 33554432 ? n4 + 1 | 0 : n4)) << 6 | I7 >>> 26) + F4 | 0, E3[A8 + 4 >> 2] = s4, E3[A8 >> 2] = k4 - (-67108864 & I7); + } + function Z(A8, I7) { + var g6, B4, Q4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0; + for (r3 = g6 = r3 - 480 | 0; a4 = (D4 = g6 + 288 | 0) + (c4 << 1) | 0, y4 = i3[I7 + c4 | 0], C3[a4 + 1 | 0] = y4 >>> 4, C3[0 | a4] = 15 & y4, D4 = D4 + ((a4 = 1 | c4) << 1) | 0, a4 = i3[I7 + a4 | 0], C3[D4 + 1 | 0] = a4 >>> 4, C3[0 | D4] = 15 & a4, 32 != (0 | (c4 = c4 + 2 | 0)); ) ; + for (I7 = 0; c4 = 8 + (D4 = (c4 = I7) + i3[0 | (I7 = (g6 + 288 | 0) + f4 | 0)] | 0) | 0, C3[0 | I7] = D4 - (240 & c4), c4 = 8 + (D4 = i3[I7 + 1 | 0] + (c4 << 24 >> 24 >> 4) | 0) | 0, C3[I7 + 1 | 0] = D4 - (240 & c4), c4 = 8 + (D4 = i3[I7 + 2 | 0] + (c4 << 24 >> 24 >> 4) | 0) | 0, C3[I7 + 2 | 0] = D4 - (240 & c4), I7 = c4 << 24 >> 24 >> 4, 63 != (0 | (f4 = f4 + 3 | 0)); ) ; + for (C3[g6 + 351 | 0] = i3[g6 + 351 | 0] + I7, E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, E3[A8 + 24 >> 2] = 0, E3[A8 + 28 >> 2] = 0, E3[A8 + 16 >> 2] = 0, E3[A8 + 20 >> 2] = 0, E3[A8 + 8 >> 2] = 0, E3[A8 + 12 >> 2] = 0, E3[A8 >> 2] = 0, E3[A8 + 4 >> 2] = 0, E3[A8 + 44 >> 2] = 0, E3[A8 + 48 >> 2] = 0, E3[A8 + 40 >> 2] = 1, E3[A8 + 52 >> 2] = 0, E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, E3[A8 + 64 >> 2] = 0, E3[A8 + 68 >> 2] = 0, E3[A8 + 72 >> 2] = 0, E3[A8 + 76 >> 2] = 0, E3[A8 + 80 >> 2] = 1, VA(A8 + 84 | 0, 0, 76), Q4 = A8 + 120 | 0, f4 = A8 + 80 | 0, I7 = A8 + 40 | 0, D4 = g6 + 208 | 0, B4 = g6 + 168 | 0, a4 = g6 + 248 | 0, c4 = 1; oA(e4 = g6 + 8 | 0, c4 >>> 1 | 0, C3[(g6 + 288 | 0) + c4 | 0]), T(y4 = g6 + 128 | 0, A8, e4), M3(A8, y4, a4), M3(I7, B4, D4), M3(f4, D4, a4), M3(Q4, y4, B4), e4 = c4 >>> 0 < 62, c4 = c4 + 2 | 0, e4; ) ; + for (c4 = E3[A8 + 36 >> 2], E3[g6 + 392 >> 2] = E3[A8 + 32 >> 2], E3[g6 + 396 >> 2] = c4, c4 = E3[A8 + 28 >> 2], E3[g6 + 384 >> 2] = E3[A8 + 24 >> 2], E3[g6 + 388 >> 2] = c4, c4 = E3[A8 + 20 >> 2], E3[g6 + 376 >> 2] = E3[A8 + 16 >> 2], E3[g6 + 380 >> 2] = c4, c4 = E3[A8 + 12 >> 2], E3[g6 + 368 >> 2] = E3[A8 + 8 >> 2], E3[g6 + 372 >> 2] = c4, c4 = E3[A8 + 4 >> 2], E3[g6 + 360 >> 2] = E3[A8 >> 2], E3[g6 + 364 >> 2] = c4, c4 = E3[I7 + 12 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 412 >> 2] = c4, c4 = E3[I7 + 20 >> 2], E3[g6 + 416 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 420 >> 2] = c4, c4 = E3[I7 + 28 >> 2], E3[g6 + 424 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 428 >> 2] = c4, c4 = E3[I7 + 36 >> 2], E3[g6 + 432 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 436 >> 2] = c4, c4 = E3[I7 + 4 >> 2], E3[g6 + 400 >> 2] = E3[I7 >> 2], E3[g6 + 404 >> 2] = c4, c4 = E3[f4 + 12 >> 2], E3[g6 + 448 >> 2] = E3[f4 + 8 >> 2], E3[g6 + 452 >> 2] = c4, c4 = E3[f4 + 20 >> 2], E3[g6 + 456 >> 2] = E3[f4 + 16 >> 2], E3[g6 + 460 >> 2] = c4, c4 = E3[f4 + 28 >> 2], E3[g6 + 464 >> 2] = E3[f4 + 24 >> 2], E3[g6 + 468 >> 2] = c4, c4 = E3[f4 + 36 >> 2], E3[g6 + 472 >> 2] = E3[f4 + 32 >> 2], E3[g6 + 476 >> 2] = c4, c4 = E3[f4 + 4 >> 2], E3[g6 + 440 >> 2] = E3[f4 >> 2], E3[g6 + 444 >> 2] = c4, _3(y4, c4 = g6 + 360 | 0), M3(c4, y4, a4), M3(e4 = g6 + 400 | 0, B4, D4), M3(o4 = g6 + 440 | 0, D4, a4), _3(y4, c4), M3(c4, y4, a4), M3(e4, B4, D4), M3(o4, D4, a4), _3(y4, c4), M3(c4, y4, a4), M3(e4, B4, D4), M3(o4, D4, a4), _3(y4, c4), M3(A8, y4, a4), M3(I7, B4, D4), M3(f4, D4, a4), M3(Q4, y4, B4), c4 = 0; oA(e4 = g6 + 8 | 0, c4 >>> 1 | 0, C3[(g6 + 288 | 0) + c4 | 0]), T(y4 = g6 + 128 | 0, A8, e4), M3(A8, y4, a4), M3(I7, B4, D4), M3(f4, D4, a4), M3(Q4, y4, B4), y4 = c4 >>> 0 < 62, c4 = c4 + 2 | 0, y4; ) ; + r3 = g6 + 480 | 0; + } + function W(A8, I7, g6, B4) { + var Q4, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, s4 = 0; + if (r3 = Q4 = r3 - 704 | 0, g6 | B4) if (o4 = (B4 << 3 | g6 >>> 29) + (c4 = a4 = E3[A8 + 76 >> 2]) | 0, D4 = (f4 = E3[A8 + 72 >> 2]) + (y4 = g6 << 3) | 0, E3[A8 + 72 >> 2] = D4, o4 = D4 >>> 0 < y4 >>> 0 ? o4 + 1 | 0 : o4, E3[A8 + 76 >> 2] = o4, a4 = E3[A8 + 68 >> 2], o4 = (o4 = D4 = (0 | o4) == (0 | c4) & D4 >>> 0 < f4 >>> 0 | o4 >>> 0 < c4 >>> 0) >>> 0 > (D4 = D4 + E3[A8 + 64 >> 2] | 0) >>> 0 ? a4 + 1 | 0 : a4, D4 = (y4 = B4 >>> 29 | 0) + D4 | 0, E3[A8 + 64 >> 2] = D4, E3[A8 + 68 >> 2] = D4 >>> 0 < y4 >>> 0 ? o4 + 1 | 0 : o4, D4 = A8 + 80 | 0, (0 | B4) == (0 | (a4 = k4 = 0 - ((o4 = 0) + ((y4 = 127 & ((7 & c4) << 29 | f4 >>> 3)) >>> 0 > 128) | 0) | 0)) & g6 >>> 0 >= (f4 = 128 - y4 | 0) >>> 0 | B4 >>> 0 > a4 >>> 0) { + if (c4 = 0, a4 = 0, !o4 & (127 ^ y4) >>> 0 >= 3 | o4) for (s4 = 252 & f4; C3[(o4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], C3[D4 + (y4 + (o4 = 1 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (y4 + (o4 = 2 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (y4 + (o4 = 3 | c4) | 0) | 0] = i3[I7 + o4 | 0], o4 = a4, a4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, o4 = t4, t4 = o4 = (e4 = e4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, (0 | e4) != (0 | s4) | (0 | h4) != (0 | o4); ) ; + if (t4 = o4 = 0, o4 | (e4 = 3 & f4)) for (; C3[(o4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], o4 = a4, a4 = (c4 = c4 + 1 | 0) ? o4 : o4 + 1 | 0, o4 = h4, h4 = o4 = (w4 = w4 + 1 | 0) ? o4 : o4 + 1 | 0, (0 | e4) != (0 | w4) | (0 | t4) != (0 | o4); ) ; + if (n3(A8, D4, Q4, c4 = Q4 + 640 | 0), I7 = I7 + f4 | 0, !(B4 = B4 - ((g6 >>> 0 < f4 >>> 0) + k4 | 0) | 0) & (g6 = g6 - f4 | 0) >>> 0 > 127 | B4) for (; n3(A8, I7, Q4, c4), I7 = I7 + 128 | 0, !(B4 = B4 - (g6 >>> 0 < 128) | 0) & (g6 = g6 - 128 | 0) >>> 0 > 127 | B4; ) ; + if (g6 | B4) { + if (A8 = 3 & g6, w4 = 0, h4 = 0, c4 = 0, a4 = 0, !B4 & g6 >>> 0 >= 4 | B4) for (e4 = 124 & g6, f4 = 0, g6 = 0, B4 = 0; C3[c4 + D4 | 0] = i3[I7 + c4 | 0], C3[(o4 = 1 | c4) + D4 | 0] = i3[I7 + o4 | 0], C3[(o4 = 2 | c4) + D4 | 0] = i3[I7 + o4 | 0], C3[(o4 = 3 | c4) + D4 | 0] = i3[I7 + o4 | 0], o4 = a4, a4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, o4 = B4, B4 = o4 = (g6 = g6 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, (0 | g6) != (0 | e4) | (0 | f4) != (0 | o4); ) ; + if (A8 | t4) for (; C3[c4 + D4 | 0] = i3[I7 + c4 | 0], a4 = (c4 = c4 + 1 | 0) ? a4 : a4 + 1 | 0, o4 = h4, h4 = o4 = (w4 = w4 + 1 | 0) ? o4 : o4 + 1 | 0, (0 | A8) != (0 | w4) | (0 | t4) != (0 | o4); ) ; + } + MI(Q4, 704); + } else { + if (c4 = 0, a4 = 0, !B4 & g6 >>> 0 >= 4 | B4) for (A8 = -4 & g6; C3[(o4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], C3[D4 + (f4 = y4 + (o4 = 1 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (f4 = y4 + (o4 = 2 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (f4 = y4 + (o4 = 3 | c4) | 0) | 0] = i3[I7 + o4 | 0], o4 = a4, a4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, o4 = t4, t4 = o4 = (e4 = e4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, (0 | A8) != (0 | e4) | (0 | B4) != (0 | o4); ) ; + if ((g6 &= 3) | (A8 = 0)) for (; C3[(B4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], a4 = (c4 = c4 + 1 | 0) ? a4 : a4 + 1 | 0, o4 = h4, h4 = o4 = (w4 = w4 + 1 | 0) ? o4 : o4 + 1 | 0, (0 | g6) != (0 | w4) | (0 | A8) != (0 | o4); ) ; + } + return r3 = Q4 + 704 | 0, 0; + } + function $(A8, I7, g6) { + var B4 = 0, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0; + for (Q4 = 2036477234, o4 = 857760878, B4 = 1634760805, D4 = 1797285236, E4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, f4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, c4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, e4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, a4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, s4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, w4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, r4 = i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24, t4 = i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24, h4 = i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24, I7 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, g6 = i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24; y4 = g6, g6 = gI((k4 = I7) ^ (I7 = g6 + B4 | 0), 16), y4 = w4 = gI(y4 ^ (B4 = g6 + w4 | 0), 12), F4 = gI((k4 = I7 + w4 | 0) ^ g6, 8), I7 = gI(y4 ^ (w4 = F4 + B4 | 0), 7), B4 = r4, r4 = gI((g6 = D4 + r4 | 0) ^ E4, 16), B4 = gI(B4 ^ (e4 = r4 + e4 | 0), 12), E4 = t4, D4 = gI((Q4 = Q4 + t4 | 0) ^ f4, 16), E4 = gI(E4 ^ (t4 = D4 + a4 | 0), 12), a4 = gI((Q4 = E4 + Q4 | 0) ^ D4, 8), g6 = gI(a4 ^ (D4 = I7 + (n4 = g6 + B4 | 0) | 0), 16), f4 = gI((o4 = o4 + h4 | 0) ^ c4, 16), h4 = gI((c4 = f4 + s4 | 0) ^ h4, 12), y4 = I7, I7 = gI((o4 = o4 + h4 | 0) ^ f4, 8), y4 = gI(y4 ^ (c4 = g6 + (S4 = I7 + c4 | 0) | 0), 12), f4 = gI(g6 ^ (D4 = y4 + D4 | 0), 8), g6 = gI((s4 = f4 + c4 | 0) ^ y4, 7), y4 = Q4, Q4 = B4, n4 = gI(r4 ^ n4, 8), Q4 = gI(Q4 ^ (B4 = n4 + e4 | 0), 7), r4 = gI((c4 = y4 + Q4 | 0) ^ I7, 16), e4 = gI((I7 = r4 + w4 | 0) ^ Q4, 12), c4 = gI(r4 ^ (Q4 = e4 + c4 | 0), 8), r4 = gI((w4 = I7 + c4 | 0) ^ e4, 7), I7 = gI((I7 = E4) ^ (E4 = a4 + t4 | 0), 7), t4 = gI((o4 = I7 + o4 | 0) ^ F4, 16), a4 = gI(I7 ^ (B4 = t4 + B4 | 0), 12), I7 = gI(t4 ^ (o4 = a4 + o4 | 0), 8), t4 = gI((e4 = B4 + I7 | 0) ^ a4, 7), y4 = E4, B4 = gI(h4 ^ S4, 7), a4 = gI((E4 = B4 + k4 | 0) ^ n4, 16), k4 = gI(B4 ^ (h4 = y4 + a4 | 0), 12), E4 = gI(a4 ^ (B4 = k4 + E4 | 0), 8), h4 = gI((a4 = h4 + E4 | 0) ^ k4, 7), 10 != (0 | (M4 = M4 + 1 | 0)); ) ; + C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = E4, C3[A8 + 29 | 0] = E4 >>> 8, C3[A8 + 30 | 0] = E4 >>> 16, C3[A8 + 31 | 0] = E4 >>> 24, C3[A8 + 24 | 0] = f4, C3[A8 + 25 | 0] = f4 >>> 8, C3[A8 + 26 | 0] = f4 >>> 16, C3[A8 + 27 | 0] = f4 >>> 24, C3[A8 + 20 | 0] = c4, C3[A8 + 21 | 0] = c4 >>> 8, C3[A8 + 22 | 0] = c4 >>> 16, C3[A8 + 23 | 0] = c4 >>> 24, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, C3[A8 + 12 | 0] = D4, C3[A8 + 13 | 0] = D4 >>> 8, C3[A8 + 14 | 0] = D4 >>> 16, C3[A8 + 15 | 0] = D4 >>> 24, C3[A8 + 8 | 0] = Q4, C3[A8 + 9 | 0] = Q4 >>> 8, C3[A8 + 10 | 0] = Q4 >>> 16, C3[A8 + 11 | 0] = Q4 >>> 24, C3[A8 + 4 | 0] = o4, C3[A8 + 5 | 0] = o4 >>> 8, C3[A8 + 6 | 0] = o4 >>> 16, C3[A8 + 7 | 0] = o4 >>> 24; + } + function AA(A8, I7, g6) { + var B4 = 0, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0; + for (B4 = 1797285236, a4 = 2036477234, y4 = 857760878, Q4 = 1634760805, E4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, c4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, o4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, k4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, h4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, n4 = 20, r4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, t4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, f4 = i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24, e4 = i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24, w4 = i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24, I7 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, g6 = i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24; D4 = gI(g6 + y4 | 0, 7) ^ E4, s4 = gI(D4 + y4 | 0, 9) ^ h4, f4 = gI(Q4 + r4 | 0, 7) ^ f4, F4 = gI(f4 + Q4 | 0, 9) ^ c4, S4 = gI(F4 + f4 | 0, 13) ^ r4, e4 = gI(B4 + t4 | 0, 7) ^ e4, o4 = gI(e4 + B4 | 0, 9) ^ o4, c4 = gI(o4 + e4 | 0, 13) ^ t4, B4 = gI(o4 + c4 | 0, 18) ^ B4, E4 = gI(I7 + a4 | 0, 7) ^ k4, r4 = S4 ^ gI(B4 + E4 | 0, 7), h4 = s4 ^ gI(r4 + B4 | 0, 9), k4 = gI(r4 + h4 | 0, 13) ^ E4, B4 = gI(h4 + k4 | 0, 18) ^ B4, w4 = gI(E4 + a4 | 0, 9) ^ w4, M4 = gI(w4 + E4 | 0, 13) ^ I7, I7 = gI(M4 + w4 | 0, 18) ^ a4, t4 = gI(I7 + D4 | 0, 7) ^ c4, c4 = gI(t4 + I7 | 0, 9) ^ F4, E4 = gI(c4 + t4 | 0, 13) ^ D4, a4 = gI(E4 + c4 | 0, 18) ^ I7, D4 = gI(D4 + s4 | 0, 13) ^ g6, g6 = gI(D4 + s4 | 0, 18) ^ y4, I7 = gI(g6 + f4 | 0, 7) ^ M4, o4 = gI(I7 + g6 | 0, 9) ^ o4, f4 = gI(I7 + o4 | 0, 13) ^ f4, y4 = gI(o4 + f4 | 0, 18) ^ g6, Q4 = gI(F4 + S4 | 0, 18) ^ Q4, g6 = gI(Q4 + e4 | 0, 7) ^ D4, w4 = gI(g6 + Q4 | 0, 9) ^ w4, e4 = gI(g6 + w4 | 0, 13) ^ e4, Q4 = gI(w4 + e4 | 0, 18) ^ Q4, D4 = n4 >>> 0 > 2, n4 = n4 - 2 | 0, D4; ) ; + return C3[0 | A8] = Q4, C3[A8 + 1 | 0] = Q4 >>> 8, C3[A8 + 2 | 0] = Q4 >>> 16, C3[A8 + 3 | 0] = Q4 >>> 24, C3[A8 + 28 | 0] = E4, C3[A8 + 29 | 0] = E4 >>> 8, C3[A8 + 30 | 0] = E4 >>> 16, C3[A8 + 31 | 0] = E4 >>> 24, C3[A8 + 24 | 0] = c4, C3[A8 + 25 | 0] = c4 >>> 8, C3[A8 + 26 | 0] = c4 >>> 16, C3[A8 + 27 | 0] = c4 >>> 24, C3[A8 + 20 | 0] = o4, C3[A8 + 21 | 0] = o4 >>> 8, C3[A8 + 22 | 0] = o4 >>> 16, C3[A8 + 23 | 0] = o4 >>> 24, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, C3[A8 + 12 | 0] = B4, C3[A8 + 13 | 0] = B4 >>> 8, C3[A8 + 14 | 0] = B4 >>> 16, C3[A8 + 15 | 0] = B4 >>> 24, C3[A8 + 8 | 0] = a4, C3[A8 + 9 | 0] = a4 >>> 8, C3[A8 + 10 | 0] = a4 >>> 16, C3[A8 + 11 | 0] = a4 >>> 24, C3[A8 + 4 | 0] = y4, C3[A8 + 5 | 0] = y4 >>> 8, C3[A8 + 6 | 0] = y4 >>> 16, C3[A8 + 7 | 0] = y4 >>> 24, 0; + } + function IA(A8, I7) { + var g6, B4, Q4 = 0, i4 = 0, o4 = 0, c4 = 0; + r3 = g6 = r3 - 288 | 0, i4 = 40 + ((Q4 = E3[A8 + 32 >> 2] >>> 3 & 63) + A8 | 0) | 0, Q4 >>> 0 >= 56 ? (TA(i4, 35040, 64 - Q4 | 0), p3(A8, A8 + 40 | 0, g6, g6 + 256 | 0), E3[A8 + 88 >> 2] = 0, E3[A8 + 92 >> 2] = 0, E3[A8 + 80 >> 2] = 0, E3[A8 + 84 >> 2] = 0, E3[A8 + 72 >> 2] = 0, E3[A8 + 76 >> 2] = 0, E3[(Q4 = A8 - -64 | 0) >> 2] = 0, E3[Q4 + 4 >> 2] = 0, E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, E3[A8 + 48 >> 2] = 0, E3[A8 + 52 >> 2] = 0, E3[A8 + 40 >> 2] = 0, E3[A8 + 44 >> 2] = 0) : TA(i4, 35040, 56 - Q4 | 0), o4 = (Q4 = 16711680 & (i4 = E3[A8 + 32 >> 2])) >>> 8 | 0, c4 = Q4 << 24, B4 = (Q4 = -16777216 & i4) >>> 24 | 0, Q4 = (c4 |= Q4 << 8) | -16777216 & ((255 & (Q4 = E3[A8 + 36 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & Q4) << 8 | i4 >>> 24) | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[A8 + 96 | 0] = Q4, C3[A8 + 97 | 0] = Q4 >>> 8, C3[A8 + 98 | 0] = Q4 >>> 16, C3[A8 + 99 | 0] = Q4 >>> 24, Q4 = o4 | B4 | i4 << 24 | (65280 & i4) << 8, Q4 |= o4 = 0, C3[A8 + 100 | 0] = Q4, C3[A8 + 101 | 0] = Q4 >>> 8, C3[A8 + 102 | 0] = Q4 >>> 16, C3[A8 + 103 | 0] = Q4 >>> 24, p3(A8, A8 + 40 | 0, g6, g6 + 256 | 0), Q4 = (Q4 = E3[A8 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[0 | I7] = Q4, C3[I7 + 1 | 0] = Q4 >>> 8, C3[I7 + 2 | 0] = Q4 >>> 16, C3[I7 + 3 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 4 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 4 | 0] = Q4, C3[I7 + 5 | 0] = Q4 >>> 8, C3[I7 + 6 | 0] = Q4 >>> 16, C3[I7 + 7 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 8 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 8 | 0] = Q4, C3[I7 + 9 | 0] = Q4 >>> 8, C3[I7 + 10 | 0] = Q4 >>> 16, C3[I7 + 11 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 12 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 12 | 0] = Q4, C3[I7 + 13 | 0] = Q4 >>> 8, C3[I7 + 14 | 0] = Q4 >>> 16, C3[I7 + 15 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 16 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 16 | 0] = Q4, C3[I7 + 17 | 0] = Q4 >>> 8, C3[I7 + 18 | 0] = Q4 >>> 16, C3[I7 + 19 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 20 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 20 | 0] = Q4, C3[I7 + 21 | 0] = Q4 >>> 8, C3[I7 + 22 | 0] = Q4 >>> 16, C3[I7 + 23 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 24 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 24 | 0] = Q4, C3[I7 + 25 | 0] = Q4 >>> 8, C3[I7 + 26 | 0] = Q4 >>> 16, C3[I7 + 27 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 28 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 28 | 0] = Q4, C3[I7 + 29 | 0] = Q4 >>> 8, C3[I7 + 30 | 0] = Q4 >>> 16, C3[I7 + 31 | 0] = Q4 >>> 24, MI(g6, 288), MI(A8, 104), r3 = g6 + 288 | 0; + } + function gA(A8, I7, g6) { + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0; + if (r3 = B4 = r3 - 96 | 0, g6 >>> 0 >= 65 && (RA(A8), BA(A8, I7, g6), IA(A8, B4), g6 = 32, I7 = B4), RA(A8), E3[B4 + 88 >> 2] = 909522486, E3[B4 + 92 >> 2] = 909522486, E3[B4 + 80 >> 2] = 909522486, E3[B4 + 84 >> 2] = 909522486, E3[B4 + 72 >> 2] = 909522486, E3[B4 + 76 >> 2] = 909522486, E3[(c4 = f4 = B4 - -64 | 0) >> 2] = 909522486, E3[c4 + 4 >> 2] = 909522486, E3[B4 + 56 >> 2] = 909522486, E3[B4 + 60 >> 2] = 909522486, E3[B4 + 48 >> 2] = 909522486, E3[B4 + 52 >> 2] = 909522486, E3[B4 + 40 >> 2] = 909522486, E3[B4 + 44 >> 2] = 909522486, E3[B4 + 32 >> 2] = 909522486, E3[B4 + 36 >> 2] = 909522486, g6) { + if (g6 >>> 0 >= 4) for (D4 = 124 & g6; C3[0 | (o4 = (c4 = B4 + 32 | 0) + Q4 | 0)] = i3[0 | o4] ^ i3[I7 + Q4 | 0], C3[0 | (e4 = (o4 = 1 | Q4) + c4 | 0)] = i3[0 | e4] ^ i3[I7 + o4 | 0], C3[0 | (e4 = (o4 = 2 | Q4) + c4 | 0)] = i3[0 | e4] ^ i3[I7 + o4 | 0], C3[0 | (o4 = (o4 = c4) + (c4 = 3 | Q4) | 0)] = i3[0 | o4] ^ i3[I7 + c4 | 0], Q4 = Q4 + 4 | 0, (0 | D4) != (0 | (a4 = a4 + 4 | 0)); ) ; + if (a4 = 3 & g6) for (; C3[0 | (c4 = (B4 + 32 | 0) + Q4 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], Q4 = Q4 + 1 | 0, (0 | a4) != (0 | (y4 = y4 + 1 | 0)); ) ; + } + if (BA(A8, B4 + 32 | 0, 64), RA(c4 = A8 + 104 | 0), E3[B4 + 88 >> 2] = 1549556828, E3[B4 + 92 >> 2] = 1549556828, E3[B4 + 80 >> 2] = 1549556828, E3[B4 + 84 >> 2] = 1549556828, E3[B4 + 72 >> 2] = 1549556828, E3[B4 + 76 >> 2] = 1549556828, E3[f4 >> 2] = 1549556828, E3[f4 + 4 >> 2] = 1549556828, E3[B4 + 56 >> 2] = 1549556828, E3[B4 + 60 >> 2] = 1549556828, E3[B4 + 48 >> 2] = 1549556828, E3[B4 + 52 >> 2] = 1549556828, E3[B4 + 40 >> 2] = 1549556828, E3[B4 + 44 >> 2] = 1549556828, E3[B4 + 32 >> 2] = 1549556828, E3[B4 + 36 >> 2] = 1549556828, g6) { + if (y4 = 0, Q4 = 0, g6 >>> 0 >= 4) for (f4 = 124 & g6, a4 = 0; C3[0 | (D4 = (A8 = B4 + 32 | 0) + Q4 | 0)] = i3[0 | D4] ^ i3[I7 + Q4 | 0], C3[0 | (o4 = (D4 = 1 | Q4) + A8 | 0)] = i3[0 | o4] ^ i3[I7 + D4 | 0], C3[0 | (o4 = (D4 = 2 | Q4) + A8 | 0)] = i3[0 | o4] ^ i3[I7 + D4 | 0], C3[0 | (D4 = (o4 = A8) + (A8 = 3 | Q4) | 0)] = i3[0 | D4] ^ i3[A8 + I7 | 0], Q4 = Q4 + 4 | 0, (0 | f4) != (0 | (a4 = a4 + 4 | 0)); ) ; + if (A8 = 3 & g6) for (; C3[0 | (g6 = (B4 + 32 | 0) + Q4 | 0)] = i3[0 | g6] ^ i3[I7 + Q4 | 0], Q4 = Q4 + 1 | 0, (0 | A8) != (0 | (y4 = y4 + 1 | 0)); ) ; + } + return BA(c4, A8 = B4 + 32 | 0, 64), MI(A8, 64), MI(B4, 32), r3 = B4 + 96 | 0, 0; + } + function CA(A8, I7, g6, C4, B4, i4, o4) { + var c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0; + if (I7 - 65 >>> 0 < 4294967232 | o4 >>> 0 > 64) A8 = -1; + else { + e4 = c4 = r3, r3 = c4 = c4 - 512 & -64; + A: { + I: if (!(!(!(C4 | B4) | g6) | !A8 | ((D4 = 255 & I7) - 65 & 255) >>> 0 <= 191 | !(!(I7 = 255 & o4) || i4) | I7 >>> 0 >= 65)) { + if (I7) { + if (!i4) break I; + VA(c4 - -64 | 0, 0, 293), E3[c4 + 56 >> 2] = 327033209, E3[c4 + 60 >> 2] = 1541459225, E3[c4 + 48 >> 2] = -79577749, E3[c4 + 52 >> 2] = 528734635, E3[c4 + 40 >> 2] = 725511199, E3[c4 + 44 >> 2] = -1694144372, E3[c4 + 32 >> 2] = -1377402159, E3[c4 + 36 >> 2] = 1359893119, E3[c4 + 24 >> 2] = 1595750129, E3[c4 + 28 >> 2] = -1521486534, E3[c4 + 16 >> 2] = -23791573, E3[c4 + 20 >> 2] = 1013904242, E3[c4 + 8 >> 2] = -2067093701, E3[c4 + 12 >> 2] = -1150833019, E3[c4 >> 2] = -222443256 ^ (I7 << 8 | D4), E3[c4 + 4 >> 2] = I7 >>> 24 ^ 1779033703, VA((o4 = c4 + 384 | 0) + I7 | 0, 0, 128 - I7 | 0), TA(o4, i4, I7), TA(c4 + 96 | 0, o4, 128), E3[c4 + 352 >> 2] = 128, MI(o4, 128), I7 = 128; + } else VA(c4 - -64 | 0, 0, 293), E3[c4 + 56 >> 2] = 327033209, E3[c4 + 60 >> 2] = 1541459225, E3[c4 + 48 >> 2] = -79577749, E3[c4 + 52 >> 2] = 528734635, E3[c4 + 40 >> 2] = 725511199, E3[c4 + 44 >> 2] = -1694144372, E3[c4 + 32 >> 2] = -1377402159, E3[c4 + 36 >> 2] = 1359893119, E3[c4 + 24 >> 2] = 1595750129, E3[c4 + 28 >> 2] = -1521486534, E3[c4 + 16 >> 2] = -23791573, E3[c4 + 20 >> 2] = 1013904242, E3[c4 + 8 >> 2] = -2067093701, E3[c4 + 12 >> 2] = -1150833019, E3[c4 >> 2] = -222443256 ^ D4, E3[c4 + 4 >> 2] = 1779033703, I7 = 0; + g: if (C4 | B4) for (w4 = c4 + 224 | 0, a4 = c4 + 96 | 0; ; ) { + if (o4 = I7 + a4 | 0, !B4 & C4 >>> 0 <= (i4 = 256 - I7 | 0) >>> 0) { + TA(o4, g6, C4), E3[c4 + 352 >> 2] = C4 + E3[c4 + 352 >> 2]; + break g; + } + if (TA(o4, g6, i4), E3[c4 + 352 >> 2] = i4 + E3[c4 + 352 >> 2], y4 = I7 = E3[c4 + 68 >> 2], I7 = (f4 = (o4 = E3[c4 + 64 >> 2]) + 128 | 0) >>> 0 < 128 ? I7 + 1 | 0 : I7, E3[c4 + 64 >> 2] = f4, E3[c4 + 68 >> 2] = I7, I7 = E3[c4 + 76 >> 2], I7 = (y4 = o4 = -1 == (0 | y4) & o4 >>> 0 > 4294967167) >>> 0 > (o4 = o4 + E3[c4 + 72 >> 2] | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[c4 + 72 >> 2] = o4, E3[c4 + 76 >> 2] = I7, h3(c4, a4), TA(a4, w4, 128), I7 = E3[c4 + 352 >> 2] - 128 | 0, E3[c4 + 352 >> 2] = I7, g6 = g6 + i4 | 0, !((B4 = B4 - (C4 >>> 0 < i4 >>> 0) | 0) | (C4 = C4 - i4 | 0))) break; + } + m3(c4, A8, D4), r3 = e4; + break A; + } + iI(), Q3(); + } + A8 = 0; + } + return A8; + } + function BA(A8, I7, g6) { + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0; + if (r3 = B4 = r3 - 288 | 0, g6) if (Q4 = E3[A8 + 36 >> 2], y4 = (D4 = E3[A8 + 32 >> 2]) + (a4 = g6 << 3) | 0, E3[A8 + 32 >> 2] = y4, c4 = (g6 >>> 29 | 0) + Q4 | 0, E3[A8 + 36 >> 2] = a4 >>> 0 > y4 >>> 0 ? c4 + 1 | 0 : c4, a4 = A8 + 40 | 0, true & (c4 = 64 - (y4 = 63 & ((7 & Q4) << 29 | D4 >>> 3)) | 0) >>> 0 <= g6 >>> 0) { + if (Q4 = 0, D4 = 0, (63 ^ y4) >>> 0 >= 3) for (h4 = 124 & c4; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], C3[(y4 + (w4 = 1 | Q4) | 0) + a4 | 0] = i3[I7 + w4 | 0], C3[(y4 + (w4 = 2 | Q4) | 0) + a4 | 0] = i3[I7 + w4 | 0], C3[(y4 + (w4 = 3 | Q4) | 0) + a4 | 0] = i3[I7 + w4 | 0], D4 = (Q4 = Q4 + 4 | 0) >>> 0 < 4 ? D4 + 1 | 0 : D4, (o4 = (t4 = t4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4) | (0 | t4) != (0 | h4); ) ; + if (o4 = 3 & c4) for (; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], D4 = (Q4 = Q4 + 1 | 0) ? D4 : D4 + 1 | 0, (f4 = (e4 = e4 + 1 | 0) ? f4 : f4 + 1 | 0) | (0 | o4) != (0 | e4); ) ; + if (p3(A8, a4, B4, f4 = B4 + 256 | 0), I7 = I7 + c4 | 0, !(o4 = 0 - ((g6 >>> 0 < c4 >>> 0) + 0 | 0) | 0) & (g6 = g6 - c4 | 0) >>> 0 > 63 | o4) for (; p3(A8, I7, B4, f4), I7 = I7 - -64 | 0, o4 = o4 - 1 | 0, !(o4 = (g6 = g6 + -64 | 0) >>> 0 < 4294967232 ? o4 + 1 | 0 : o4) & g6 >>> 0 > 63 | o4; ) ; + if (g6 | o4) { + if (A8 = 3 & g6, e4 = 0, f4 = 0, Q4 = 0, D4 = 0, !o4 & g6 >>> 0 >= 4 | o4) for (y4 = 60 & g6, g6 = 0, o4 = 0; C3[Q4 + a4 | 0] = i3[I7 + Q4 | 0], C3[(c4 = 1 | Q4) + a4 | 0] = i3[I7 + c4 | 0], C3[(c4 = 2 | Q4) + a4 | 0] = i3[I7 + c4 | 0], C3[(c4 = 3 | Q4) + a4 | 0] = i3[I7 + c4 | 0], D4 = (Q4 = Q4 + 4 | 0) >>> 0 < 4 ? D4 + 1 | 0 : D4, (o4 = (g6 = g6 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4) | (0 | g6) != (0 | y4); ) ; + if (A8) for (; C3[Q4 + a4 | 0] = i3[I7 + Q4 | 0], D4 = (Q4 = Q4 + 1 | 0) ? D4 : D4 + 1 | 0, (f4 = (e4 = e4 + 1 | 0) ? f4 : f4 + 1 | 0) | (0 | A8) != (0 | e4); ) ; + } + MI(B4, 288); + } else { + if (Q4 = 0, D4 = 0, g6 >>> 0 >= 4) for (A8 = -4 & g6; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], C3[(y4 + (c4 = 1 | Q4) | 0) + a4 | 0] = i3[I7 + c4 | 0], C3[(y4 + (c4 = 2 | Q4) | 0) + a4 | 0] = i3[I7 + c4 | 0], C3[(y4 + (c4 = 3 | Q4) | 0) + a4 | 0] = i3[I7 + c4 | 0], D4 = (Q4 = Q4 + 4 | 0) >>> 0 < 4 ? D4 + 1 | 0 : D4, (o4 = (t4 = t4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4) | (0 | A8) != (0 | t4); ) ; + if (A8 = 3 & g6) for (; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], D4 = (Q4 = Q4 + 1 | 0) ? D4 : D4 + 1 | 0, (f4 = (e4 = e4 + 1 | 0) ? f4 : f4 + 1 | 0) | (0 | A8) != (0 | e4); ) ; + } + r3 = B4 + 288 | 0; + } + function QA(A8, I7, g6, B4) { + var Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0; + A: { + if ((o4 = E3[A8 + 56 >> 2]) | (Q4 = E3[A8 + 60 >> 2])) { + if (e4 = D4 = 16 - o4 | 0, y4 = (D4 = (0 | (c4 = 0 - ((o4 >>> 0 > 16) + Q4 | 0) | 0)) == (0 | B4) & g6 >>> 0 > D4 >>> 0 | B4 >>> 0 > c4 >>> 0) ? e4 : g6, e4 = D4 = D4 ? c4 : B4, D4 | y4) { + if (D4 = A8 - -64 | 0, c4 = 0, o4 = 0, !e4 & y4 >>> 0 >= 4 | e4) for (f4 = -4 & y4; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], Q4 = (w4 = 1 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + w4 | 0], Q4 = (w4 = 2 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + w4 | 0], Q4 = (w4 = 3 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + w4 | 0], Q4 = o4, o4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? Q4 + 1 | 0 : Q4, Q4 = t4, t4 = Q4 = (a4 = a4 + 4 | 0) >>> 0 < 4 ? Q4 + 1 | 0 : Q4, (0 | a4) != (0 | f4) | (0 | e4) != (0 | Q4); ) ; + if (t4 = Q4 = 0, Q4 | (a4 = 3 & y4)) for (; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], o4 = (c4 = c4 + 1 | 0) ? o4 : o4 + 1 | 0, Q4 = h4, h4 = Q4 = (r4 = r4 + 1 | 0) ? Q4 : Q4 + 1 | 0, (0 | a4) != (0 | r4) | (0 | t4) != (0 | Q4); ) ; + o4 = E3[A8 + 56 >> 2], Q4 = E3[A8 + 60 >> 2]; + } + if (Q4 = Q4 + e4 | 0, Q4 = (o4 = o4 + y4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, E3[A8 + 56 >> 2] = o4, E3[A8 + 60 >> 2] = Q4, !Q4 & o4 >>> 0 < 16) break A; + z(A8, A8 - -64 | 0, 16, 0), E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, g6 = (o4 = g6) - y4 | 0, B4 = B4 - ((o4 >>> 0 < y4 >>> 0) + e4 | 0) | 0, I7 = I7 + y4 | 0; + } + if (!B4 & g6 >>> 0 >= 16 | B4 && (z(A8, I7, o4 = -16 & g6, B4), g6 &= 15, B4 = 0, I7 = I7 + o4 | 0), g6 | B4) { + if (D4 = A8 - -64 | 0, r4 = 0, h4 = 0, c4 = 0, o4 = 0, !B4 & g6 >>> 0 >= 4 | B4) for (y4 = 12 & g6, e4 = 0, a4 = 0; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], Q4 = (f4 = 1 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + f4 | 0], Q4 = (f4 = 2 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + f4 | 0], Q4 = (f4 = 3 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + f4 | 0], o4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, Q4 = t4, t4 = Q4 = (a4 = a4 + 4 | 0) >>> 0 < 4 ? Q4 + 1 | 0 : Q4, (0 | y4) != (0 | a4) | (0 | e4) != (0 | Q4); ) ; + if (t4 = Q4 = 0, Q4 | (a4 = 3 & g6)) for (; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], o4 = (c4 = c4 + 1 | 0) ? o4 : o4 + 1 | 0, Q4 = h4, h4 = Q4 = (r4 = r4 + 1 | 0) ? Q4 : Q4 + 1 | 0, (0 | a4) != (0 | r4) | (0 | t4) != (0 | Q4); ) ; + o4 = B4 + E3[A8 + 60 >> 2] | 0, o4 = (I7 = g6 + E3[A8 + 56 >> 2] | 0) >>> 0 < g6 >>> 0 ? o4 + 1 | 0 : o4, E3[A8 + 56 >> 2] = I7, E3[A8 + 60 >> 2] = o4; + } + } + } + function EA(A8, I7, g6) { + var C4, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0; + r4 = E3[I7 + 4 >> 2], B4 = E3[A8 + 4 >> 2], t4 = E3[I7 + 8 >> 2], Q4 = E3[A8 + 8 >> 2], h4 = E3[I7 + 12 >> 2], i4 = E3[A8 + 12 >> 2], k4 = E3[I7 + 16 >> 2], o4 = E3[A8 + 16 >> 2], n4 = E3[I7 + 20 >> 2], c4 = E3[A8 + 20 >> 2], e4 = E3[I7 + 24 >> 2], D4 = E3[A8 + 24 >> 2], s4 = E3[I7 + 28 >> 2], a4 = E3[A8 + 28 >> 2], F4 = E3[I7 + 32 >> 2], y4 = E3[A8 + 32 >> 2], S4 = E3[I7 + 36 >> 2], f4 = E3[A8 + 36 >> 2], g6 = 0 - g6 | 0, w4 = E3[A8 >> 2], E3[A8 >> 2] = g6 & (w4 ^ E3[I7 >> 2]) ^ w4, E3[A8 + 36 >> 2] = f4 ^ g6 & (f4 ^ S4), E3[A8 + 32 >> 2] = y4 ^ g6 & (y4 ^ F4), E3[A8 + 28 >> 2] = a4 ^ g6 & (a4 ^ s4), E3[A8 + 24 >> 2] = D4 ^ g6 & (D4 ^ e4), E3[A8 + 20 >> 2] = c4 ^ g6 & (c4 ^ n4), E3[A8 + 16 >> 2] = o4 ^ g6 & (o4 ^ k4), E3[A8 + 12 >> 2] = i4 ^ g6 & (i4 ^ h4), E3[A8 + 8 >> 2] = Q4 ^ g6 & (Q4 ^ t4), E3[A8 + 4 >> 2] = B4 ^ g6 & (B4 ^ r4), B4 = E3[A8 + 44 >> 2], r4 = E3[I7 + 44 >> 2], Q4 = E3[A8 + 48 >> 2], t4 = E3[I7 + 48 >> 2], i4 = E3[A8 + 52 >> 2], h4 = E3[I7 + 52 >> 2], o4 = E3[A8 + 56 >> 2], k4 = E3[I7 + 56 >> 2], c4 = E3[A8 + 60 >> 2], n4 = E3[I7 + 60 >> 2], D4 = E3[(e4 = A8 - -64 | 0) >> 2], s4 = E3[I7 - -64 >> 2], a4 = E3[A8 + 68 >> 2], F4 = E3[I7 + 68 >> 2], y4 = E3[A8 + 72 >> 2], S4 = E3[I7 + 72 >> 2], f4 = E3[A8 + 40 >> 2], w4 = E3[I7 + 40 >> 2], C4 = E3[A8 + 76 >> 2], E3[A8 + 76 >> 2] = C4 ^ g6 & (E3[I7 + 76 >> 2] ^ C4), E3[A8 + 72 >> 2] = y4 ^ g6 & (y4 ^ S4), E3[A8 + 68 >> 2] = a4 ^ g6 & (a4 ^ F4), E3[e4 >> 2] = D4 ^ g6 & (D4 ^ s4), E3[A8 + 60 >> 2] = c4 ^ g6 & (c4 ^ n4), E3[A8 + 56 >> 2] = o4 ^ g6 & (o4 ^ k4), E3[A8 + 52 >> 2] = i4 ^ g6 & (i4 ^ h4), E3[A8 + 48 >> 2] = Q4 ^ g6 & (Q4 ^ t4), E3[A8 + 44 >> 2] = B4 ^ g6 & (B4 ^ r4), E3[A8 + 40 >> 2] = f4 ^ g6 & (f4 ^ w4), B4 = E3[A8 + 84 >> 2], r4 = E3[I7 + 84 >> 2], Q4 = E3[A8 + 88 >> 2], t4 = E3[I7 + 88 >> 2], i4 = E3[A8 + 92 >> 2], h4 = E3[I7 + 92 >> 2], o4 = E3[A8 + 96 >> 2], k4 = E3[I7 + 96 >> 2], c4 = E3[A8 + 100 >> 2], n4 = E3[I7 + 100 >> 2], D4 = E3[A8 + 104 >> 2], e4 = E3[I7 + 104 >> 2], a4 = E3[A8 + 108 >> 2], s4 = E3[I7 + 108 >> 2], y4 = E3[A8 + 112 >> 2], F4 = E3[I7 + 112 >> 2], f4 = E3[A8 + 80 >> 2], S4 = E3[I7 + 80 >> 2], w4 = E3[I7 + 116 >> 2], I7 = E3[A8 + 116 >> 2], E3[A8 + 116 >> 2] = g6 & (w4 ^ I7) ^ I7, E3[A8 + 112 >> 2] = y4 ^ g6 & (y4 ^ F4), E3[A8 + 108 >> 2] = a4 ^ g6 & (a4 ^ s4), E3[A8 + 104 >> 2] = D4 ^ g6 & (D4 ^ e4), E3[A8 + 100 >> 2] = c4 ^ g6 & (c4 ^ n4), E3[A8 + 96 >> 2] = o4 ^ g6 & (o4 ^ k4), E3[A8 + 92 >> 2] = i4 ^ g6 & (i4 ^ h4), E3[A8 + 88 >> 2] = Q4 ^ g6 & (Q4 ^ t4), E3[A8 + 84 >> 2] = B4 ^ g6 & (B4 ^ r4), E3[A8 + 80 >> 2] = f4 ^ g6 & (f4 ^ S4); + } + function iA(A8, I7) { + var g6, C4, B4 = 0; + for (r3 = g6 = r3 - 192 | 0, U3(C4 = g6 + 144 | 0, I7), U3(B4 = g6 + 96 | 0, C4), U3(B4, B4), M3(B4, I7, B4), M3(C4, C4, B4), U3(I7 = g6 + 48 | 0, C4), M3(B4, B4, I7), U3(I7, B4), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(B4, I7, B4), U3(I7, B4), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(I7, I7, B4), U3(g6, I7), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), M3(I7, g6, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(B4, I7, B4), U3(I7, B4), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(I7, I7, B4), U3(g6, I7), I7 = 1; U3(g6, g6), 100 != (0 | (I7 = I7 + 1 | 0)); ) ; + M3(I7 = g6 + 48 | 0, g6, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(B4 = g6 + 96 | 0, I7, B4), U3(B4, B4), U3(B4, B4), U3(B4, B4), U3(B4, B4), U3(B4, B4), M3(A8, B4, g6 + 144 | 0), r3 = g6 + 192 | 0; + } + function oA(A8, I7, g6) { + var C4, B4, Q4, i4, o4, D4, a4, y4, f4 = 0; + r3 = C4 = r3 - 128 | 0, E3[A8 >> 2] = 1, E3[A8 + 4 >> 2] = 0, E3[A8 + 8 >> 2] = 0, E3[A8 + 12 >> 2] = 0, E3[A8 + 16 >> 2] = 0, E3[A8 + 20 >> 2] = 0, E3[A8 + 24 >> 2] = 0, E3[A8 + 28 >> 2] = 0, E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, E3[A8 + 40 >> 2] = 1, VA(A8 + 44 | 0, 0, 76), EA(A8, I7 = c3(I7, 960) + 2688 | 0, (255 & (1 ^ (f4 = g6 - ((g6 >> 31 & g6) << 1) | 0))) - 1 >>> 31 | 0), EA(A8, I7 + 120 | 0, (255 & (2 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 240 | 0, (255 & (3 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 360 | 0, (255 & (4 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 480 | 0, (255 & (5 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 600 | 0, (255 & (6 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 720 | 0, (255 & (7 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 840 | 0, (255 & (8 ^ f4)) - 1 >>> 31 | 0), I7 = E3[A8 + 76 >> 2], E3[C4 + 40 >> 2] = E3[A8 + 72 >> 2], E3[C4 + 44 >> 2] = I7, f4 = E3[4 + (I7 = A8 - -64 | 0) >> 2], E3[C4 + 32 >> 2] = E3[I7 >> 2], E3[C4 + 36 >> 2] = f4, I7 = E3[A8 + 60 >> 2], E3[C4 + 24 >> 2] = E3[A8 + 56 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[A8 + 52 >> 2], E3[C4 + 16 >> 2] = E3[A8 + 48 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[A8 + 44 >> 2], E3[C4 + 8 >> 2] = E3[A8 + 40 >> 2], E3[C4 + 12 >> 2] = I7, I7 = E3[A8 + 12 >> 2], E3[C4 + 56 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 60 >> 2] = I7, f4 = E3[A8 + 20 >> 2], E3[(I7 = C4 - -64 | 0) >> 2] = E3[A8 + 16 >> 2], E3[I7 + 4 >> 2] = f4, I7 = E3[A8 + 28 >> 2], E3[C4 + 72 >> 2] = E3[A8 + 24 >> 2], E3[C4 + 76 >> 2] = I7, I7 = E3[A8 + 36 >> 2], E3[C4 + 80 >> 2] = E3[A8 + 32 >> 2], E3[C4 + 84 >> 2] = I7, I7 = E3[A8 + 4 >> 2], E3[C4 + 48 >> 2] = E3[A8 >> 2], E3[C4 + 52 >> 2] = I7, I7 = E3[A8 + 84 >> 2], f4 = E3[A8 + 88 >> 2], B4 = E3[A8 + 92 >> 2], Q4 = E3[A8 + 96 >> 2], i4 = E3[A8 + 100 >> 2], o4 = E3[A8 + 104 >> 2], D4 = E3[A8 + 108 >> 2], a4 = E3[A8 + 112 >> 2], y4 = E3[A8 + 80 >> 2], E3[C4 + 124 >> 2] = 0 - E3[A8 + 116 >> 2], E3[C4 + 120 >> 2] = 0 - a4, E3[C4 + 116 >> 2] = 0 - D4, E3[C4 + 112 >> 2] = 0 - o4, E3[C4 + 108 >> 2] = 0 - i4, E3[C4 + 104 >> 2] = 0 - Q4, E3[C4 + 100 >> 2] = 0 - B4, E3[C4 + 96 >> 2] = 0 - f4, E3[C4 + 92 >> 2] = 0 - I7, E3[C4 + 88 >> 2] = 0 - y4, EA(A8, C4 + 8 | 0, (128 & g6) >>> 7 | 0), r3 = C4 + 128 | 0; + } + function cA(A8, I7, g6, B4) { + var Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (g6 | B4) A: for (y4 = A8 + 224 | 0, D4 = A8 + 96 | 0, E4 = i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24; ; ) { + if (Q4 = E4 + D4 | 0, !B4 & g6 >>> 0 <= (o4 = 256 - E4 | 0) >>> 0) { + TA(Q4, I7, g6), I7 = g6 + (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) | 0, C3[A8 + 352 | 0] = I7, C3[A8 + 353 | 0] = I7 >>> 8, C3[A8 + 354 | 0] = I7 >>> 16, C3[A8 + 355 | 0] = I7 >>> 24; + break A; + } + if (TA(Q4, I7, o4), Q4 = (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) + o4 | 0, C3[A8 + 352 | 0] = Q4, C3[A8 + 353 | 0] = Q4 >>> 8, C3[A8 + 354 | 0] = Q4 >>> 16, C3[A8 + 355 | 0] = Q4 >>> 24, a4 = E4 = i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24, E4 = (c4 = 128 + (Q4 = i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) | 0) >>> 0 < 128 ? E4 + 1 | 0 : E4, C3[A8 + 64 | 0] = c4, C3[A8 + 65 | 0] = c4 >>> 8, C3[A8 + 66 | 0] = c4 >>> 16, C3[A8 + 67 | 0] = c4 >>> 24, C3[A8 + 68 | 0] = E4, C3[A8 + 69 | 0] = E4 >>> 8, C3[A8 + 70 | 0] = E4 >>> 16, C3[A8 + 71 | 0] = E4 >>> 24, E4 = i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24, E4 = (a4 = Q4 = -1 == (0 | a4) & Q4 >>> 0 > 4294967167) >>> 0 > (Q4 = Q4 + (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) | 0) >>> 0 ? E4 + 1 | 0 : E4, C3[A8 + 72 | 0] = Q4, C3[A8 + 73 | 0] = Q4 >>> 8, C3[A8 + 74 | 0] = Q4 >>> 16, C3[A8 + 75 | 0] = Q4 >>> 24, C3[A8 + 76 | 0] = E4, C3[A8 + 77 | 0] = E4 >>> 8, C3[A8 + 78 | 0] = E4 >>> 16, C3[A8 + 79 | 0] = E4 >>> 24, h3(A8, D4), TA(D4, y4, 128), Q4 = E4 = (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) - 128 | 0, C3[A8 + 352 | 0] = Q4, C3[A8 + 353 | 0] = Q4 >>> 8, C3[A8 + 354 | 0] = Q4 >>> 16, C3[A8 + 355 | 0] = Q4 >>> 24, I7 = I7 + o4 | 0, !((B4 = B4 - (g6 >>> 0 < o4 >>> 0) | 0) | (g6 = g6 - o4 | 0))) break; + } + return 0; + } + function DA(A8, I7) { + var g6, C4 = 0, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0; + C4 = E3[I7 + 4 >> 2], Q4 = E3[I7 + 44 >> 2], i4 = E3[I7 + 8 >> 2], o4 = E3[I7 + 48 >> 2], c4 = E3[I7 + 12 >> 2], D4 = E3[I7 + 52 >> 2], a4 = E3[I7 + 16 >> 2], y4 = E3[I7 + 56 >> 2], f4 = E3[I7 + 20 >> 2], e4 = E3[I7 + 60 >> 2], w4 = E3[I7 + 24 >> 2], r4 = E3[(B4 = I7 - -64 | 0) >> 2], t4 = E3[I7 + 28 >> 2], h4 = E3[I7 + 68 >> 2], k4 = E3[I7 + 32 >> 2], n4 = E3[I7 + 72 >> 2], s4 = E3[I7 + 36 >> 2], g6 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = s4 + g6, E3[A8 + 32 >> 2] = k4 + n4, E3[A8 + 28 >> 2] = t4 + h4, E3[A8 + 24 >> 2] = w4 + r4, E3[A8 + 20 >> 2] = f4 + e4, E3[A8 + 16 >> 2] = a4 + y4, E3[A8 + 12 >> 2] = c4 + D4, E3[A8 + 8 >> 2] = i4 + o4, E3[A8 + 4 >> 2] = C4 + Q4, C4 = E3[I7 + 4 >> 2], Q4 = E3[I7 + 44 >> 2], i4 = E3[I7 + 8 >> 2], o4 = E3[I7 + 48 >> 2], c4 = E3[I7 + 12 >> 2], D4 = E3[I7 + 52 >> 2], a4 = E3[I7 + 16 >> 2], y4 = E3[I7 + 56 >> 2], f4 = E3[I7 + 20 >> 2], e4 = E3[I7 + 60 >> 2], w4 = E3[I7 + 24 >> 2], B4 = E3[B4 >> 2], r4 = E3[I7 + 28 >> 2], t4 = E3[I7 + 68 >> 2], h4 = E3[I7 + 32 >> 2], k4 = E3[I7 + 72 >> 2], n4 = E3[I7 >> 2], s4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = k4 - h4, E3[A8 + 68 >> 2] = t4 - r4, E3[A8 - -64 >> 2] = B4 - w4, E3[A8 + 60 >> 2] = e4 - f4, E3[A8 + 56 >> 2] = y4 - a4, E3[A8 + 52 >> 2] = D4 - c4, E3[A8 + 48 >> 2] = o4 - i4, E3[A8 + 44 >> 2] = Q4 - C4, E3[A8 + 40 >> 2] = s4 - n4, C4 = E3[I7 + 84 >> 2], E3[A8 + 80 >> 2] = E3[I7 + 80 >> 2], E3[A8 + 84 >> 2] = C4, C4 = E3[I7 + 92 >> 2], E3[A8 + 88 >> 2] = E3[I7 + 88 >> 2], E3[A8 + 92 >> 2] = C4, C4 = E3[I7 + 100 >> 2], E3[A8 + 96 >> 2] = E3[I7 + 96 >> 2], E3[A8 + 100 >> 2] = C4, C4 = E3[I7 + 108 >> 2], E3[A8 + 104 >> 2] = E3[I7 + 104 >> 2], E3[A8 + 108 >> 2] = C4, C4 = E3[I7 + 116 >> 2], E3[A8 + 112 >> 2] = E3[I7 + 112 >> 2], E3[A8 + 116 >> 2] = C4, M3(A8 + 120 | 0, I7 + 120 | 0, 1424); + } + function aA(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4, w4, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0; + t4 = E3[I7 + 12 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 4 >> 2], C4 = r3 + -64 & -64, I7 = E3[I7 >> 2], E3[C4 >> 2] = E3[35248 + ((255 & I7) << 2) >> 2], E3[C4 + 4 >> 2] = E3[35248 + (k4 >>> 6 & 1020) >> 2], E3[C4 + 8 >> 2] = E3[35248 + (h4 >>> 14 & 1020) >> 2], E3[C4 + 12 >> 2] = E3[35248 + (t4 >>> 22 & 1020) >> 2], E3[C4 + 16 >> 2] = E3[35248 + ((255 & k4) << 2) >> 2], E3[C4 + 20 >> 2] = E3[35248 + (h4 >>> 6 & 1020) >> 2], E3[C4 + 24 >> 2] = E3[35248 + (t4 >>> 14 & 1020) >> 2], E3[C4 + 28 >> 2] = E3[35248 + (I7 >>> 22 & 1020) >> 2], E3[C4 + 32 >> 2] = E3[35248 + ((255 & h4) << 2) >> 2], E3[C4 + 36 >> 2] = E3[35248 + (t4 >>> 6 & 1020) >> 2], E3[C4 + 40 >> 2] = E3[35248 + (I7 >>> 14 & 1020) >> 2], E3[C4 + 44 >> 2] = E3[35248 + (k4 >>> 22 & 1020) >> 2], E3[C4 + 48 >> 2] = E3[35248 + ((255 & t4) << 2) >> 2], E3[C4 + 52 >> 2] = E3[35248 + (I7 >>> 6 & 1020) >> 2], E3[C4 + 56 >> 2] = E3[35248 + (k4 >>> 14 & 1020) >> 2], E3[C4 + 60 >> 2] = E3[35248 + (h4 >>> 22 & 1020) >> 2], I7 = E3[C4 + 12 >> 2], t4 = E3[C4 >> 2], h4 = E3[C4 + 4 >> 2], k4 = E3[C4 + 8 >> 2], B4 = E3[C4 + 28 >> 2], Q4 = E3[C4 + 16 >> 2], i4 = E3[C4 + 20 >> 2], o4 = E3[C4 + 24 >> 2], c4 = E3[C4 + 44 >> 2], D4 = E3[C4 + 32 >> 2], a4 = E3[C4 + 36 >> 2], y4 = E3[C4 + 40 >> 2], f4 = E3[g6 >> 2], e4 = E3[g6 + 4 >> 2], w4 = E3[g6 + 8 >> 2], n4 = A8, s4 = E3[g6 + 12 >> 2] ^ E3[C4 + 48 >> 2] ^ gI(E3[C4 + 52 >> 2], 8) ^ gI(E3[C4 + 56 >> 2], 16) ^ gI(E3[C4 + 60 >> 2], 24), E3[n4 + 12 >> 2] = s4, n4 = A8, s4 = gI(a4, 8) ^ D4 ^ gI(y4, 16) ^ gI(c4, 24) ^ w4, E3[n4 + 8 >> 2] = s4, n4 = A8, s4 = gI(i4, 8) ^ Q4 ^ gI(o4, 16) ^ gI(B4, 24) ^ e4, E3[n4 + 4 >> 2] = s4, n4 = A8, s4 = gI(h4, 8) ^ t4 ^ gI(k4, 16) ^ gI(I7, 24) ^ f4, E3[n4 >> 2] = s4; + } + function yA(A8, I7) { + var g6, B4, Q4, i4, o4, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0; + (D4 = E3[A8 + 56 >> 2]) | (a4 = E3[A8 + 60 >> 2]) && (C3[(f4 = A8 - -64 | 0) + D4 | 0] = 1, !((k4 = D4 + 1 | 0) ? a4 : a4 + 1 | 0) & k4 >>> 0 <= 15 && VA(65 + (A8 + D4 | 0) | 0, 0, 15 - D4 | 0), C3[A8 + 80 | 0] = 1, z(A8, f4, 16, 0)), k4 = E3[A8 + 52 >> 2], t4 = E3[A8 + 48 >> 2], f4 = E3[A8 + 44 >> 2], D4 = E3[A8 + 24 >> 2], e4 = E3[A8 + 28 >> 2] + (D4 >>> 26 | 0) | 0, y4 = E3[A8 + 32 >> 2] + (e4 >>> 26 | 0) | 0, g6 = E3[A8 + 36 >> 2] + (y4 >>> 26 | 0) | 0, a4 = (r4 = (D4 = (D4 = (67108863 & D4) + ((w4 = E3[A8 + 20 >> 2] + c3(g6 >>> 26 | 0, 5) | 0) >>> 26 | 0) | 0) & (e4 = (y4 = (o4 = (67108863 & g6) + ((i4 = (B4 = 67108863 & y4) + ((Q4 = (h4 = 67108863 & e4) + ((w4 = D4 + ((a4 = 5 + (r4 = 67108863 & w4) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) - 67108864 | 0) >> 31) | w4 & (y4 = 67108863 & (w4 = (y4 >>> 31 | 0) - 1 | 0))) << 26 | a4 & y4 | e4 & r4) + E3[A8 + 40 >> 2] | 0, C3[0 | I7] = a4, C3[I7 + 1 | 0] = a4 >>> 8, C3[I7 + 2 | 0] = a4 >>> 16, C3[I7 + 3 | 0] = a4 >>> 24, r4 = a4 >>> 0 < r4 >>> 0, a4 = 0, a4 = (D4 = (h4 = e4 & h4 | y4 & Q4) << 20 | D4 >>> 6) >>> 0 > (D4 = D4 + f4 | 0) >>> 0 ? 1 : a4, a4 = (f4 = D4) >>> 0 > (D4 = D4 + r4 | 0) >>> 0 ? a4 + 1 | 0 : a4, C3[I7 + 4 | 0] = D4, C3[I7 + 5 | 0] = D4 >>> 8, C3[I7 + 6 | 0] = D4 >>> 16, C3[I7 + 7 | 0] = D4 >>> 24, D4 = 0, f4 = (f4 = (y4 = e4 & B4 | y4 & i4) << 14 | h4 >>> 12) >>> 0 > (t4 = f4 + t4 | 0) >>> 0 ? 1 : D4, D4 = t4, t4 = a4, D4 = D4 + a4 | 0, a4 = f4, a4 = D4 >>> 0 < t4 >>> 0 ? a4 + 1 | 0 : a4, C3[I7 + 8 | 0] = D4, C3[I7 + 9 | 0] = D4 >>> 8, C3[I7 + 10 | 0] = D4 >>> 16, C3[I7 + 11 | 0] = D4 >>> 24, a4 = (D4 = (D4 = (w4 & o4 | e4 & g6) << 8 | y4 >>> 18) + k4 | 0) + a4 | 0, C3[I7 + 12 | 0] = a4, C3[I7 + 13 | 0] = a4 >>> 8, C3[I7 + 14 | 0] = a4 >>> 16, C3[I7 + 15 | 0] = a4 >>> 24, MI(A8, 88); + } + function fA(A8, I7, g6) { + var B4, Q4 = 0; + return r3 = B4 = r3 - 16 | 0, C3[B4 + 15 | 0] = 0, Q4 = -1, 0 | vI[E3[8806]](A8, I7, g6) || (C3[B4 + 15 | 0] = i3[0 | A8] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 1 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 2 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 3 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 4 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 5 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 6 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 7 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 8 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 9 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 10 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 11 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 12 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 13 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 14 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 15 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 16 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 17 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 18 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 19 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 20 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 21 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 22 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 23 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 24 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 25 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 26 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 27 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 28 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 29 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 30 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 31 | 0] | i3[B4 + 15 | 0], Q4 = (i3[B4 + 15 | 0] << 23) - 8388608 >> 31), r3 = B4 + 16 | 0, Q4; + } + function eA(A8, I7) { + var g6, B4, Q4, i4, o4, D4, a4, y4 = 0, f4 = 0; + B4 = E3[I7 + 32 >> 2], Q4 = E3[I7 + 28 >> 2], i4 = E3[I7 + 24 >> 2], o4 = E3[I7 + 20 >> 2], D4 = E3[I7 + 16 >> 2], a4 = E3[I7 + 12 >> 2], y4 = E3[I7 + 4 >> 2], f4 = E3[I7 >> 2], g6 = E3[I7 + 36 >> 2], I7 = E3[I7 + 8 >> 2], f4 = c3((B4 + (Q4 + (i4 + (o4 + (D4 + (a4 + ((y4 + (f4 + (c3(g6, 19) + 16777216 >>> 25 | 0) >> 26) >> 25) + I7 >> 26) >> 25) >> 26) >> 25) >> 26) >> 25) >> 26) + g6 >> 25, 19) + f4 | 0, C3[0 | A8] = f4, C3[A8 + 2 | 0] = f4 >>> 16, C3[A8 + 1 | 0] = f4 >>> 8, y4 = y4 + (f4 >> 26) | 0, C3[A8 + 5 | 0] = y4 >>> 14, C3[A8 + 4 | 0] = y4 >>> 6, C3[A8 + 3 | 0] = f4 >>> 24 & 3 | y4 << 2, I7 = I7 + (y4 >> 25) | 0, C3[A8 + 8 | 0] = I7 >>> 13, C3[A8 + 7 | 0] = I7 >>> 5, C3[A8 + 6 | 0] = I7 << 3 | (29360128 & y4) >>> 22, f4 = (I7 >> 26) + a4 | 0, C3[A8 + 11 | 0] = f4 >>> 11, C3[A8 + 10 | 0] = f4 >>> 3, C3[A8 + 9 | 0] = f4 << 5 | (65011712 & I7) >>> 21, y4 = (f4 >> 25) + D4 | 0, C3[A8 + 15 | 0] = y4 >>> 18, C3[A8 + 14 | 0] = y4 >>> 10, C3[A8 + 13 | 0] = y4 >>> 2, I7 = (y4 >> 26) + o4 | 0, C3[A8 + 16 | 0] = I7, C3[A8 + 12 | 0] = y4 << 6 | (33030144 & f4) >>> 19, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 17 | 0] = I7 >>> 8, y4 = (I7 >> 25) + i4 | 0, C3[A8 + 21 | 0] = y4 >>> 15, C3[A8 + 20 | 0] = y4 >>> 7, C3[A8 + 19 | 0] = I7 >>> 24 & 1 | y4 << 1, I7 = (y4 >> 26) + Q4 | 0, C3[A8 + 24 | 0] = I7 >>> 13, C3[A8 + 23 | 0] = I7 >>> 5, C3[A8 + 22 | 0] = I7 << 3 | (58720256 & y4) >>> 23, y4 = (I7 >> 25) + B4 | 0, C3[A8 + 27 | 0] = y4 >>> 12, C3[A8 + 26 | 0] = y4 >>> 4, C3[A8 + 25 | 0] = y4 << 4 | (31457280 & I7) >>> 21, I7 = g6 + (y4 >> 26) | 0, C3[A8 + 30 | 0] = I7 >>> 10, C3[A8 + 29 | 0] = I7 >>> 2, C3[A8 + 31 | 0] = (33292288 & I7) >>> 18, C3[A8 + 28 | 0] = I7 << 6 | (66060288 & y4) >>> 20; + } + function wA(A8, I7, g6) { + var B4, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = B4 = r3 - 192 | 0, g6 >>> 0 >= 129 && (MA(A8), W(A8, I7, g6, 0), v3(A8, B4), g6 = 64, I7 = B4), MA(A8), VA(B4 - -64 | 0, 54, 128), g6) { + if (g6 >>> 0 >= 4) for (y4 = 252 & g6; C3[0 | (Q4 = (o4 = B4 - -64 | 0) + E4 | 0)] = i3[0 | Q4] ^ i3[I7 + E4 | 0], C3[0 | (c4 = (Q4 = 1 | E4) + o4 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (c4 = (Q4 = 2 | E4) + o4 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (Q4 = (Q4 = o4) + (o4 = 3 | E4) | 0)] = i3[0 | Q4] ^ i3[I7 + o4 | 0], E4 = E4 + 4 | 0, (0 | y4) != (0 | (D4 = D4 + 4 | 0)); ) ; + if (D4 = 3 & g6) for (; C3[0 | (o4 = (B4 - -64 | 0) + E4 | 0)] = i3[0 | o4] ^ i3[I7 + E4 | 0], E4 = E4 + 1 | 0, (0 | D4) != (0 | (a4 = a4 + 1 | 0)); ) ; + } + if (W(A8, E4 = B4 - -64 | 0, 128, 0), MA(o4 = A8 + 208 | 0), VA(E4, 92, 128), g6) { + if (a4 = 0, E4 = 0, g6 >>> 0 >= 4) for (y4 = 252 & g6, D4 = 0; C3[0 | (Q4 = (A8 = B4 - -64 | 0) + E4 | 0)] = i3[0 | Q4] ^ i3[I7 + E4 | 0], C3[0 | (c4 = (Q4 = 1 | E4) + A8 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (c4 = (Q4 = 2 | E4) + A8 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (Q4 = (Q4 = A8) + (A8 = 3 | E4) | 0)] = i3[0 | Q4] ^ i3[A8 + I7 | 0], E4 = E4 + 4 | 0, (0 | y4) != (0 | (D4 = D4 + 4 | 0)); ) ; + if (A8 = 3 & g6) for (; C3[0 | (g6 = (B4 - -64 | 0) + E4 | 0)] = i3[0 | g6] ^ i3[I7 + E4 | 0], E4 = E4 + 1 | 0, (0 | A8) != (0 | (a4 = a4 + 1 | 0)); ) ; + } + return W(o4, A8 = B4 - -64 | 0, 128, 0), MI(A8, 128), MI(B4, 64), r3 = B4 + 192 | 0, 0; + } + function rA(A8, I7) { + var g6; + return E3[12 + (g6 = r3 - 16 | 0) >> 2] = A8, E3[g6 + 8 >> 2] = I7, E3[g6 + 4 >> 2] = 0, E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2]] ^ i3[E3[g6 + 8 >> 2]], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 1 | 0] ^ i3[E3[g6 + 8 >> 2] + 1 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 2 | 0] ^ i3[E3[g6 + 8 >> 2] + 2 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 3 | 0] ^ i3[E3[g6 + 8 >> 2] + 3 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 4 | 0] ^ i3[E3[g6 + 8 >> 2] + 4 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 5 | 0] ^ i3[E3[g6 + 8 >> 2] + 5 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 6 | 0] ^ i3[E3[g6 + 8 >> 2] + 6 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 7 | 0] ^ i3[E3[g6 + 8 >> 2] + 7 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 8 | 0] ^ i3[E3[g6 + 8 >> 2] + 8 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 9 | 0] ^ i3[E3[g6 + 8 >> 2] + 9 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 10 | 0] ^ i3[E3[g6 + 8 >> 2] + 10 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 11 | 0] ^ i3[E3[g6 + 8 >> 2] + 11 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 12 | 0] ^ i3[E3[g6 + 8 >> 2] + 12 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 13 | 0] ^ i3[E3[g6 + 8 >> 2] + 13 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 14 | 0] ^ i3[E3[g6 + 8 >> 2] + 14 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 15 | 0] ^ i3[E3[g6 + 8 >> 2] + 15 | 0], (E3[g6 + 4 >> 2] - 1 >>> 8 & 1) - 1 | 0; + } + function tA(A8, I7, g6, C4, B4, Q4, i4) { + var o4, c4, D4, a4 = 0, y4 = 0, f4 = 0, e4 = 0; + r3 = o4 = r3 - 352 | 0, AA(o4, Q4, i4); + A: { + if (!(((a4 = !!(0 | B4)) | !B4 & C4 >>> 0 > A8 - g6 >>> 0) & A8 >>> 0 > g6 >>> 0) & (!B4 & g6 - A8 >>> 0 >= C4 >>> 0 | A8 >>> 0 >= g6 >>> 0)) { + if (E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, y4 = (i4 = (a4 = !!(0 | B4)) | !B4 & C4 >>> 0 >= 32) ? 32 : C4, f4 = i4 ? 0 : B4, i4 = a4 | !B4 & C4 >>> 0 > 32, !(C4 | B4)) { + e4 = 1; + break A; + } + } else g6 = lA(A8, g6, C4), E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, y4 = (i4 = a4 | !B4 & C4 >>> 0 >= 32) ? 32 : C4, f4 = i4 ? 0 : B4, i4 = a4 | !B4 & C4 >>> 0 > 32; + TA(o4 - -64 | 0, g6, y4), e4 = 0; + } + return a4 = f4, oI(c4 = o4 + 32 | 0, c4, D4 = y4 + 32 | 0, a4 = D4 >>> 0 < 32 ? a4 + 1 | 0 : a4, a4 = Q4 + 16 | 0, o4), nI(o4 + 96 | 0, c4), e4 || TA(A8, o4 - -64 | 0, y4), MI(o4 + 32 | 0, 64), i4 && DI(A8 + y4 | 0, g6 + y4 | 0, C4 - y4 | 0, B4 - ((C4 >>> 0 < y4 >>> 0) + f4 | 0) | 0, a4, o4), MI(o4, 32), rI(g6 = o4 + 96 | 0, A8, C4, B4), sI(g6, I7), MI(g6, 256), r3 = o4 + 352 | 0, 0; + } + function hA(A8, I7) { + var g6, C4 = 0, B4 = 0; + g6 = I7; + A: { + I: { + g: { + if (I7 &= 255) { + if (3 & A8) for (; ; ) { + if (!(C4 = i3[0 | A8]) | (0 | I7) == (0 | C4)) break A; + if (!(3 & (A8 = A8 + 1 | 0))) break; + } + if (-2139062144 != (-2139062144 & ((C4 = E3[A8 >> 2]) | 16843008 - C4))) break g; + for (B4 = c3(I7, 16843009); ; ) { + if (-2139062144 != (-2139062144 & (16843008 - (I7 = C4 ^ B4) | I7))) break g; + if (C4 = E3[A8 + 4 >> 2], A8 = I7 = A8 + 4 | 0, -2139062144 != (-2139062144 & (16843008 - C4 | C4))) break; + } + break I; + } + C4 = A8; + C: { + B: { + Q: if (3 & A8) { + if (I7 = 0, !i3[0 | A8]) break C; + for (; ; ) { + if (!(3 & (A8 = A8 + 1 | 0))) break Q; + if (!i3[0 | A8]) break; + } + break B; + } + for (; I7 = A8, A8 = A8 + 4 | 0, -2139062144 == (-2139062144 & (16843008 - (B4 = E3[I7 >> 2]) | B4)); ) ; + for (; I7 = (A8 = I7) + 1 | 0, i3[0 | A8]; ) ; + } + I7 = A8 - C4 | 0; + } + A8 = I7 + C4 | 0; + break A; + } + I7 = A8; + } + for (; ; ) { + if (!(C4 = i3[0 | (A8 = I7)])) break A; + if (I7 = A8 + 1 | 0, (0 | C4) == (255 & g6)) break; + } + } + return i3[0 | A8] == (255 & g6) ? A8 : 0; + } + function kA(A8, I7, g6, C4, B4, Q4, i4) { + var o4, c4, D4 = 0, a4 = 0, y4 = 0; + r3 = o4 = r3 - 96 | 0, AA(o4, Q4, i4), i4 = o4 + 32 | 0, c4 = Q4 + 16 | 0, vI[E3[8808]](i4, 32, 0, c4, o4), Q4 = -1; + A: { + I: if (!(0 | vI[E3[8802]](g6, I7, C4, B4, i4))) { + if (Q4 = 0, !A8) break A; + g: { + if (!(((g6 = !!(0 | B4)) | !B4 & C4 >>> 0 > I7 - A8 >>> 0) & A8 >>> 0 < I7 >>> 0) & (!B4 & C4 >>> 0 <= A8 - I7 >>> 0 | A8 >>> 0 <= I7 >>> 0)) { + if (!(C4 | B4)) break g; + g6 = (Q4 = !B4 & C4 >>> 0 >= 32 | !!(0 | B4)) ? 32 : C4, D4 = Q4 ? 0 : B4; + } else I7 = lA(A8, I7, C4), g6 = (Q4 = g6 | !B4 & C4 >>> 0 >= 32) ? 32 : C4, D4 = Q4 ? 0 : B4; + if (Q4 = D4, y4 = TA(o4 - -64 | 0, I7, g6), oI(i4 = o4 + 32 | 0, i4, a4 = g6 + 32 | 0, Q4 = a4 >>> 0 < 32 ? Q4 + 1 | 0 : Q4, c4, o4), A8 = TA(A8, y4, g6), MI(i4, 64), Q4 = 0, !B4 & C4 >>> 0 < 33) break I; + DI(A8 + g6 | 0, I7 + g6 | 0, C4 - g6 | 0, B4 - (D4 + (g6 >>> 0 > C4 >>> 0) | 0) | 0, c4, o4); + break I; + } + oI(A8 = o4 + 32 | 0, A8, 32, 0, c4, o4), MI(A8, 64); + } + MI(o4, 32); + } + return r3 = o4 + 96 | 0, Q4; + } + function nA(A8, I7, g6, C4, B4, Q4, o4, c4, D4, a4) { + var y4, f4; + return r3 = y4 = r3 - 400 | 0, E3[y4 + 4 >> 2] = 0, $(f4 = y4 + 16 | 0, D4, a4), a4 = i3[D4 + 20 | 0] | i3[D4 + 21 | 0] << 8 | i3[D4 + 22 | 0] << 16 | i3[D4 + 23 | 0] << 24, E3[y4 + 8 >> 2] = i3[D4 + 16 | 0] | i3[D4 + 17 | 0] << 8 | i3[D4 + 18 | 0] << 16 | i3[D4 + 19 | 0] << 24, E3[y4 + 12 >> 2] = a4, eI(a4 = y4 + 80 | 0, 64, y4 + 4 | 0, f4), nI(D4 = y4 + 144 | 0, a4), MI(a4, 64), rI(D4, Q4, o4, c4), rI(D4, 35104, 0 - o4 & 15, 0), rI(D4, I7, g6, C4), rI(D4, 35104, 0 - g6 & 15, 0), E3[y4 + 72 >> 2] = o4, E3[y4 + 76 >> 2] = c4, rI(D4, Q4 = y4 + 72 | 0, 8, 0), E3[y4 + 72 >> 2] = g6, E3[y4 + 76 >> 2] = C4, rI(D4, Q4, 8, 0), sI(D4, Q4 = y4 + 48 | 0), MI(D4, 256), D4 = rA(Q4, B4), MI(Q4, 16), A8 && (D4 ? (VA(A8, 0, g6), D4 = -1) : (BI(A8, I7, g6, C4, y4 + 4 | 0, y4 + 16 | 0), D4 = 0)), MI(y4 + 16 | 0, 32), r3 = y4 + 400 | 0, D4; + } + function sA(A8, I7, g6, C4, B4, Q4, o4, c4, D4, a4, y4) { + var f4, e4, w4; + return r3 = f4 = r3 - 384 | 0, E3[f4 + 4 >> 2] = 0, $(e4 = f4 + 16 | 0, a4, y4), y4 = i3[a4 + 20 | 0] | i3[a4 + 21 | 0] << 8 | i3[a4 + 22 | 0] << 16 | i3[a4 + 23 | 0] << 24, E3[f4 + 8 >> 2] = i3[a4 + 16 | 0] | i3[a4 + 17 | 0] << 8 | i3[a4 + 18 | 0] << 16 | i3[a4 + 19 | 0] << 24, E3[f4 + 12 >> 2] = y4, eI(y4 = f4 - -64 | 0, 64, w4 = f4 + 4 | 0, e4), nI(a4 = f4 + 128 | 0, y4), MI(y4, 64), rI(a4, o4, c4, D4), rI(a4, 35104, 0 - c4 & 15, 0), BI(A8, C4, B4, Q4, w4, e4), rI(a4, A8, B4, Q4), rI(a4, 35104, 0 - B4 & 15, 0), E3[f4 + 56 >> 2] = c4, E3[f4 + 60 >> 2] = D4, rI(a4, A8 = f4 + 56 | 0, 8, 0), E3[f4 + 56 >> 2] = B4, E3[f4 + 60 >> 2] = Q4, rI(a4, A8, 8, 0), sI(a4, I7), MI(a4, 256), g6 && (E3[g6 >> 2] = 16, E3[g6 + 4 >> 2] = 0), MI(f4 + 16 | 0, 32), r3 = f4 + 384 | 0, 0; + } + function FA(A8, I7, g6, C4) { + var B4, Q4 = 0; + return r3 = B4 = r3 - 208 | 0, E3[B4 + 72 >> 2] = 0, E3[B4 + 76 >> 2] = 0, Q4 = E3[8479], E3[B4 + 8 >> 2] = E3[8478], E3[B4 + 12 >> 2] = Q4, Q4 = E3[8481], E3[B4 + 16 >> 2] = E3[8480], E3[B4 + 20 >> 2] = Q4, Q4 = E3[8483], E3[B4 + 24 >> 2] = E3[8482], E3[B4 + 28 >> 2] = Q4, Q4 = E3[8485], E3[B4 + 32 >> 2] = E3[8484], E3[B4 + 36 >> 2] = Q4, Q4 = E3[8487], E3[B4 + 40 >> 2] = E3[8486], E3[B4 + 44 >> 2] = Q4, Q4 = E3[8489], E3[B4 + 48 >> 2] = E3[8488], E3[B4 + 52 >> 2] = Q4, Q4 = E3[8491], E3[B4 + 56 >> 2] = E3[8490], E3[B4 + 60 >> 2] = Q4, E3[B4 + 64 >> 2] = 0, E3[B4 + 68 >> 2] = 0, Q4 = E3[8477], E3[B4 >> 2] = E3[8476], E3[B4 + 4 >> 2] = Q4, W(B4, I7, g6, C4), v3(B4, A8), r3 = B4 + 208 | 0, 0; + } + function SA(A8, I7) { + var g6, B4 = 0, Q4 = 0, E4 = 0, o4 = 0; + if (C3[15 + (g6 = r3 - 16 | 0) | 0] = 0, I7) { + if (I7 >>> 0 >= 4) for (o4 = -4 & I7; B4 = A8 + Q4 | 0, C3[g6 + 15 | 0] = i3[0 | B4] | i3[g6 + 15 | 0], C3[g6 + 15 | 0] = i3[B4 + 1 | 0] | i3[g6 + 15 | 0], C3[g6 + 15 | 0] = i3[B4 + 2 | 0] | i3[g6 + 15 | 0], C3[g6 + 15 | 0] = i3[B4 + 3 | 0] | i3[g6 + 15 | 0], Q4 = Q4 + 4 | 0, (0 | o4) != (0 | (E4 = E4 + 4 | 0)); ) ; + if (B4 = 3 & I7) for (I7 = 0; C3[g6 + 15 | 0] = i3[A8 + Q4 | 0] | i3[g6 + 15 | 0], Q4 = Q4 + 1 | 0, (0 | B4) != (0 | (I7 = I7 + 1 | 0)); ) ; + } + return i3[g6 + 15 | 0] - 1 >>> 8 & 1; + } + function MA(A8) { + var I7 = 0; + E3[A8 + 64 >> 2] = 0, E3[A8 + 68 >> 2] = 0, E3[A8 + 72 >> 2] = 0, E3[A8 + 76 >> 2] = 0, I7 = E3[8477], E3[A8 >> 2] = E3[8476], E3[A8 + 4 >> 2] = I7, I7 = E3[8479], E3[A8 + 8 >> 2] = E3[8478], E3[A8 + 12 >> 2] = I7, I7 = E3[8481], E3[A8 + 16 >> 2] = E3[8480], E3[A8 + 20 >> 2] = I7, I7 = E3[8483], E3[A8 + 24 >> 2] = E3[8482], E3[A8 + 28 >> 2] = I7, I7 = E3[8485], E3[A8 + 32 >> 2] = E3[8484], E3[A8 + 36 >> 2] = I7, I7 = E3[8487], E3[A8 + 40 >> 2] = E3[8486], E3[A8 + 44 >> 2] = I7, I7 = E3[8489], E3[A8 + 48 >> 2] = E3[8488], E3[A8 + 52 >> 2] = I7, I7 = E3[8491], E3[A8 + 56 >> 2] = E3[8490], E3[A8 + 60 >> 2] = I7; + } + function NA(A8, I7, g6) { + var B4, Q4 = 0, o4 = 0; + if (E3[12 + (B4 = r3 - 16 | 0) >> 2] = A8, E3[B4 + 8 >> 2] = I7, A8 = 0, C3[B4 + 7 | 0] = 0, g6) { + if (I7 = 1 & g6, 1 != (0 | g6)) for (o4 = -2 & g6, g6 = 0; C3[B4 + 7 | 0] = i3[B4 + 7 | 0] | i3[E3[B4 + 12 >> 2] + A8 | 0] ^ i3[E3[B4 + 8 >> 2] + A8 | 0], Q4 = 1 | A8, C3[B4 + 7 | 0] = i3[B4 + 7 | 0] | i3[Q4 + E3[B4 + 12 >> 2] | 0] ^ i3[E3[B4 + 8 >> 2] + Q4 | 0], A8 = A8 + 2 | 0, (0 | o4) != (0 | (g6 = g6 + 2 | 0)); ) ; + I7 && (C3[B4 + 7 | 0] = i3[B4 + 7 | 0] | i3[E3[B4 + 12 >> 2] + A8 | 0] ^ i3[E3[B4 + 8 >> 2] + A8 | 0]); + } + return (i3[B4 + 7 | 0] - 1 >>> 8 & 1) - 1 | 0; + } + function KA(A8) { + for (var I7 = 0, g6 = 0, C4 = 0, B4 = 0, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0; B4 = (g6 = i3[A8 + C4 | 0]) ^ i3[0 | (I7 = C4 + 2432 | 0)] | B4, Q4 = g6 ^ i3[I7 + 192 | 0] | Q4, E4 = g6 ^ i3[I7 + 160 | 0] | E4, o4 = g6 ^ i3[I7 + 128 | 0] | o4, c4 = g6 ^ i3[I7 + 96 | 0] | c4, D4 = g6 ^ i3[I7 - -64 | 0] | D4, a4 = g6 ^ i3[I7 + 32 | 0] | a4, 31 != (0 | (C4 = C4 + 1 | 0)); ) ; + return ((255 & ((I7 = 127 ^ (A8 = 127 & i3[A8 + 31 | 0])) | Q4)) - 1 | (255 & (I7 | E4)) - 1 | (255 & (I7 | o4)) - 1 | (255 & (122 ^ A8 | c4)) - 1 | (255 & (5 ^ A8 | D4)) - 1 | (255 & (A8 | a4)) - 1 | (255 & (A8 | B4)) - 1) >>> 8 & 1; + } + function _A(A8, I7, g6) { + var C4 = 0, B4 = 0, Q4 = 0, E4 = 0; + return B4 = 31 & (Q4 = E4 = 63 & g6), Q4 = Q4 >>> 0 >= 32 ? -1 >>> B4 | 0 : (C4 = -1 >>> B4 | 0) | (1 << B4) - 1 << 32 - B4, Q4 &= A8, C4 &= I7, B4 = 31 & E4, E4 >>> 0 >= 32 ? (C4 = Q4 << B4, E4 = 0) : (C4 = (1 << B4) - 1 & Q4 >>> 32 - B4 | C4 << B4, E4 = Q4 << B4), Q4 = C4, C4 = 31 & (B4 = 0 - g6 & 63), B4 >>> 0 >= 32 ? (C4 = -1 << C4, g6 = 0) : C4 = (g6 = -1 << C4) | (1 << C4) - 1 & -1 >>> 32 - C4, A8 &= g6, I7 &= C4, C4 = 31 & B4, B4 >>> 0 >= 32 ? (g6 = 0, A8 = I7 >>> C4 | 0) : (g6 = I7 >>> C4 | 0, A8 = ((1 << C4) - 1 & I7) << 32 - C4 | A8 >>> C4), t3 = g6 | Q4, A8 | E4; + } + function pA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4) { + var a4, y4, f4; + return r3 = a4 = r3 - 352 | 0, eI(f4 = a4 + 32 | 0, 64, c4, D4), nI(y4 = a4 + 96 | 0, f4), MI(f4, 64), rI(y4, Q4, i4, o4), rI(y4, 35168, 0 - i4 & 15, 0), rI(y4, I7, g6, C4), rI(y4, 35168, 0 - g6 & 15, 0), E3[a4 + 24 >> 2] = i4, E3[a4 + 28 >> 2] = o4, rI(y4, Q4 = a4 + 24 | 0, 8, 0), E3[a4 + 24 >> 2] = g6, E3[a4 + 28 >> 2] = C4, rI(y4, Q4, 8, 0), sI(y4, a4), MI(y4, 256), Q4 = rA(a4, B4), MI(a4, 16), A8 && (Q4 ? (VA(A8, 0, g6), Q4 = -1) : (vA(A8, I7, g6, C4, c4, 1, D4), Q4 = 0)), r3 = a4 + 352 | 0, Q4; + } + function HA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + var y4, f4, e4; + return r3 = y4 = r3 - 336 | 0, eI(e4 = y4 + 16 | 0, 64, D4, a4), nI(f4 = y4 + 80 | 0, e4), MI(e4, 64), rI(f4, i4, o4, c4), rI(f4, 35168, 0 - o4 & 15, 0), vA(A8, C4, B4, Q4, D4, 1, a4), rI(f4, A8, B4, Q4), rI(f4, 35168, 0 - B4 & 15, 0), E3[y4 + 8 >> 2] = o4, E3[y4 + 12 >> 2] = c4, rI(f4, A8 = y4 + 8 | 0, 8, 0), E3[y4 + 8 >> 2] = B4, E3[y4 + 12 >> 2] = Q4, rI(f4, A8, 8, 0), sI(f4, I7), MI(f4, 256), g6 && (E3[g6 >> 2] = 16, E3[g6 + 4 >> 2] = 0), r3 = y4 + 336 | 0, 0; + } + function GA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4) { + var a4, y4, f4; + return r3 = a4 = r3 - 352 | 0, wI(f4 = a4 + 32 | 0, c4, D4), nI(y4 = a4 + 96 | 0, f4), MI(f4, 64), rI(y4, Q4, i4, o4), E3[a4 + 24 >> 2] = i4, E3[a4 + 28 >> 2] = o4, rI(y4, Q4 = a4 + 24 | 0, 8, 0), rI(y4, I7, g6, C4), E3[a4 + 24 >> 2] = g6, E3[a4 + 28 >> 2] = C4, rI(y4, Q4, 8, 0), sI(y4, a4), MI(y4, 256), Q4 = rA(a4, B4), MI(a4, 16), A8 && (Q4 ? (VA(A8, 0, g6), Q4 = -1) : (CI(A8, I7, g6, C4, c4, D4), Q4 = 0)), r3 = a4 + 352 | 0, Q4; + } + function JA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + var y4, f4, e4; + return r3 = y4 = r3 - 336 | 0, wI(e4 = y4 + 16 | 0, D4, a4), nI(f4 = y4 + 80 | 0, e4), MI(e4, 64), rI(f4, i4, o4, c4), E3[y4 + 8 >> 2] = o4, E3[y4 + 12 >> 2] = c4, rI(f4, i4 = y4 + 8 | 0, 8, 0), CI(A8, C4, B4, Q4, D4, a4), rI(f4, A8, B4, Q4), E3[y4 + 8 >> 2] = B4, E3[y4 + 12 >> 2] = Q4, rI(f4, i4, 8, 0), sI(f4, I7), MI(f4, 256), g6 && (E3[g6 >> 2] = 16, E3[g6 + 4 >> 2] = 0), r3 = y4 + 336 | 0, 0; + } + function YA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + var y4 = 0, f4 = 0, e4 = 0; + return f4 = -1, (y4 = C4 >>> 0 < 32) & !B4 || !(y4 = B4 - y4 | 0) & (e4 = C4 - 32 | 0) >>> 0 > 4294967263 | y4 | !o4 & i4 >>> 0 > 4294967263 | o4 || (f4 = 0 | vI[E3[a4 >> 2]](A8, g6, e4, (g6 + C4 | 0) - 32 | 0, 32, Q4, i4, c4, D4)), I7 && (E3[I7 >> 2] = f4 ? 0 : C4 - 32 | 0, E3[I7 + 4 >> 2] = f4 ? 0 : B4 - (C4 >>> 0 < 32) | 0), f4; + } + function UA(A8, I7) { + var g6; + for (E3[12 + (g6 = r3 - 16 | 0) >> 2] = A8, E3[g6 + 8 >> 2] = I7, A8 = 0, E3[g6 + 4 >> 2] = 0; E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + A8 | 0] ^ i3[E3[g6 + 8 >> 2] + A8 | 0], I7 = 1 | A8, E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[I7 + E3[g6 + 12 >> 2] | 0] ^ i3[I7 + E3[g6 + 8 >> 2] | 0], 32 != (0 | (A8 = A8 + 2 | 0)); ) ; + return (E3[g6 + 4 >> 2] - 1 >>> 8 & 1) - 1 | 0; + } + function dA(A8) { + var I7 = 0, g6 = 0, B4 = 0, Q4 = 0, E4 = 0; + for (I7 = 1; g6 = (B4 = I7) + i3[0 | (I7 = A8 + Q4 | 0)] | 0, C3[0 | I7] = g6, g6 = i3[I7 + 1 | 0] + (g6 >>> 8 | 0) | 0, C3[I7 + 1 | 0] = g6, g6 = i3[I7 + 2 | 0] + (g6 >>> 8 | 0) | 0, C3[I7 + 2 | 0] = g6, B4 = I7, I7 = i3[I7 + 3 | 0] + (g6 >>> 8 | 0) | 0, C3[B4 + 3 | 0] = I7, I7 = I7 >>> 8 | 0, Q4 = Q4 + 4 | 0, 4 != (0 | (E4 = E4 + 4 | 0)); ) ; + } + function bA(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return !B4 & C4 >>> 0 > 4294967263 | !!(0 | B4) | !c4 & o4 >>> 0 >= 4294967264 | !!(0 | c4) ? (iI(), Q3()) : (A8 = 0 | vI[E3[y4 >> 2]](A8, A8 + C4 | 0, 32, g6, C4, i4, o4, D4, a4), I7 && (C4 = (g6 = C4 + 32 | 0) >>> 0 < 32 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8 ? 0 : g6, E3[I7 + 4 >> 2] = A8 ? 0 : C4)), A8; + } + function PA(A8, I7, g6, C4) { + var B4, Q4, E4, i4, o4 = 0, D4 = 0; + return i4 = c3(o4 = g6 >>> 16 | 0, D4 = A8 >>> 16 | 0), o4 = (65535 & (D4 = ((E4 = c3(B4 = 65535 & g6, Q4 = 65535 & A8)) >>> 16 | 0) + c3(D4, B4) | 0)) + c3(o4, Q4) | 0, t3 = (c3(I7, g6) + i4 | 0) + c3(A8, C4) + (D4 >>> 16) + (o4 >>> 16) | 0, 65535 & E4 | o4 << 16; + } + function vA(A8, I7, g6, C4, B4, i4, o4) { + var c4 = 0, D4 = 0; + c4 = C4, 1 == (((c4 = (D4 = g6 + 63 | 0) >>> 0 < 63 ? c4 + 1 | 0 : c4) >>> 6 | 0) + !!(0 | (c4 = (63 & c4) << 26 | D4 >>> 6)) | 0) & i4 >>> 0 > (D4 = 0 - c4 | 0) >>> 0 | 1 == (0 | C4) | C4 >>> 0 > 1 ? (iI(), Q3()) : vI[E3[9075]](A8, I7, g6, C4, B4, i4, o4); + } + function RA(A8) { + var I7 = 0; + E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, I7 = E3[8689], E3[A8 >> 2] = E3[8688], E3[A8 + 4 >> 2] = I7, I7 = E3[8691], E3[A8 + 8 >> 2] = E3[8690], E3[A8 + 12 >> 2] = I7, I7 = E3[8693], E3[A8 + 16 >> 2] = E3[8692], E3[A8 + 20 >> 2] = I7, I7 = E3[8695], E3[A8 + 24 >> 2] = E3[8694], E3[A8 + 28 >> 2] = I7; + } + function LA(A8, I7) { + A8 |= 0; + var g6, B4 = 0, Q4 = 0, E4 = 0; + if (r3 = g6 = r3 - 16 | 0, I7 |= 0) for (; C3[g6 + 15 | 0] = 0, Q4 = A8 + B4 | 0, E4 = 0 | y3(36304, g6 + 15 | 0, 0), C3[0 | Q4] = E4, (0 | (B4 = B4 + 1 | 0)) != (0 | I7); ) ; + r3 = g6 + 16 | 0; + } + function xA(A8, I7, g6, C4, B4, Q4, E4) { + var i4, o4, c4 = 0; + return r3 = i4 = r3 - 32 | 0, c4 = -1, (o4 = g6 >>> 0 < 16) & !C4 || OA(i4, Q4, E4) || (c4 = kA(A8, I7 + 16 | 0, I7, g6 - 16 | 0, C4 - o4 | 0, B4, i4), MI(i4, 32)), r3 = i4 + 32 | 0, c4; + } + function uA(A8) { + var I7, g6; + A: { + if (!((A8 = (I7 = E3[8800]) + (g6 = A8 + 7 & -8) | 0) >>> 0 <= I7 >>> 0 && g6)) { + if (A8 >>> 0 <= RI() << 16 >>> 0) break A; + if (0 | w3(0 | A8)) break A; + } + return E3[9280] = 48, -1; + } + return E3[8800] = A8, I7; + } + function mA(A8, I7) { + var g6, B4, Q4; + r3 = g6 = r3 - 176 | 0, iA(B4 = g6 + 96 | 0, I7 + 80 | 0), M3(Q4 = g6 + 48 | 0, I7, B4), M3(g6, I7 + 40 | 0, B4), eA(A8, g6), eA(g6 + 144 | 0, Q4), C3[A8 + 31 | 0] = i3[A8 + 31 | 0] ^ i3[g6 + 144 | 0] << 7, r3 = g6 + 176 | 0; + } + function qA(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4, f4) { + return g6 && (E3[g6 >> 2] = 32, E3[g6 + 4 >> 2] = 0), !D4 & c4 >>> 0 < 4294967264 & !i4 & B4 >>> 0 <= 4294967263 || (iI(), Q3()), 0 | vI[E3[f4 >> 2]](A8, I7, 32, C4, B4, o4, c4, a4, y4); + } + function lA(A8, I7, g6) { + var B4 = 0; + if (A8 >>> 0 < I7 >>> 0) return TA(A8, I7, g6); + if (g6) for (B4 = A8 + g6 | 0, I7 = I7 + g6 | 0; I7 = I7 - 1 | 0, C3[0 | (B4 = B4 - 1 | 0)] = i3[0 | I7], g6 = g6 - 1 | 0; ) ; + return A8; + } + function zA(A8, I7, g6, C4, B4, E4, i4) { + var o4, c4 = 0; + if (r3 = o4 = r3 - 32 | 0, !C4 & g6 >>> 0 < 4294967280) return c4 = -1, OA(o4, E4, i4) || (c4 = tA(A8 + 16 | 0, A8, I7, g6, C4, B4, o4), MI(o4, 32)), r3 = o4 + 32 | 0, c4; + iI(), Q3(); + } + function jA(A8, I7, g6, C4, B4, Q4) { + return I7 |= 0, 0 | (!(C4 |= 0) & (g6 |= 0) >>> 0 >= 16 | C4 ? kA(A8 |= 0, I7 + 16 | 0, I7, g6 - 16 | 0, C4 - (g6 >>> 0 < 16) | 0, B4 |= 0, Q4 |= 0) : -1); + } + function XA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return !C4 & g6 >>> 0 > 4294967263 | C4 | !o4 & i4 >>> 0 > 4294967263 | o4 ? -1 : 0 | vI[E3[a4 >> 2]](A8, I7, g6, B4, 32, Q4, i4, c4, D4); + } + function OA(A8, I7, g6) { + A8 |= 0; + var C4, B4 = 0; + return r3 = C4 = r3 - 32 | 0, B4 = -1, fA(C4, g6 |= 0, I7 |= 0) || (B4 = AA(A8, 35184, C4)), r3 = C4 + 32 | 0, 0 | B4; + } + function TA(A8, I7, g6) { + var B4 = 0; + if (g6) for (B4 = A8; C3[0 | B4] = i3[0 | I7], B4 = B4 + 1 | 0, I7 = I7 + 1 | 0, g6 = g6 - 1 | 0; ) ; + return A8; + } + function VA(A8, I7, g6) { + var B4 = 0; + if (g6) for (B4 = A8; C3[0 | B4] = I7, B4 = B4 + 1 | 0, g6 = g6 - 1 | 0; ) ; + return A8; + } + function ZA(A8, I7, g6) { + return A8 |= 0, I7 |= 0, (g6 |= 0) >>> 0 >= 256 && (f3(1248, 1175, 107, 1055), Q3()), 0 | m3(A8, I7, 255 & g6); + } + function WA(A8, I7) { + var g6; + r3 = g6 = r3 + -64 | 0, v3(A8, g6), W(A8 = A8 + 208 | 0, g6, 64, 0), v3(A8, I7), MI(g6, 64), r3 = g6 - -64 | 0; + } + function $A(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | tA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + } + function AI(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | kA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + } + function II(A8, I7) { + var g6; + r3 = g6 = r3 - 32 | 0, IA(A8, g6), BA(A8 = A8 + 104 | 0, g6, 32), IA(A8, I7), MI(g6, 32), r3 = g6 + 32 | 0; + } + function gI(A8, I7) { + var g6 = 0; + return (-1 >>> (g6 = 31 & I7) & A8) << g6 | ((g6 = A8) & -1 << (A8 = 0 - I7 & 31)) >>> A8; + } + function CI(A8, I7, g6, C4, B4, i4) { + 1 == (0 | C4) | C4 >>> 0 > 1 && (iI(), Q3()), vI[E3[9074]](A8, I7, g6, C4, B4, 1, 0, i4); + } + function BI(A8, I7, g6, C4, B4, i4) { + 1 == (0 | C4) | C4 >>> 0 > 1 && (iI(), Q3()), vI[E3[9075]](A8, I7, g6, C4, B4, 1, i4); + } + function QI() { + var A8; + r3 = A8 = r3 - 16 | 0, C3[A8 + 15 | 0] = 0, y3(36340, A8 + 15 | 0, 0), r3 = A8 + 16 | 0; + } + function EI(A8, I7, g6) { + return 0 | fA(A8 |= 0, I7 |= 0, g6 |= 0); + } + function iI() { + var A8; + (A8 = E3[9413]) && vI[0 | A8](), e3(), Q3(); + } + function oI(A8, I7, g6, C4, B4, Q4) { + vI[E3[8809]](A8, I7, g6, C4, B4, 0, 0, Q4); + } + function cI(A8, I7) { + return A8 |= 0, LA(I7 |= 0, 32), 0 | hI(A8, I7); + } + function DI(A8, I7, g6, C4, B4, Q4) { + vI[E3[8809]](A8, I7, g6, C4, B4, 1, 0, Q4); + } + function aI(A8) { + return A8 ? 31 - D3(A8 - 1 ^ A8) | 0 : 32; + } + function yI(A8, I7, g6, C4) { + vI[E3[9075]](A8, I7, 40, 0, g6, 0, C4); + } + function fI(A8, I7) { + return 0 | hI(A8 |= 0, I7 |= 0); + } + function eI(A8, I7, g6, C4) { + vI[E3[9073]](A8, I7, 0, g6, C4); + } + function wI(A8, I7, g6) { + vI[E3[9072]](A8, 64, 0, I7, g6); + } + function rI(A8, I7, g6, C4) { + vI[E3[8804]](A8, I7, g6, C4); + } + function tI(A8, I7, g6, C4) { + return W(A8, I7, g6, C4), 0; + } + function hI(A8, I7) { + return 0 | vI[E3[8807]](A8, I7); + } + function kI(A8, I7, g6) { + return BA(A8, I7, g6), 0; + } + function nI(A8, I7) { + vI[E3[8803]](A8, I7); + } + function sI(A8, I7) { + vI[E3[8805]](A8, I7); + } + function FI(A8) { + LA(A8 |= 0, 32); + } + function SI(A8) { + LA(A8 |= 0, 16); + } + function MI(A8, I7) { + VA(A8, 0, I7); + } + function NI() { + return 208; + } + function KI() { + return 16; + } + function _I() { + return 32; + } + function pI() { + return 24; + } + function HI() { + return -17; + } + function GI() { + return -33; + } + function JI() { + return 64; + } + function YI() { + return 0; + } + function UI() { + return 8; + } + function dI() { + return 1; + } + function bI() { + return 2; + } + B3(I6 = i3, 1024, "cmFuZG9tYnl0ZXMAYjY0X3BvcyA8PSBiNjRfbGVuAGNyeXB0b19nZW5lcmljaGFzaF9ibGFrZTJiX2ZpbmFsAHJhbmRvbWJ5dGVzL3JhbmRvbWJ5dGVzLmMAc29kaXVtL2NvZGVjcy5jAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9ibGFrZTJiLXJlZi5jAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9nZW5lcmljaGFzaF9ibGFrZTJiLmMAYnVmX2xlbiA8PSBTSVpFX01BWABvdXRsZW4gPD0gVUlOVDhfTUFYAFMtPmJ1ZmxlbiA8PSBCTEFLRTJCX0JMT0NLQllURVMAc29kaXVtX2JpbjJiYXNlNjQAMS4wLjIwAAAAALZ4Wf+FctMAvW4V/w8KagApwAEAmOh5/7w8oP+Zcc7/ALfi/rQNSP8AAAAAAAAAALCgDv7TyYb/nhiPAH9pNQBgDL0Ap9f7/59MgP5qZeH/HvwEAJIMrg=="), B3(I6, 1424, "WfGy/grlpv973Sr+HhTUAFKAAwAw0fMAd3lA/zLjnP8AbsUBZxuQ"), B3(I6, 1472, "hTuMAb3xJP/4JcMBYNw3ALdMPv/DQj0AMkykAeGkTP9MPaP/dT4fAFGRQP92QQ4AonPW/waKLgB85vT/CoqPADQawgC49EwAgY8pAb70E/97qnr/YoFEAHnVkwBWZR7/oWebAIxZQ//v5b4BQwu1AMbwif7uRbz/Q5fuABMqbP/lVXEBMkSH/xFqCQAyZwH/UAGoASOYHv8QqLkBOFno/2XS/AAp+kcAzKpP/w4u7/9QTe8AvdZL/xGN+QAmUEz/vlV1AFbkqgCc2NABw8+k/5ZCTP+v4RD/jVBiAUzb8gDGonIALtqYAJsr8f6boGj/M7ulAAIRrwBCVKAB9zoeACNBNf5F7L8ALYb1AaN73QAgbhT/NBelALrWRwDpsGAA8u82ATlZigBTAFT/iKBkAFyOeP5ofL4AtbE+//opVQCYgioBYPz2AJeXP/7vhT4AIDicAC2nvf+OhbMBg1bTALuzlv76qg7/0qNOACU0lwBjTRoA7pzV/9XA0QFJLlQAFEEpATbOTwDJg5L+qm8Y/7EhMv6rJsv/Tvd0ANHdmQCFgLIBOiwZAMknOwG9E/wAMeXSAXW7dQC1s7gBAHLbADBekwD1KTgAfQ3M/vStdwAs3SD+VOoUAPmgxgHsfur/L2Oo/qrimf9ms9gA4o16/3pCmf629YYA4+QZAdY56//YrTj/tefSAHeAnf+BX4j/bn4zAAKpt/8HgmL+RbBe/3QE4wHZ8pH/yq0fAWkBJ/8ur0UA5C86/9fgRf7POEX/EP6L/xfP1P/KFH7/X9Vg/wmwIQDIBc//8SqA/iMhwP/45cQBgRF4APtnl/8HNHD/jDhC/yji9f/ZRiX+rNYJ/0hDhgGSwNb/LCZwAES4S//OWvsAleuNALWqOgB09O8AXJ0CAGatYgDpiWABfzHLAAWblAAXlAn/03oMACKGGv/bzIgAhggp/+BTK/5VGfcAbX8A/qmIMADud9v/563VAM4S/v4Iugf/fgkHAW8qSABvNOz+YD+NAJO/f/7NTsD/DmrtAbvbTACv87v+aVmtAFUZWQGi85QAAnbR/iGeCQCLoy7/XUYoAGwqjv5v/I7/m9+QADPlp/9J/Jv/XnQM/5ig2v+c7iX/s+rP/8UAs/+apI0A4cRoAAojGf7R1PL/Yf3e/rhl5QDeEn8BpIiH/x7PjP6SYfMAgcAa/slUIf9vCk7/k1Gy/wQEGACh7tf/Bo0hADXXDv8ptdD/54udALPL3f//uXEAveKs/3FC1v/KPi3/ZkAI/06uEP6FdUT/"), B3(I6, 2464, "AQ=="), B3(I6, 2496, "JuiVj8KyJ7BFw/SJ8u+Y8NXfrAXTxjM5sTgCiG1T/AXHF2pwPU3YT7o8C3YNEGcPKiBT+iw5zMZOx/13kqwDeuz///////////////////////////////////////9/7f///////////////////////////////////////3/u////////////////////////////////////////f+3T9VwaYxJY1pz3ot753hQ="), B3(I6, 2687, "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"), B3(I6, 33660, "AQ=="), B3(I6, 33696, "AQ=="), B3(I6, 33728, "4Ot6fDtBuK4WVuP68Z/EatoJjeucMrH9hmIFFl9JuABfnJW8o1CMJLHQsVWcg+9bBERcxFgcjobYIk7d0J8RV+z///////////////////////////////////////9/7f///////////////////////////////////////3/u////////////////////////////////////////f0xpYnNvZGl1bURSRwAAAAAIybzzZ+YJajunyoSFrme7K/iU/nLzbjzxNh1fOvVPpdGC5q1/Ug5RH2w+K4xoBZtrvUH7q9mDH3khfhMZzeBbIq4o15gvikLNZe8jkUQ3cS87TezP+8C1vNuJgaXbtek4tUjzW8JWORnQBbbxEfFZm08Zr6SCP5IYgW3a1V4cq0ICA6OYqgfYvm9wRQFbgxKMsuROvoUxJOK0/9XDfQxVb4l78nRdvnKxlhY7/rHegDUSxyWnBtyblCZpz3Txm8HSSvGewWmb5OMlTziGR77vtdWMi8adwQ9lnKx3zKEMJHUCK1lvLOktg+SmbqqEdErU+0G93KmwXLVTEYPaiPl2q99m7lJRPpgQMrQtbcYxqD8h+5jIJwOw5A7vvsd/Wb/Cj6g98wvgxiWnCpNHkafVb4ID4FFjygZwbg4KZykpFPwv0kaFCrcnJskmXDghGy7tKsRa/G0sTd+zlZ0TDThT3mOvi1RzCmWosnc8uwpqduau7UcuycKBOzWCFIUscpJkA/FMoei/ogEwQrxLZhqokZf40HCLS8IwvlQGo1FsxxhS79YZ6JLREKllVSQGmdYqIHFXhTUO9LjRuzJwoGoQyNDSuBbBpBlTq0FRCGw3Hpnrjt9Md0gnqEib4bW8sDRjWsnFswwcOcuKQeNKqthOc+Njd0/KnFujuLLW828uaPyy713ugo90YC8XQ29jpXhyq/ChFHjIhOw5ZBoIAseMKB5jI/r/vpDpvYLe62xQpBV5xrL3o/m+K1Ny4/J4ccacYSbqzj4nygfCwCHHuIbRHuvgzdZ92up40W7uf0999bpvF3KqZ/AGppjIosV9YwquDfm+BJg/ERtHHBM1C3EbhH0EI/V32yiTJMdAe6vKMry+yRUKvp48TA0QnMRnHUO2Qj7LvtTFTCp+ZfycKX9Z7PrWOqtvy18XWEdKjBlEbIA="), B3(I6, 34752, "Z+YJaoWuZ7ty8248OvVPpX9SDlGMaAWbq9mDHxnN4FuYL4pCkUQ3cc/7wLWl27XpW8JWOfER8Vmkgj+S1V4cq5iqB9gBW4MSvoUxJMN9DFV0Xb5y/rHegKcG3Jt08ZvBwWmb5IZHvu/GncEPzKEMJG8s6S2qhHRK3KmwXNqI+XZSUT6YbcYxqMgnA7DHf1m/8wvgxkeRp9VRY8oGZykpFIUKtyc4IRsu/G0sTRMNOFNUcwpluwpqdi7JwoGFLHKSoei/oktmGqhwi0vCo1FsxxnoktEkBpnWhTUO9HCgahAWwaQZCGw3Hkx3SCe1vLA0swwcOUqq2E5Pypxb828uaO6Cj3RvY6V4FHjIhAgCx4z6/76Q62xQpPej+b7yeHHGgA=="), B3(I6, 35120, "U2lnRWQyNTUxOSBubyBFZDI1NTE5IGNvbGxpc2lvbnMB"), B3(I6, 35200, "IJMBAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQ=="), B3(I6, 35248, "xmNjpfh8fITud3eZ9nt7jf/y8g3Wa2u93m9vsZHFxVRgMDBQAgEBA85nZ6lWKyt95/7+GbXX12JNq6vm7HZ2mo/KykUfgoKdicnJQPp9fYfv+voVsllZ645HR8n78PALQa2t7LPU1GdfoqL9Ra+v6iOcnL9TpKT35HJylpvAwFt1t7fC4f39HD2Tk65MJiZqbDY2Wn4/P0H19/cCg8zMT2g0NFxRpaX00eXlNPnx8QjicXGTq9jYc2IxMVMqFRU/CAQEDJXHx1JGIyNlncPDXjAYGCg3lpahCgUFDy+amrUOBwcJJBISNhuAgJvf4uI9zevrJk4nJ2l/srLN6nV1nxIJCRsdg4OeWCwsdDQaGi42Gxst3G5usrRaWu5boKD7pFJS9nY7O0231tZhfbOzzlIpKXvd4+M+Xi8vcROEhJemU1P1udHRaAAAAADB7e0sQCAgYOP8/B95sbHItltb7dRqar6Ny8tGZ76+2XI5OUuUSkremExM1LBYWOiFz89Ku9DQa8Xv7ypPqqrl7fv7FoZDQ8WaTU3XZjMzVRGFhZSKRUXP6fn5EAQCAgb+f3+BoFBQ8Hg8PEQln5+6S6io46JRUfNdo6P+gEBAwAWPj4o/kpKtIZ2dvHA4OEjx9fUEY7y833e2tsGv2tp1QiEhYyAQEDDl//8a/fPzDr/S0m2Bzc1MGAwMFCYTEzXD7Owvvl9f4TWXl6KIRETMLhcXOZPExFdVp6fy/H5+gno9PUfIZGSsul1d5zIZGSvmc3OVwGBgoBmBgZieT0/Ro9zcf0QiImZUKip+O5CQqwuIiIOMRkbKx+7uKWu4uNMoFBQ8p97eebxeXuIWCwsdrdvbdtvg4DtkMjJWdDo6ThQKCh6SSUnbDAYGCkgkJGy4XFzkn8LCXb3T025DrKzvxGJipjmRkagxlZWk0+TkN/J5eYvV5+cyi8jIQ243N1nabW23AY2NjLHV1WScTk7SSamp4NhsbLSsVlb68/T0B8/q6iXKZWWv9Hp6jkeurukQCAgYb7q61fB4eIhKJSVvXC4ucjgcHCRXpqbxc7S0x5fGxlHL6Ogjod3dfOh0dJw+Hx8hlktL3WG9vdwNi4uGD4qKheBwcJB8Pj5CcbW1xMxmZqqQSEjYBgMDBff29gEcDg4SwmFho2o1NV+uV1f5abm50BeGhpGZwcFYOh0dJyeenrnZ4eE46/j4EyuYmLMiEREz0mlpu6nZ2XAHjo6JM5SUpy2bm7Y8Hh4iFYeHksnp6SCHzs5JqlVV/1AoKHil3996A4yMj1mhofgJiYmAGg0NF2W/v9rX5uYxhEJCxtBoaLiCQUHDKZmZsFotLXceDw8Re7Cwy6hUVPxtu7vWLBYWOgoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAAR"); + var PI, vI = (PI = [null, function(A8, I7, g6, B4, Q4) { + var o4, c4, D4; + return A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0, r3 = o4 = (c4 = r3) - 128 & -64, E3[o4 >> 2] = 67108863 & (i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), E3[o4 + 4 >> 2] = (i3[Q4 + 3 | 0] | i3[Q4 + 4 | 0] << 8 | i3[Q4 + 5 | 0] << 16 | i3[Q4 + 6 | 0] << 24) >>> 2 & 67108611, E3[o4 + 8 >> 2] = (i3[Q4 + 6 | 0] | i3[Q4 + 7 | 0] << 8 | i3[Q4 + 8 | 0] << 16 | i3[Q4 + 9 | 0] << 24) >>> 4 & 67092735, E3[o4 + 12 >> 2] = (i3[Q4 + 9 | 0] | i3[Q4 + 10 | 0] << 8 | i3[Q4 + 11 | 0] << 16 | i3[Q4 + 12 | 0] << 24) >>> 6 & 66076671, D4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[o4 + 20 >> 2] = 0, E3[o4 + 24 >> 2] = 0, E3[o4 + 28 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, E3[o4 + 16 >> 2] = D4 >>> 8 & 1048575, E3[o4 + 40 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[o4 + 44 >> 2] = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[o4 + 48 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, Q4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, C3[o4 + 80 | 0] = 0, E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 52 >> 2] = Q4, QA(o4, I7, g6, B4), yA(o4, A8), r3 = c4, 0; + }, function(A8, I7, g6, B4, Q4) { + var o4, c4, D4; + return A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0, r3 = o4 = (c4 = r3) - 192 & -64, E3[o4 + 64 >> 2] = 67108863 & (i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), E3[o4 + 68 >> 2] = (i3[Q4 + 3 | 0] | i3[Q4 + 4 | 0] << 8 | i3[Q4 + 5 | 0] << 16 | i3[Q4 + 6 | 0] << 24) >>> 2 & 67108611, E3[o4 + 72 >> 2] = (i3[Q4 + 6 | 0] | i3[Q4 + 7 | 0] << 8 | i3[Q4 + 8 | 0] << 16 | i3[Q4 + 9 | 0] << 24) >>> 4 & 67092735, E3[o4 + 76 >> 2] = (i3[Q4 + 9 | 0] | i3[Q4 + 10 | 0] << 8 | i3[Q4 + 11 | 0] << 16 | i3[Q4 + 12 | 0] << 24) >>> 6 & 66076671, D4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[o4 + 84 >> 2] = 0, E3[o4 + 88 >> 2] = 0, E3[o4 + 92 >> 2] = 0, E3[o4 + 96 >> 2] = 0, E3[o4 + 100 >> 2] = 0, E3[o4 + 80 >> 2] = D4 >>> 8 & 1048575, E3[o4 + 104 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[o4 + 108 >> 2] = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[o4 + 112 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, Q4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, C3[o4 + 144 | 0] = 0, E3[o4 + 120 >> 2] = 0, E3[o4 + 124 >> 2] = 0, E3[o4 + 116 >> 2] = Q4, QA(Q4 = o4 - -64 | 0, I7, g6, B4), yA(Q4, I7 = o4 + 48 | 0), A8 = rA(A8, I7), r3 = c4, 0 | A8; + }, function(A8, I7) { + var g6; + return I7 |= 0, E3[(A8 |= 0) >> 2] = 67108863 & (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24), E3[A8 + 4 >> 2] = (i3[I7 + 3 | 0] | i3[I7 + 4 | 0] << 8 | i3[I7 + 5 | 0] << 16 | i3[I7 + 6 | 0] << 24) >>> 2 & 67108611, E3[A8 + 8 >> 2] = (i3[I7 + 6 | 0] | i3[I7 + 7 | 0] << 8 | i3[I7 + 8 | 0] << 16 | i3[I7 + 9 | 0] << 24) >>> 4 & 67092735, E3[A8 + 12 >> 2] = (i3[I7 + 9 | 0] | i3[I7 + 10 | 0] << 8 | i3[I7 + 11 | 0] << 16 | i3[I7 + 12 | 0] << 24) >>> 6 & 66076671, g6 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, E3[A8 + 20 >> 2] = 0, E3[A8 + 24 >> 2] = 0, E3[A8 + 28 >> 2] = 0, E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, E3[A8 + 16 >> 2] = g6 >>> 8 & 1048575, E3[A8 + 40 >> 2] = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, E3[A8 + 44 >> 2] = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, E3[A8 + 48 >> 2] = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, I7 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, C3[A8 + 80 | 0] = 0, E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, E3[A8 + 52 >> 2] = I7, 0; + }, function(A8, I7, g6, C4) { + return QA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0), 0; + }, function(A8, I7) { + return yA(A8 |= 0, I7 |= 0), 0; + }, function(A8, I7, g6) { + A8 |= 0, I7 |= 0, g6 |= 0; + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, SA2 = 0, MA2 = 0, NA2 = 0; + for (r3 = B4 = r3 - 368 | 0; k4 = (c4 = i3[g6 + Q4 | 0]) ^ i3[0 | (a4 = Q4 + 33664 | 0)] | k4, h4 = c4 ^ i3[a4 + 192 | 0] | h4, w4 = c4 ^ i3[a4 + 160 | 0] | w4, e4 = c4 ^ i3[a4 + 128 | 0] | e4, D4 = c4 ^ i3[a4 + 96 | 0] | D4, y4 = c4 ^ i3[a4 - -64 | 0] | y4, o4 = c4 ^ i3[a4 + 32 | 0] | o4, 31 != (0 | (Q4 = Q4 + 1 | 0)); ) ; + if (Q4 = -1, !(256 & ((255 & ((c4 = 127 ^ (a4 = 127 & i3[g6 + 31 | 0])) | h4)) - 1 | (255 & (c4 | w4)) - 1 | (255 & (c4 | e4)) - 1 | (255 & (87 ^ a4 | D4)) - 1 | (255 & (y4 | a4)) - 1 | (255 & (o4 | a4)) - 1 | (255 & (a4 | k4)) - 1))) { + for (Q4 = I7, I7 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, E3[B4 + 360 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, E3[B4 + 364 >> 2] = I7, I7 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[B4 + 352 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[B4 + 356 >> 2] = I7, o4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, I7 = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, E3[B4 + 336 >> 2] = I7, E3[B4 + 340 >> 2] = o4, o4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[B4 + 344 >> 2] = i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24, E3[B4 + 348 >> 2] = o4, C3[B4 + 336 | 0] = 248 & I7, C3[B4 + 367 | 0] = 63 & i3[B4 + 367 | 0] | 64, V(B4 + 288 | 0, g6), E3[B4 + 260 >> 2] = 0, E3[B4 + 264 >> 2] = 0, E3[B4 + 268 >> 2] = 0, E3[B4 + 272 >> 2] = 0, E3[B4 + 276 >> 2] = 0, E3[B4 + 208 >> 2] = 0, E3[B4 + 212 >> 2] = 0, E3[B4 + 216 >> 2] = 0, E3[B4 + 220 >> 2] = 0, E3[B4 + 224 >> 2] = 0, E3[B4 + 228 >> 2] = 0, I7 = E3[B4 + 308 >> 2], E3[B4 + 160 >> 2] = E3[B4 + 304 >> 2], E3[B4 + 164 >> 2] = I7, I7 = E3[B4 + 316 >> 2], E3[B4 + 168 >> 2] = E3[B4 + 312 >> 2], E3[B4 + 172 >> 2] = I7, I7 = E3[B4 + 324 >> 2], E3[B4 + 176 >> 2] = E3[B4 + 320 >> 2], E3[B4 + 180 >> 2] = I7, E3[B4 + 244 >> 2] = 0, E3[B4 + 248 >> 2] = 0, E3[B4 + 240 >> 2] = 1, E3[B4 + 252 >> 2] = 0, E3[B4 + 256 >> 2] = 0, E3[B4 + 192 >> 2] = 0, E3[B4 + 196 >> 2] = 0, E3[B4 + 200 >> 2] = 0, E3[B4 + 204 >> 2] = 0, I7 = E3[B4 + 292 >> 2], E3[B4 + 144 >> 2] = E3[B4 + 288 >> 2], E3[B4 + 148 >> 2] = I7, I7 = E3[B4 + 300 >> 2], E3[B4 + 152 >> 2] = E3[B4 + 296 >> 2], E3[B4 + 156 >> 2] = I7, E3[B4 + 116 >> 2] = 0, E3[B4 + 120 >> 2] = 0, E3[B4 + 124 >> 2] = 0, E3[B4 + 128 >> 2] = 0, E3[B4 + 132 >> 2] = 0, E3[B4 + 100 >> 2] = 0, E3[B4 + 104 >> 2] = 0, E3[B4 + 96 >> 2] = 1, E3[B4 + 108 >> 2] = 0, E3[B4 + 112 >> 2] = 0, g6 = 254; W2 = E3[B4 + 276 >> 2], c4 = E3[B4 + 180 >> 2], $2 = E3[B4 + 96 >> 2], AA2 = E3[B4 + 192 >> 2], IA2 = E3[B4 + 144 >> 2], gA2 = E3[B4 + 240 >> 2], CA2 = E3[B4 + 100 >> 2], BA2 = E3[B4 + 196 >> 2], QA2 = E3[B4 + 148 >> 2], EA2 = E3[B4 + 244 >> 2], J4 = E3[B4 + 104 >> 2], oA2 = E3[B4 + 200 >> 2], Y4 = E3[B4 + 152 >> 2], cA2 = E3[B4 + 248 >> 2], P4 = E3[B4 + 108 >> 2], DA2 = E3[B4 + 204 >> 2], v4 = E3[B4 + 156 >> 2], aA2 = E3[B4 + 252 >> 2], d4 = E3[B4 + 112 >> 2], yA2 = E3[B4 + 208 >> 2], H4 = E3[B4 + 160 >> 2], fA2 = E3[B4 + 256 >> 2], k4 = E3[B4 + 116 >> 2], wA2 = E3[B4 + 212 >> 2], f4 = E3[B4 + 164 >> 2], rA2 = E3[B4 + 260 >> 2], h4 = E3[B4 + 120 >> 2], tA2 = E3[B4 + 216 >> 2], w4 = E3[B4 + 168 >> 2], hA2 = E3[B4 + 264 >> 2], e4 = E3[B4 + 124 >> 2], kA2 = E3[B4 + 220 >> 2], D4 = E3[B4 + 172 >> 2], nA2 = E3[B4 + 268 >> 2], y4 = E3[B4 + 128 >> 2], sA2 = E3[B4 + 224 >> 2], o4 = E3[B4 + 176 >> 2], p4 = E3[B4 + 272 >> 2], FA2 = g6, G4 = (N4 = (I7 = 0 - ((I7 = Z2) ^ (Z2 = i3[(SA2 = B4 + 336 | 0) + (g6 >>> 3 | 0) | 0] >>> (7 & g6) & 1)) | 0) & ((Q4 = E3[B4 + 132 >> 2]) ^ (j2 = E3[B4 + 228 >> 2]))) ^ Q4, E3[B4 + 132 >> 2] = G4, X2 = c4 ^ (K4 = I7 & (c4 ^ W2)), E3[B4 + 84 >> 2] = X2 - G4, b4 = y4 ^ (s4 = I7 & (y4 ^ sA2)), E3[B4 + 128 >> 2] = b4, O2 = (_4 = I7 & (o4 ^ p4)) ^ o4, E3[B4 + 80 >> 2] = O2 - b4, L4 = e4 ^ (F4 = I7 & (e4 ^ kA2)), E3[B4 + 124 >> 2] = L4, MA2 = D4 ^ (S4 = I7 & (D4 ^ nA2)), E3[B4 + 76 >> 2] = MA2 - L4, x4 = h4 ^ (n4 = I7 & (h4 ^ tA2)), E3[B4 + 120 >> 2] = x4, NA2 = w4 ^ (a4 = I7 & (w4 ^ hA2)), E3[B4 + 72 >> 2] = NA2 - x4, u4 = k4 ^ (c4 = I7 & (k4 ^ wA2)), E3[B4 + 116 >> 2] = u4, m4 = f4 ^ (k4 = I7 & (f4 ^ rA2)), E3[B4 + 68 >> 2] = m4 - u4, q4 = d4 ^ (h4 = I7 & (d4 ^ yA2)), E3[B4 + 112 >> 2] = q4, R4 = H4 ^ (w4 = I7 & (H4 ^ fA2)), E3[B4 + 64 >> 2] = R4 - q4, l3 = P4 ^ (e4 = I7 & (P4 ^ DA2)), E3[B4 + 108 >> 2] = l3, T2 = v4 ^ (D4 = I7 & (v4 ^ aA2)), E3[B4 + 60 >> 2] = T2 - l3, z2 = J4 ^ (y4 = I7 & (J4 ^ oA2)), E3[B4 + 104 >> 2] = z2, P4 = Y4 ^ (o4 = I7 & (Y4 ^ cA2)), E3[B4 + 56 >> 2] = P4 - z2, J4 = CA2 ^ (Q4 = I7 & (CA2 ^ BA2)), E3[B4 + 100 >> 2] = J4, v4 = QA2 ^ (g6 = I7 & (QA2 ^ EA2)), E3[B4 + 52 >> 2] = v4 - J4, Y4 = $2 ^ (d4 = I7 & ($2 ^ AA2)), E3[B4 + 96 >> 2] = Y4, H4 = (I7 &= IA2 ^ gA2) ^ IA2, E3[B4 + 48 >> 2] = H4 - Y4, f4 = K4 ^ W2, N4 ^= j2, E3[B4 + 36 >> 2] = f4 - N4, K4 = _4 ^ p4, s4 ^= sA2, E3[B4 + 32 >> 2] = K4 - s4, _4 = S4 ^ nA2, F4 ^= kA2, E3[B4 + 28 >> 2] = _4 - F4, S4 = a4 ^ hA2, n4 ^= tA2, E3[B4 + 24 >> 2] = S4 - n4, a4 = k4 ^ rA2, c4 ^= wA2, E3[B4 + 20 >> 2] = a4 - c4, k4 = w4 ^ fA2, h4 ^= yA2, E3[B4 + 16 >> 2] = k4 - h4, w4 = D4 ^ aA2, e4 ^= DA2, E3[B4 + 12 >> 2] = w4 - e4, D4 = o4 ^ cA2, y4 ^= oA2, E3[B4 + 8 >> 2] = D4 - y4, o4 = g6 ^ EA2, Q4 ^= BA2, E3[B4 + 4 >> 2] = o4 - Q4, g6 = I7 ^ gA2, I7 = d4 ^ AA2, E3[B4 >> 2] = g6 - I7, E3[B4 + 276 >> 2] = f4 + N4, E3[B4 + 272 >> 2] = K4 + s4, E3[B4 + 268 >> 2] = F4 + _4, E3[B4 + 264 >> 2] = n4 + S4, E3[B4 + 260 >> 2] = c4 + a4, E3[B4 + 256 >> 2] = h4 + k4, E3[B4 + 248 >> 2] = D4 + y4, E3[B4 + 244 >> 2] = Q4 + o4, E3[B4 + 240 >> 2] = I7 + g6, E3[B4 + 252 >> 2] = e4 + w4, E3[B4 + 228 >> 2] = G4 + X2, E3[B4 + 224 >> 2] = b4 + O2, E3[B4 + 220 >> 2] = L4 + MA2, E3[B4 + 216 >> 2] = x4 + NA2, E3[B4 + 212 >> 2] = u4 + m4, E3[B4 + 208 >> 2] = R4 + q4, E3[B4 + 204 >> 2] = l3 + T2, E3[B4 + 200 >> 2] = P4 + z2, E3[B4 + 196 >> 2] = J4 + v4, E3[B4 + 192 >> 2] = H4 + Y4, M3(X2 = B4 + 96 | 0, b4 = B4 + 48 | 0, G4 = B4 + 240 | 0), M3(p4 = B4 + 192 | 0, p4, B4), U3(b4, B4), U3(B4, G4), f4 = E3[B4 + 192 >> 2], N4 = E3[B4 + 96 >> 2], K4 = E3[B4 + 196 >> 2], s4 = E3[B4 + 100 >> 2], _4 = E3[B4 + 200 >> 2], F4 = E3[B4 + 104 >> 2], S4 = E3[B4 + 204 >> 2], n4 = E3[B4 + 108 >> 2], a4 = E3[B4 + 208 >> 2], c4 = E3[B4 + 112 >> 2], k4 = E3[B4 + 212 >> 2], h4 = E3[B4 + 116 >> 2], w4 = E3[B4 + 216 >> 2], e4 = E3[B4 + 120 >> 2], D4 = E3[B4 + 220 >> 2], y4 = E3[B4 + 124 >> 2], o4 = E3[B4 + 224 >> 2], Q4 = E3[B4 + 128 >> 2], g6 = E3[B4 + 228 >> 2], I7 = E3[B4 + 132 >> 2], E3[B4 + 180 >> 2] = g6 + I7, E3[B4 + 176 >> 2] = Q4 + o4, E3[B4 + 172 >> 2] = D4 + y4, E3[B4 + 168 >> 2] = e4 + w4, E3[B4 + 164 >> 2] = h4 + k4, E3[B4 + 160 >> 2] = c4 + a4, E3[B4 + 156 >> 2] = n4 + S4, E3[B4 + 152 >> 2] = F4 + _4, E3[B4 + 148 >> 2] = K4 + s4, E3[B4 + 144 >> 2] = f4 + N4, E3[B4 + 228 >> 2] = I7 - g6, E3[B4 + 224 >> 2] = Q4 - o4, E3[B4 + 220 >> 2] = y4 - D4, E3[B4 + 216 >> 2] = e4 - w4, E3[B4 + 212 >> 2] = h4 - k4, E3[B4 + 208 >> 2] = c4 - a4, E3[B4 + 204 >> 2] = n4 - S4, E3[B4 + 200 >> 2] = F4 - _4, E3[B4 + 196 >> 2] = s4 - K4, E3[B4 + 192 >> 2] = N4 - f4, M3(G4, B4, b4), L4 = E3[B4 + 52 >> 2], n4 = E3[B4 + 4 >> 2], x4 = E3[B4 + 56 >> 2], a4 = E3[B4 + 8 >> 2], u4 = E3[B4 + 64 >> 2], w4 = E3[B4 + 16 >> 2], q4 = E3[B4 + 60 >> 2], e4 = E3[B4 + 12 >> 2], l3 = E3[B4 + 72 >> 2], D4 = E3[B4 + 24 >> 2], z2 = E3[B4 + 68 >> 2], y4 = E3[B4 + 20 >> 2], J4 = E3[B4 + 80 >> 2], o4 = E3[B4 + 32 >> 2], Y4 = E3[B4 + 76 >> 2], Q4 = E3[B4 + 28 >> 2], j2 = E3[B4 + 84 >> 2], I7 = E3[B4 + 36 >> 2], O2 = E3[B4 + 48 >> 2], g6 = E3[B4 >> 2] - O2 | 0, E3[B4 >> 2] = g6, I7 = I7 - j2 | 0, E3[B4 + 36 >> 2] = I7, d4 = Q4 - Y4 | 0, E3[B4 + 28 >> 2] = d4, H4 = o4 - J4 | 0, E3[B4 + 32 >> 2] = H4, c4 = y4 - z2 | 0, E3[B4 + 20 >> 2] = c4, k4 = D4 - l3 | 0, E3[B4 + 24 >> 2] = k4, h4 = e4 - q4 | 0, E3[B4 + 12 >> 2] = h4, w4 = w4 - u4 | 0, E3[B4 + 16 >> 2] = w4, e4 = a4 - x4 | 0, E3[B4 + 8 >> 2] = e4, o4 = n4 - L4 | 0, E3[B4 + 4 >> 2] = o4, U3(p4, p4), I7 = PA(I7, I7 >> 31, 121666, 0), Q4 = t3, T2 = I7, I7 = PA((33554431 & (Q4 = (f4 = I7 + 16777216 | 0) >>> 0 < 16777216 ? Q4 + 1 | 0 : Q4)) << 7 | f4 >>> 25, Q4 >> 25, 19, 0), y4 = t3, Q4 = I7, I7 = PA(g6, g6 >> 31, 121666, 0), R4 = t3 + y4 | 0, I7 = I7 >>> 0 > (Q4 = Q4 + I7 | 0) >>> 0 ? R4 + 1 | 0 : R4, g6 = (D4 = Q4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, N4 = Q4 - (-67108864 & D4) | 0, E3[B4 + 96 >> 2] = N4, y4 = PA(o4, o4 >> 31, 121666, 0), Q4 = t3, Q4 = (o4 = y4 + 16777216 | 0) >>> 0 < 16777216 ? Q4 + 1 | 0 : Q4, K4 = (y4 - (-33554432 & o4) | 0) + ((67108863 & g6) << 6 | D4 >>> 26) | 0, E3[B4 + 100 >> 2] = K4, R4 = (I7 = Q4) >> 25, Q4 = (33554431 & I7) << 7 | o4 >>> 25, g6 = PA(e4, e4 >> 31, 121666, 0) + Q4 | 0, I7 = R4 + t3 | 0, I7 = g6 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, y4 = (s4 = g6 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, _4 = g6 - (-67108864 & s4) | 0, E3[B4 + 104 >> 2] = _4, Q4 = PA(w4, w4 >> 31, 121666, 0), o4 = t3, g6 = PA(h4, h4 >> 31, 121666, 0), I7 = t3, m4 = Q4, P4 = g6, Q4 = (33554431 & (I7 = (F4 = g6 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | F4 >>> 25, I7 = (I7 >> 25) + o4 | 0, I7 = (g6 = m4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, o4 = (S4 = g6 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, n4 = g6 - (-67108864 & S4) | 0, E3[B4 + 112 >> 2] = n4, Q4 = PA(k4, k4 >> 31, 121666, 0), D4 = t3, g6 = PA(c4, c4 >> 31, 121666, 0), I7 = t3, m4 = Q4, v4 = g6, Q4 = (33554431 & (I7 = (a4 = g6 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | a4 >>> 25, I7 = (I7 >> 25) + D4 | 0, I7 = (g6 = m4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (c4 = g6 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, k4 = g6 - (-67108864 & c4) | 0, E3[B4 + 120 >> 2] = k4, D4 = PA(H4, H4 >> 31, 121666, 0), e4 = t3, g6 = PA(d4, d4 >> 31, 121666, 0), I7 = t3, H4 = g6, g6 = (33554431 & (I7 = (h4 = g6 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | h4 >>> 25, I7 = (I7 >> 25) + e4 | 0, I7 = g6 >>> 0 > (D4 = g6 + D4 | 0) >>> 0 ? I7 + 1 | 0 : I7, g6 = (w4 = D4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, e4 = D4 - (-67108864 & w4) | 0, E3[B4 + 128 >> 2] = e4, D4 = (y4 = P4 + ((67108863 & y4) << 6 | s4 >>> 26) | 0) - (-33554432 & F4) | 0, E3[B4 + 108 >> 2] = D4, y4 = (o4 = v4 + ((67108863 & o4) << 6 | S4 >>> 26) | 0) - (-33554432 & a4) | 0, E3[B4 + 116 >> 2] = y4, o4 = (I7 = H4 + ((67108863 & Q4) << 6 | c4 >>> 26) | 0) - (-33554432 & h4) | 0, E3[B4 + 124 >> 2] = o4, g6 = (g6 = T2 + ((67108863 & g6) << 6 | w4 >>> 26) | 0) - (-33554432 & f4) | 0, E3[B4 + 132 >> 2] = g6, U3(I7 = B4 + 144 | 0, I7), E3[B4 + 84 >> 2] = g6 + j2, E3[B4 + 80 >> 2] = e4 + J4, E3[B4 + 76 >> 2] = o4 + Y4, E3[B4 + 72 >> 2] = k4 + l3, E3[B4 + 68 >> 2] = y4 + z2, E3[B4 + 64 >> 2] = n4 + u4, E3[B4 + 60 >> 2] = D4 + q4, E3[B4 + 56 >> 2] = _4 + x4, E3[B4 + 52 >> 2] = K4 + L4, E3[B4 + 48 >> 2] = N4 + O2, g6 = FA2 - 1 | 0, M3(X2, B4 + 288 | 0, p4), M3(p4, B4, b4), FA2; ) ; + k4 = E3[B4 + 144 >> 2], N4 = E3[B4 + 240 >> 2], h4 = E3[B4 + 148 >> 2], K4 = E3[B4 + 244 >> 2], w4 = E3[B4 + 152 >> 2], s4 = E3[B4 + 248 >> 2], e4 = E3[B4 + 156 >> 2], _4 = E3[B4 + 252 >> 2], D4 = E3[B4 + 160 >> 2], F4 = E3[B4 + 256 >> 2], y4 = E3[B4 + 164 >> 2], S4 = E3[B4 + 260 >> 2], o4 = E3[B4 + 168 >> 2], n4 = E3[B4 + 264 >> 2], Q4 = E3[B4 + 172 >> 2], a4 = E3[B4 + 268 >> 2], g6 = E3[B4 + 176 >> 2], c4 = E3[B4 + 272 >> 2], f4 = 0 - Z2 | 0, I7 = E3[B4 + 276 >> 2], E3[B4 + 276 >> 2] = f4 & (I7 ^ E3[B4 + 180 >> 2]) ^ I7, E3[B4 + 272 >> 2] = c4 ^ f4 & (g6 ^ c4), E3[B4 + 268 >> 2] = a4 ^ f4 & (Q4 ^ a4), E3[B4 + 264 >> 2] = n4 ^ f4 & (o4 ^ n4), E3[B4 + 260 >> 2] = S4 ^ f4 & (y4 ^ S4), E3[B4 + 256 >> 2] = F4 ^ f4 & (D4 ^ F4), E3[B4 + 252 >> 2] = _4 ^ f4 & (e4 ^ _4), E3[B4 + 248 >> 2] = s4 ^ f4 & (w4 ^ s4), E3[B4 + 244 >> 2] = K4 ^ f4 & (h4 ^ K4), E3[B4 + 240 >> 2] = N4 ^ f4 & (k4 ^ N4), N4 = E3[B4 + 192 >> 2], k4 = E3[B4 + 96 >> 2], K4 = E3[B4 + 196 >> 2], h4 = E3[B4 + 100 >> 2], s4 = E3[B4 + 200 >> 2], w4 = E3[B4 + 104 >> 2], _4 = E3[B4 + 204 >> 2], e4 = E3[B4 + 108 >> 2], F4 = E3[B4 + 208 >> 2], D4 = E3[B4 + 112 >> 2], S4 = E3[B4 + 212 >> 2], y4 = E3[B4 + 116 >> 2], n4 = E3[B4 + 216 >> 2], o4 = E3[B4 + 120 >> 2], a4 = E3[B4 + 220 >> 2], Q4 = E3[B4 + 124 >> 2], c4 = E3[B4 + 224 >> 2], g6 = E3[B4 + 128 >> 2], I7 = E3[B4 + 228 >> 2], E3[B4 + 228 >> 2] = f4 & (I7 ^ E3[B4 + 132 >> 2]) ^ I7, E3[B4 + 224 >> 2] = c4 ^ f4 & (g6 ^ c4), E3[B4 + 220 >> 2] = a4 ^ f4 & (Q4 ^ a4), E3[B4 + 216 >> 2] = n4 ^ f4 & (o4 ^ n4), E3[B4 + 212 >> 2] = S4 ^ f4 & (y4 ^ S4), E3[B4 + 208 >> 2] = F4 ^ f4 & (D4 ^ F4), E3[B4 + 204 >> 2] = _4 ^ f4 & (e4 ^ _4), E3[B4 + 200 >> 2] = s4 ^ f4 & (w4 ^ s4), E3[B4 + 196 >> 2] = K4 ^ f4 & (h4 ^ K4), E3[B4 + 192 >> 2] = N4 ^ f4 & (k4 ^ N4), iA(p4, p4), M3(G4, G4, p4), eA(A8, G4), MI(SA2, 32), Q4 = 0; + } + return r3 = B4 + 368 | 0, 0 | Q4; + }, function(A8, I7) { + var g6, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, N4, K4; + return I7 |= 0, r3 = g6 = r3 - 304 | 0, C3[0 | (A8 |= 0)] = i3[0 | I7], C3[A8 + 1 | 0] = i3[I7 + 1 | 0], C3[A8 + 2 | 0] = i3[I7 + 2 | 0], C3[A8 + 3 | 0] = i3[I7 + 3 | 0], C3[A8 + 4 | 0] = i3[I7 + 4 | 0], C3[A8 + 5 | 0] = i3[I7 + 5 | 0], C3[A8 + 6 | 0] = i3[I7 + 6 | 0], C3[A8 + 7 | 0] = i3[I7 + 7 | 0], C3[A8 + 8 | 0] = i3[I7 + 8 | 0], C3[A8 + 9 | 0] = i3[I7 + 9 | 0], C3[A8 + 10 | 0] = i3[I7 + 10 | 0], C3[A8 + 11 | 0] = i3[I7 + 11 | 0], C3[A8 + 12 | 0] = i3[I7 + 12 | 0], C3[A8 + 13 | 0] = i3[I7 + 13 | 0], C3[A8 + 14 | 0] = i3[I7 + 14 | 0], C3[A8 + 15 | 0] = i3[I7 + 15 | 0], C3[A8 + 16 | 0] = i3[I7 + 16 | 0], C3[A8 + 17 | 0] = i3[I7 + 17 | 0], C3[A8 + 18 | 0] = i3[I7 + 18 | 0], C3[A8 + 19 | 0] = i3[I7 + 19 | 0], C3[A8 + 20 | 0] = i3[I7 + 20 | 0], C3[A8 + 21 | 0] = i3[I7 + 21 | 0], C3[A8 + 22 | 0] = i3[I7 + 22 | 0], C3[A8 + 23 | 0] = i3[I7 + 23 | 0], C3[A8 + 24 | 0] = i3[I7 + 24 | 0], C3[A8 + 25 | 0] = i3[I7 + 25 | 0], C3[A8 + 26 | 0] = i3[I7 + 26 | 0], C3[A8 + 27 | 0] = i3[I7 + 27 | 0], C3[A8 + 28 | 0] = i3[I7 + 28 | 0], C3[A8 + 29 | 0] = i3[I7 + 29 | 0], C3[A8 + 30 | 0] = i3[I7 + 30 | 0], I7 = i3[I7 + 31 | 0], C3[0 | A8] = 248 & i3[0 | A8], C3[A8 + 31 | 0] = 63 & I7 | 64, Z(g6 + 48 | 0, A8), I7 = E3[g6 + 128 >> 2], B4 = E3[g6 + 88 >> 2], Q4 = E3[g6 + 132 >> 2], o4 = E3[g6 + 92 >> 2], c4 = E3[g6 + 136 >> 2], D4 = E3[g6 + 96 >> 2], a4 = E3[g6 + 140 >> 2], y4 = E3[g6 + 100 >> 2], f4 = E3[g6 + 144 >> 2], e4 = E3[g6 + 104 >> 2], w4 = E3[g6 + 148 >> 2], t4 = E3[g6 + 108 >> 2], h4 = E3[g6 + 152 >> 2], k4 = E3[g6 + 112 >> 2], n4 = E3[g6 + 156 >> 2], s4 = E3[g6 + 116 >> 2], F4 = E3[g6 + 160 >> 2], S4 = E3[g6 + 120 >> 2], N4 = E3[g6 + 124 >> 2], K4 = E3[g6 + 164 >> 2], E3[g6 + 292 >> 2] = N4 + K4, E3[g6 + 288 >> 2] = F4 + S4, E3[g6 + 284 >> 2] = n4 + s4, E3[g6 + 280 >> 2] = h4 + k4, E3[g6 + 276 >> 2] = w4 + t4, E3[g6 + 272 >> 2] = f4 + e4, E3[g6 + 268 >> 2] = a4 + y4, E3[g6 + 264 >> 2] = c4 + D4, E3[g6 + 260 >> 2] = Q4 + o4, E3[g6 + 256 >> 2] = I7 + B4, E3[g6 + 244 >> 2] = K4 - N4, E3[g6 + 240 >> 2] = F4 - S4, E3[g6 + 236 >> 2] = n4 - s4, E3[g6 + 232 >> 2] = h4 - k4, E3[g6 + 228 >> 2] = w4 - t4, E3[g6 + 224 >> 2] = f4 - e4, E3[g6 + 220 >> 2] = a4 - y4, E3[g6 + 216 >> 2] = c4 - D4, E3[g6 + 212 >> 2] = Q4 - o4, E3[g6 + 208 >> 2] = I7 - B4, iA(I7 = g6 + 208 | 0, I7), M3(g6, g6 + 256 | 0, I7), eA(A8, g6), r3 = g6 + 304 | 0, 0; + }, function(A8, I7, g6, B4, Q4) { + A8 |= 0, B4 |= 0, Q4 |= 0; + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = o4 = r3 - 112 | 0, (I7 |= 0) | (g6 |= 0)) { + c4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, E3[o4 + 24 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, E3[o4 + 28 >> 2] = c4, c4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[o4 + 16 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[o4 + 20 >> 2] = c4, c4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, E3[o4 >> 2] = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, E3[o4 + 4 >> 2] = c4, c4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[o4 + 8 >> 2] = i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24, E3[o4 + 12 >> 2] = c4, Q4 = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, B4 = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[o4 + 104 >> 2] = 0, E3[o4 + 108 >> 2] = 0, E3[o4 + 96 >> 2] = Q4, E3[o4 + 100 >> 2] = B4; + A: { + if (!g6 & I7 >>> 0 >= 64 | g6) { + for (; l2(A8, o4 + 96 | 0, o4), B4 = i3[o4 + 104 | 0] + 1 | 0, C3[o4 + 104 | 0] = B4, B4 = i3[o4 + 105 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 105 | 0] = B4, B4 = i3[o4 + 106 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 106 | 0] = B4, B4 = i3[o4 + 107 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 107 | 0] = B4, B4 = i3[o4 + 108 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 108 | 0] = B4, B4 = i3[o4 + 109 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 109 | 0] = B4, B4 = i3[o4 + 110 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 110 | 0] = B4, C3[o4 + 111 | 0] = i3[o4 + 111 | 0] + (B4 >>> 8 | 0), A8 = A8 - -64 | 0, g6 = g6 - 1 | 0, !(g6 = (I7 = I7 + -64 | 0) >>> 0 < 4294967232 ? g6 + 1 | 0 : g6) & I7 >>> 0 > 63 | g6; ) ; + if (!(I7 | g6)) break A; + } + if (B4 = 0, l2(o4 + 32 | 0, o4 + 96 | 0, o4), c4 = 3 & I7, Q4 = 0, !g6 & I7 >>> 0 >= 4 | g6) for (g6 = 60 & I7, I7 = 0; D4 = a4 = o4 + 32 | 0, C3[A8 + Q4 | 0] = i3[D4 + Q4 | 0], C3[(y4 = 1 | Q4) + A8 | 0] = i3[D4 + y4 | 0], C3[(D4 = 2 | Q4) + A8 | 0] = i3[D4 + a4 | 0], C3[(D4 = 3 | Q4) + A8 | 0] = i3[D4 + (o4 + 32 | 0) | 0], Q4 = Q4 + 4 | 0, (0 | g6) != (0 | (I7 = I7 + 4 | 0)); ) ; + if (c4) for (; C3[A8 + Q4 | 0] = i3[(o4 + 32 | 0) + Q4 | 0], Q4 = Q4 + 1 | 0, (0 | c4) != (0 | (B4 = B4 + 1 | 0)); ) ; + } + MI(o4 + 32 | 0, 64), MI(o4, 32); + } + return r3 = o4 + 112 | 0, 0; + }, function(A8, I7, g6, B4, Q4, o4, c4, D4) { + A8 |= 0, I7 |= 0, Q4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0; + var a4, y4 = 0; + if (r3 = a4 = r3 - 112 | 0, (g6 |= 0) | (B4 |= 0)) { + y4 = i3[D4 + 28 | 0] | i3[D4 + 29 | 0] << 8 | i3[D4 + 30 | 0] << 16 | i3[D4 + 31 | 0] << 24, E3[a4 + 24 >> 2] = i3[D4 + 24 | 0] | i3[D4 + 25 | 0] << 8 | i3[D4 + 26 | 0] << 16 | i3[D4 + 27 | 0] << 24, E3[a4 + 28 >> 2] = y4, y4 = i3[D4 + 20 | 0] | i3[D4 + 21 | 0] << 8 | i3[D4 + 22 | 0] << 16 | i3[D4 + 23 | 0] << 24, E3[a4 + 16 >> 2] = i3[D4 + 16 | 0] | i3[D4 + 17 | 0] << 8 | i3[D4 + 18 | 0] << 16 | i3[D4 + 19 | 0] << 24, E3[a4 + 20 >> 2] = y4, y4 = i3[D4 + 4 | 0] | i3[D4 + 5 | 0] << 8 | i3[D4 + 6 | 0] << 16 | i3[D4 + 7 | 0] << 24, E3[a4 >> 2] = i3[0 | D4] | i3[D4 + 1 | 0] << 8 | i3[D4 + 2 | 0] << 16 | i3[D4 + 3 | 0] << 24, E3[a4 + 4 >> 2] = y4, y4 = i3[D4 + 12 | 0] | i3[D4 + 13 | 0] << 8 | i3[D4 + 14 | 0] << 16 | i3[D4 + 15 | 0] << 24, E3[a4 + 8 >> 2] = i3[D4 + 8 | 0] | i3[D4 + 9 | 0] << 8 | i3[D4 + 10 | 0] << 16 | i3[D4 + 11 | 0] << 24, E3[a4 + 12 >> 2] = y4, D4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, E3[a4 + 96 >> 2] = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, E3[a4 + 100 >> 2] = D4, C3[a4 + 104 | 0] = o4, C3[a4 + 111 | 0] = c4 >>> 24, C3[a4 + 110 | 0] = c4 >>> 16, C3[a4 + 109 | 0] = c4 >>> 8, C3[a4 + 108 | 0] = c4, C3[a4 + 107 | 0] = (16777215 & c4) << 8 | o4 >>> 24, C3[a4 + 106 | 0] = (65535 & c4) << 16 | o4 >>> 16, C3[a4 + 105 | 0] = (255 & c4) << 24 | o4 >>> 8; + A: { + if (!B4 & g6 >>> 0 >= 64 | B4) { + for (; ; ) { + for (D4 = 0, l2(a4 + 32 | 0, a4 + 96 | 0, a4); o4 = a4 + 32 | 0, C3[A8 + D4 | 0] = i3[o4 + D4 | 0] ^ i3[I7 + D4 | 0], C3[(Q4 = 1 | D4) + A8 | 0] = i3[Q4 + o4 | 0] ^ i3[I7 + Q4 | 0], 64 != (0 | (D4 = D4 + 2 | 0)); ) ; + if (Q4 = i3[a4 + 104 | 0] + 1 | 0, C3[a4 + 104 | 0] = Q4, Q4 = i3[a4 + 105 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 105 | 0] = Q4, Q4 = i3[a4 + 106 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 106 | 0] = Q4, Q4 = i3[a4 + 107 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 107 | 0] = Q4, Q4 = i3[a4 + 108 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 108 | 0] = Q4, Q4 = i3[a4 + 109 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 109 | 0] = Q4, Q4 = i3[a4 + 110 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 110 | 0] = Q4, C3[a4 + 111 | 0] = i3[a4 + 111 | 0] + (Q4 >>> 8 | 0), I7 = I7 - -64 | 0, A8 = A8 - -64 | 0, B4 = B4 - 1 | 0, !(!(B4 = (g6 = g6 + -64 | 0) >>> 0 < 4294967232 ? B4 + 1 | 0 : B4) & g6 >>> 0 > 63 | B4)) break; + } + if (!(g6 | B4)) break A; + } + if (D4 = 0, l2(a4 + 32 | 0, a4 + 96 | 0, a4), o4 = 1 & g6, 1 != (0 | g6) | B4) for (B4 = 62 & g6, Q4 = 0; c4 = a4 + 32 | 0, C3[A8 + D4 | 0] = i3[c4 + D4 | 0] ^ i3[I7 + D4 | 0], C3[(g6 = 1 | D4) + A8 | 0] = i3[g6 + c4 | 0] ^ i3[I7 + g6 | 0], D4 = D4 + 2 | 0, (0 | B4) != (0 | (Q4 = Q4 + 2 | 0)); ) ; + o4 && (C3[A8 + D4 | 0] = i3[(a4 + 32 | 0) + D4 | 0] ^ i3[I7 + D4 | 0]); + } + MI(a4 + 32 | 0, 64), MI(a4, 32); + } + return r3 = a4 + 112 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, E4, i4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0; + var c4, D4, a4 = 0; + if (D4 = a4 = r3, r3 = c4 = a4 - 192 & -32, b3(o4 |= 0, i4 |= 0, c4 - -64 | 0), o4 = 0, E4 >>> 0 <= 63) i4 = 0; + else for (a4 = 64; N3(Q4 + o4 | 0, c4 - -64 | 0), o4 = i4 = a4, (a4 = i4 - -64 | 0) >>> 0 <= E4 >>> 0; ) ; + if ((a4 = 32 | i4) >>> 0 > E4 >>> 0) o4 = i4; + else for (; x3(Q4 + i4 | 0, c4 - -64 | 0), o4 = a4, (a4 = (i4 = a4) + 32 | 0) >>> 0 <= E4 >>> 0; ) ; + if ((i4 = 31 & E4) && (VA((a4 = c4 + 32 | 0) | i4, 0, 32 - i4 | 0), TA(a4, Q4 + o4 | 0, i4), x3(a4, c4 - -64 | 0)), o4 = 32, i4 = 0, B4 >>> 0 < 32) Q4 = 0; + else for (; G3(A8 + i4 | 0, C4 + i4 | 0, c4 - -64 | 0), Q4 = o4, (o4 = (i4 = o4) + 32 | 0) >>> 0 <= B4 >>> 0; ) ; + return (i4 = 31 & B4) && (VA((o4 = c4 + 32 | 0) | i4, 0, 32 - i4 | 0), TA(o4, C4 + Q4 | 0, i4), G3(c4, o4, c4 - -64 | 0), TA(A8 + Q4 | 0, c4, i4)), K3(I7, g6, E4, B4, c4 - -64 | 0), r3 = D4, 0; + }, function(A8, I7, g6, C4, B4, Q4, E4, i4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0; + var c4, D4, a4 = 0; + if (D4 = a4 = r3, r3 = c4 = a4 - 224 & -32, b3(o4 |= 0, i4 |= 0, c4 + 96 | 0), o4 = 0, E4 >>> 0 <= 63) i4 = 0; + else for (a4 = 64; N3(Q4 + o4 | 0, c4 + 96 | 0), o4 = i4 = a4, (a4 = i4 - -64 | 0) >>> 0 <= E4 >>> 0; ) ; + if ((a4 = 32 | i4) >>> 0 > E4 >>> 0) o4 = i4; + else for (; x3(Q4 + i4 | 0, c4 + 96 | 0), o4 = a4, (a4 = (i4 = a4) + 32 | 0) >>> 0 <= E4 >>> 0; ) ; + (i4 = 31 & E4) && (VA((a4 = c4 - -64 | 0) | i4, 0, 32 - i4 | 0), TA(a4, Q4 + o4 | 0, i4), x3(a4, c4 + 96 | 0)); + A: { + I: { + g: { + C: { + B: { + if (A8) { + if (o4 = 32, g6 >>> 0 < 32) break B; + for (Q4 = 0; H3(A8 + Q4 | 0, I7 + Q4 | 0, c4 + 96 | 0), Q4 = i4 = o4, (o4 = i4 + 32 | 0) >>> 0 <= g6 >>> 0; ) ; + } else { + if (Q4 = 32, g6 >>> 0 < 32) break g; + for (o4 = 0; H3(c4 + 32 | 0, I7 + o4 | 0, c4 + 96 | 0), o4 = i4 = Q4, (Q4 = i4 + 32 | 0) >>> 0 <= g6 >>> 0; ) ; + } + if (!(Q4 = 31 & g6)) break A; + if (A8) break C; + break I; + } + if (i4 = 0, Q4 = g6, !g6) break A; + } + Y3(A8 + i4 | 0, I7 + i4 | 0, Q4, c4 + 96 | 0); + break A; + } + if (i4 = 0, Q4 = g6, !g6) break A; + } + Y3(c4 + 32 | 0, I7 + i4 | 0, Q4, c4 + 96 | 0); + } + K3(c4, B4, E4, g6, c4 + 96 | 0), i4 = -1; + A: { + I: { + if (I7 = B4 - 16 | 0) { + if (16 == (0 | I7)) break I; + break A; + } + i4 = rA(c4, C4); + break A; + } + i4 = UA(c4, C4); + } + return !A8 | !i4 || VA(A8, 0, g6), r3 = D4, 0 | i4; + }, function(A8, I7, g6, C4, B4, Q4, o4, c4, D4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0; + var a4, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0; + if (r3 = a4 = r3 - 528 | 0, S3(D4 |= 0, c4 |= 0, a4 + 400 | 0), D4 = 0, o4 >>> 0 <= 31) c4 = 0; + else for (f4 = 32; d3(Q4 + D4 | 0, a4 + 400 | 0), D4 = c4 = f4, (f4 = c4 + 32 | 0) >>> 0 <= o4 >>> 0; ) ; + if ((D4 = 16 | c4) >>> 0 <= o4 >>> 0) for (f4 = a4 + 416 | 0, w4 = a4 + 432 | 0, t4 = a4 + 448 | 0, e4 = a4 + 464 | 0, h4 = a4 + 480 | 0; k4 = i3[0 | (c4 = Q4 + c4 | 0)] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, n4 = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, s4 = i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, F4 = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, c4 = E3[h4 + 12 >> 2], E3[a4 + 520 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 524 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 512 >> 2] = E3[h4 >> 2], E3[a4 + 516 >> 2] = c4, c4 = E3[e4 + 12 >> 2], E3[a4 + 376 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 380 >> 2] = c4, c4 = E3[e4 + 4 >> 2], E3[a4 + 368 >> 2] = E3[e4 >> 2], E3[a4 + 372 >> 2] = c4, c4 = E3[h4 + 12 >> 2], E3[a4 + 360 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 364 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 352 >> 2] = E3[h4 >> 2], E3[a4 + 356 >> 2] = c4, aA(c4 = a4 + 496 | 0, a4 + 368 | 0, a4 + 352 | 0), y4 = E3[a4 + 508 >> 2], E3[h4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[h4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[h4 >> 2] = E3[a4 + 496 >> 2], E3[h4 + 4 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 344 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 348 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 336 >> 2] = E3[t4 >> 2], E3[a4 + 340 >> 2] = y4, y4 = E3[e4 + 12 >> 2], E3[a4 + 328 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 332 >> 2] = y4, y4 = E3[e4 + 4 >> 2], E3[a4 + 320 >> 2] = E3[e4 >> 2], E3[a4 + 324 >> 2] = y4, aA(c4, a4 + 336 | 0, a4 + 320 | 0), y4 = E3[a4 + 508 >> 2], E3[e4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[e4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[e4 >> 2] = E3[a4 + 496 >> 2], E3[e4 + 4 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 312 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 316 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 304 >> 2] = E3[w4 >> 2], E3[a4 + 308 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 296 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 300 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 288 >> 2] = E3[t4 >> 2], E3[a4 + 292 >> 2] = y4, aA(c4, a4 + 304 | 0, a4 + 288 | 0), y4 = E3[a4 + 508 >> 2], E3[t4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[t4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[t4 >> 2] = E3[a4 + 496 >> 2], E3[t4 + 4 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 280 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 284 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 272 >> 2] = E3[f4 >> 2], E3[a4 + 276 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 264 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 268 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 256 >> 2] = E3[w4 >> 2], E3[a4 + 260 >> 2] = y4, aA(c4, a4 + 272 | 0, a4 + 256 | 0), y4 = E3[a4 + 508 >> 2], E3[w4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[w4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[w4 >> 2] = E3[a4 + 496 >> 2], E3[w4 + 4 >> 2] = y4, y4 = E3[a4 + 412 >> 2], E3[a4 + 248 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 252 >> 2] = y4, y4 = E3[a4 + 404 >> 2], E3[a4 + 240 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 244 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 232 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 236 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 224 >> 2] = E3[f4 >> 2], E3[a4 + 228 >> 2] = y4, aA(c4, a4 + 240 | 0, a4 + 224 | 0), y4 = E3[a4 + 508 >> 2], E3[f4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[f4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[f4 >> 2] = E3[a4 + 496 >> 2], E3[f4 + 4 >> 2] = y4, y4 = E3[a4 + 524 >> 2], E3[a4 + 216 >> 2] = E3[a4 + 520 >> 2], E3[a4 + 220 >> 2] = y4, y4 = E3[a4 + 412 >> 2], E3[a4 + 200 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 204 >> 2] = y4, y4 = E3[a4 + 516 >> 2], E3[a4 + 208 >> 2] = E3[a4 + 512 >> 2], E3[a4 + 212 >> 2] = y4, y4 = E3[a4 + 404 >> 2], E3[a4 + 192 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 196 >> 2] = y4, aA(c4, a4 + 208 | 0, a4 + 192 | 0), E3[a4 + 412 >> 2] = F4 ^ E3[a4 + 508 >> 2], E3[a4 + 408 >> 2] = E3[a4 + 504 >> 2] ^ s4, E3[a4 + 404 >> 2] = E3[a4 + 500 >> 2] ^ n4, E3[a4 + 400 >> 2] = E3[a4 + 496 >> 2] ^ k4, (D4 = (c4 = D4) + 16 | 0) >>> 0 <= o4 >>> 0; ) ; + if ((D4 = 15 & o4) && (VA((f4 = a4 + 384 | 0) | D4, 0, 16 - D4 | 0), TA(f4, Q4 + c4 | 0, D4), D4 = E3[a4 + 384 >> 2], f4 = E3[a4 + 388 >> 2], w4 = E3[a4 + 392 >> 2], t4 = E3[a4 + 396 >> 2], c4 = E3[a4 + 492 >> 2], Q4 = E3[a4 + 488 >> 2], E3[a4 + 520 >> 2] = Q4, E3[a4 + 524 >> 2] = c4, e4 = E3[a4 + 476 >> 2], E3[a4 + 184 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 188 >> 2] = e4, E3[a4 + 168 >> 2] = Q4, E3[a4 + 172 >> 2] = c4, c4 = E3[a4 + 484 >> 2], Q4 = E3[a4 + 480 >> 2], E3[a4 + 512 >> 2] = Q4, E3[a4 + 516 >> 2] = c4, e4 = E3[a4 + 468 >> 2], E3[a4 + 176 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 180 >> 2] = e4, E3[a4 + 160 >> 2] = Q4, E3[a4 + 164 >> 2] = c4, aA(Q4 = a4 + 496 | 0, a4 + 176 | 0, a4 + 160 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 488 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 492 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 152 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 156 >> 2] = c4, c4 = E3[a4 + 476 >> 2], E3[a4 + 136 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 140 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 480 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 484 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 144 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 148 >> 2] = c4, c4 = E3[a4 + 468 >> 2], E3[a4 + 128 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 132 >> 2] = c4, aA(Q4, a4 + 144 | 0, a4 + 128 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 472 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 476 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 120 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 124 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 104 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 108 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 464 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 468 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 + 112 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 116 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 96 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 100 >> 2] = c4, aA(Q4, a4 + 112 | 0, a4 + 96 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 456 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 460 >> 2] = c4, c4 = E3[a4 + 428 >> 2], E3[a4 + 88 >> 2] = E3[a4 + 424 >> 2], E3[a4 + 92 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 72 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 76 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 448 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 452 >> 2] = c4, c4 = E3[a4 + 420 >> 2], E3[a4 + 80 >> 2] = E3[a4 + 416 >> 2], E3[a4 + 84 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 + 64 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 68 >> 2] = c4, aA(Q4, a4 + 80 | 0, a4 - -64 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 440 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 444 >> 2] = c4, c4 = E3[a4 + 412 >> 2], E3[a4 + 56 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 60 >> 2] = c4, c4 = E3[a4 + 428 >> 2], E3[a4 + 40 >> 2] = E3[a4 + 424 >> 2], E3[a4 + 44 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 432 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 436 >> 2] = c4, c4 = E3[a4 + 404 >> 2], E3[a4 + 48 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 52 >> 2] = c4, c4 = E3[a4 + 420 >> 2], E3[a4 + 32 >> 2] = E3[a4 + 416 >> 2], E3[a4 + 36 >> 2] = c4, aA(Q4, a4 + 48 | 0, a4 + 32 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 424 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 428 >> 2] = c4, c4 = E3[a4 + 524 >> 2], E3[a4 + 24 >> 2] = E3[a4 + 520 >> 2], E3[a4 + 28 >> 2] = c4, c4 = E3[a4 + 412 >> 2], E3[a4 + 8 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 12 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 416 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 420 >> 2] = c4, c4 = E3[a4 + 516 >> 2], E3[a4 + 16 >> 2] = E3[a4 + 512 >> 2], E3[a4 + 20 >> 2] = c4, c4 = E3[a4 + 404 >> 2], E3[a4 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 4 >> 2] = c4, aA(Q4, a4 + 16 | 0, a4), E3[a4 + 412 >> 2] = t4 ^ E3[a4 + 508 >> 2], E3[a4 + 408 >> 2] = w4 ^ E3[a4 + 504 >> 2], E3[a4 + 404 >> 2] = f4 ^ E3[a4 + 500 >> 2], E3[a4 + 400 >> 2] = D4 ^ E3[a4 + 496 >> 2]), f4 = 16, c4 = 0, B4 >>> 0 < 16) D4 = 0; + else for (; R3(A8 + c4 | 0, C4 + c4 | 0, a4 + 400 | 0), D4 = f4, (f4 = (c4 = f4) + 16 | 0) >>> 0 <= B4 >>> 0; ) ; + return (Q4 = 15 & B4) && (VA((c4 = a4 + 384 | 0) | Q4, 0, 16 - Q4 | 0), TA(c4, C4 + D4 | 0, Q4), R3(C4 = a4 + 512 | 0, c4, a4 + 400 | 0), TA(A8 + D4 | 0, C4, Q4)), J3(I7, g6, o4, B4, a4 + 400 | 0), r3 = a4 + 528 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, o4, c4, D4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0; + var a4, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0; + if (r3 = a4 = r3 - 544 | 0, S3(D4 |= 0, c4 |= 0, a4 + 432 | 0), D4 = 0, o4 >>> 0 <= 31) c4 = 0; + else for (f4 = 32; d3(Q4 + D4 | 0, a4 + 432 | 0), D4 = c4 = f4, (f4 = c4 + 32 | 0) >>> 0 <= o4 >>> 0; ) ; + if ((D4 = 16 | c4) >>> 0 <= o4 >>> 0) for (f4 = a4 + 448 | 0, w4 = a4 + 464 | 0, t4 = a4 + 480 | 0, e4 = a4 + 496 | 0, h4 = a4 + 512 | 0; k4 = i3[0 | (c4 = Q4 + c4 | 0)] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, n4 = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, s4 = i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, F4 = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, c4 = E3[h4 + 12 >> 2], E3[a4 + 392 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 396 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 384 >> 2] = E3[h4 >> 2], E3[a4 + 388 >> 2] = c4, c4 = E3[e4 + 12 >> 2], E3[a4 + 376 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 380 >> 2] = c4, c4 = E3[e4 + 4 >> 2], E3[a4 + 368 >> 2] = E3[e4 >> 2], E3[a4 + 372 >> 2] = c4, c4 = E3[h4 + 12 >> 2], E3[a4 + 360 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 364 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 352 >> 2] = E3[h4 >> 2], E3[a4 + 356 >> 2] = c4, aA(c4 = a4 + 528 | 0, a4 + 368 | 0, a4 + 352 | 0), y4 = E3[a4 + 540 >> 2], E3[h4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[h4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[h4 >> 2] = E3[a4 + 528 >> 2], E3[h4 + 4 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 344 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 348 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 336 >> 2] = E3[t4 >> 2], E3[a4 + 340 >> 2] = y4, y4 = E3[e4 + 12 >> 2], E3[a4 + 328 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 332 >> 2] = y4, y4 = E3[e4 + 4 >> 2], E3[a4 + 320 >> 2] = E3[e4 >> 2], E3[a4 + 324 >> 2] = y4, aA(c4, a4 + 336 | 0, a4 + 320 | 0), y4 = E3[a4 + 540 >> 2], E3[e4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[e4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[e4 >> 2] = E3[a4 + 528 >> 2], E3[e4 + 4 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 312 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 316 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 304 >> 2] = E3[w4 >> 2], E3[a4 + 308 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 296 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 300 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 288 >> 2] = E3[t4 >> 2], E3[a4 + 292 >> 2] = y4, aA(c4, a4 + 304 | 0, a4 + 288 | 0), y4 = E3[a4 + 540 >> 2], E3[t4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[t4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[t4 >> 2] = E3[a4 + 528 >> 2], E3[t4 + 4 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 280 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 284 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 272 >> 2] = E3[f4 >> 2], E3[a4 + 276 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 264 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 268 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 256 >> 2] = E3[w4 >> 2], E3[a4 + 260 >> 2] = y4, aA(c4, a4 + 272 | 0, a4 + 256 | 0), y4 = E3[a4 + 540 >> 2], E3[w4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[w4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[w4 >> 2] = E3[a4 + 528 >> 2], E3[w4 + 4 >> 2] = y4, y4 = E3[a4 + 444 >> 2], E3[a4 + 248 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 252 >> 2] = y4, y4 = E3[a4 + 436 >> 2], E3[a4 + 240 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 244 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 232 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 236 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 224 >> 2] = E3[f4 >> 2], E3[a4 + 228 >> 2] = y4, aA(c4, a4 + 240 | 0, a4 + 224 | 0), y4 = E3[a4 + 540 >> 2], E3[f4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[f4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[f4 >> 2] = E3[a4 + 528 >> 2], E3[f4 + 4 >> 2] = y4, y4 = E3[a4 + 396 >> 2], E3[a4 + 216 >> 2] = E3[a4 + 392 >> 2], E3[a4 + 220 >> 2] = y4, y4 = E3[a4 + 444 >> 2], E3[a4 + 200 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 204 >> 2] = y4, y4 = E3[a4 + 388 >> 2], E3[a4 + 208 >> 2] = E3[a4 + 384 >> 2], E3[a4 + 212 >> 2] = y4, y4 = E3[a4 + 436 >> 2], E3[a4 + 192 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 196 >> 2] = y4, aA(c4, a4 + 208 | 0, a4 + 192 | 0), E3[a4 + 444 >> 2] = F4 ^ E3[a4 + 540 >> 2], E3[a4 + 440 >> 2] = E3[a4 + 536 >> 2] ^ s4, E3[a4 + 436 >> 2] = E3[a4 + 532 >> 2] ^ n4, E3[a4 + 432 >> 2] = E3[a4 + 528 >> 2] ^ k4, (D4 = (c4 = D4) + 16 | 0) >>> 0 <= o4 >>> 0; ) ; + (D4 = 15 & o4) && (VA((f4 = a4 + 416 | 0) | D4, 0, 16 - D4 | 0), TA(f4, Q4 + c4 | 0, D4), D4 = E3[a4 + 416 >> 2], f4 = E3[a4 + 420 >> 2], w4 = E3[a4 + 424 >> 2], t4 = E3[a4 + 428 >> 2], c4 = E3[a4 + 524 >> 2], Q4 = E3[a4 + 520 >> 2], E3[a4 + 392 >> 2] = Q4, E3[a4 + 396 >> 2] = c4, e4 = E3[a4 + 508 >> 2], E3[a4 + 184 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 188 >> 2] = e4, E3[a4 + 168 >> 2] = Q4, E3[a4 + 172 >> 2] = c4, c4 = E3[a4 + 516 >> 2], Q4 = E3[a4 + 512 >> 2], E3[a4 + 384 >> 2] = Q4, E3[a4 + 388 >> 2] = c4, e4 = E3[a4 + 500 >> 2], E3[a4 + 176 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 180 >> 2] = e4, E3[a4 + 160 >> 2] = Q4, E3[a4 + 164 >> 2] = c4, aA(Q4 = a4 + 528 | 0, a4 + 176 | 0, a4 + 160 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 520 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 524 >> 2] = c4, c4 = E3[a4 + 492 >> 2], E3[a4 + 152 >> 2] = E3[a4 + 488 >> 2], E3[a4 + 156 >> 2] = c4, c4 = E3[a4 + 508 >> 2], E3[a4 + 136 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 140 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 512 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 516 >> 2] = c4, c4 = E3[a4 + 484 >> 2], E3[a4 + 144 >> 2] = E3[a4 + 480 >> 2], E3[a4 + 148 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 128 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 132 >> 2] = c4, aA(Q4, a4 + 144 | 0, a4 + 128 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 504 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 508 >> 2] = c4, c4 = E3[a4 + 476 >> 2], E3[a4 + 120 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 124 >> 2] = c4, c4 = E3[a4 + 492 >> 2], E3[a4 + 104 >> 2] = E3[a4 + 488 >> 2], E3[a4 + 108 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 496 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 500 >> 2] = c4, c4 = E3[a4 + 468 >> 2], E3[a4 + 112 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 116 >> 2] = c4, c4 = E3[a4 + 484 >> 2], E3[a4 + 96 >> 2] = E3[a4 + 480 >> 2], E3[a4 + 100 >> 2] = c4, aA(Q4, a4 + 112 | 0, a4 + 96 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 488 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 492 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 88 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 92 >> 2] = c4, c4 = E3[a4 + 476 >> 2], E3[a4 + 72 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 76 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 480 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 484 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 80 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 84 >> 2] = c4, c4 = E3[a4 + 468 >> 2], E3[a4 + 64 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 68 >> 2] = c4, aA(Q4, a4 + 80 | 0, a4 - -64 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 472 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 476 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 56 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 60 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 40 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 44 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 464 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 468 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 + 48 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 52 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 32 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 36 >> 2] = c4, aA(Q4, a4 + 48 | 0, a4 + 32 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 456 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 460 >> 2] = c4, c4 = E3[a4 + 396 >> 2], E3[a4 + 24 >> 2] = E3[a4 + 392 >> 2], E3[a4 + 28 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 8 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 12 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 448 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 452 >> 2] = c4, c4 = E3[a4 + 388 >> 2], E3[a4 + 16 >> 2] = E3[a4 + 384 >> 2], E3[a4 + 20 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 4 >> 2] = c4, aA(Q4, a4 + 16 | 0, a4), E3[a4 + 444 >> 2] = t4 ^ E3[a4 + 540 >> 2], E3[a4 + 440 >> 2] = w4 ^ E3[a4 + 536 >> 2], E3[a4 + 436 >> 2] = f4 ^ E3[a4 + 532 >> 2], E3[a4 + 432 >> 2] = D4 ^ E3[a4 + 528 >> 2]); + A: { + I: { + g: { + C: { + B: { + if (A8) { + if (f4 = 16, g6 >>> 0 < 16) break B; + for (D4 = 0; L3(A8 + D4 | 0, I7 + D4 | 0, a4 + 432 | 0), D4 = c4 = f4, (f4 = c4 + 16 | 0) >>> 0 <= g6 >>> 0; ) ; + } else { + if (D4 = 16, g6 >>> 0 < 16) break g; + for (f4 = 0; L3(a4 + 528 | 0, I7 + f4 | 0, a4 + 432 | 0), f4 = c4 = D4, (D4 = c4 + 16 | 0) >>> 0 <= g6 >>> 0; ) ; + } + if (!(D4 = 15 & g6)) break A; + if (A8) break C; + break I; + } + if (c4 = 0, !(D4 = g6)) break A; + } + u3(A8 + c4 | 0, I7 + c4 | 0, D4, a4 + 432 | 0); + break A; + } + if (c4 = 0, !(D4 = g6)) break A; + } + u3(a4 + 528 | 0, I7 + c4 | 0, D4, a4 + 432 | 0); + } + J3(a4 + 384 | 0, B4, o4, g6, a4 + 432 | 0), c4 = -1; + A: { + I: { + if (I7 = B4 - 16 | 0) { + if (16 == (0 | I7)) break I; + break A; + } + c4 = rA(a4 + 384 | 0, C4); + break A; + } + c4 = UA(a4 + 384 | 0, C4); + } + return !A8 | !c4 || VA(A8, 0, g6), r3 = a4 + 544 | 0, 0 | c4; + }, function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 + -64 | 0, (I7 |= 0) | (g6 |= 0) && (E3[Q4 + 8 >> 2] = 2036477234, E3[Q4 + 12 >> 2] = 1797285236, E3[Q4 >> 2] = 1634760805, E3[Q4 + 4 >> 2] = 857760878, E3[Q4 + 16 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[Q4 + 20 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[Q4 + 24 >> 2] = i3[B4 + 8 | 0] | i3[B4 + 9 | 0] << 8 | i3[B4 + 10 | 0] << 16 | i3[B4 + 11 | 0] << 24, E3[Q4 + 28 >> 2] = i3[B4 + 12 | 0] | i3[B4 + 13 | 0] << 8 | i3[B4 + 14 | 0] << 16 | i3[B4 + 15 | 0] << 24, E3[Q4 + 32 >> 2] = i3[B4 + 16 | 0] | i3[B4 + 17 | 0] << 8 | i3[B4 + 18 | 0] << 16 | i3[B4 + 19 | 0] << 24, E3[Q4 + 36 >> 2] = i3[B4 + 20 | 0] | i3[B4 + 21 | 0] << 8 | i3[B4 + 22 | 0] << 16 | i3[B4 + 23 | 0] << 24, E3[Q4 + 40 >> 2] = i3[B4 + 24 | 0] | i3[B4 + 25 | 0] << 8 | i3[B4 + 26 | 0] << 16 | i3[B4 + 27 | 0] << 24, B4 = i3[B4 + 28 | 0] | i3[B4 + 29 | 0] << 8 | i3[B4 + 30 | 0] << 16 | i3[B4 + 31 | 0] << 24, E3[Q4 + 48 >> 2] = 0, E3[Q4 + 52 >> 2] = 0, E3[Q4 + 44 >> 2] = B4, E3[Q4 + 56 >> 2] = i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24, E3[Q4 + 60 >> 2] = i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24, P3(Q4, A8 = VA(A8, 0, I7), A8, I7, g6), MI(Q4, 64)), r3 = Q4 - -64 | 0, 0; + }, function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 + -64 | 0, (I7 |= 0) | (g6 |= 0) && (E3[Q4 + 8 >> 2] = 2036477234, E3[Q4 + 12 >> 2] = 1797285236, E3[Q4 >> 2] = 1634760805, E3[Q4 + 4 >> 2] = 857760878, E3[Q4 + 16 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[Q4 + 20 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[Q4 + 24 >> 2] = i3[B4 + 8 | 0] | i3[B4 + 9 | 0] << 8 | i3[B4 + 10 | 0] << 16 | i3[B4 + 11 | 0] << 24, E3[Q4 + 28 >> 2] = i3[B4 + 12 | 0] | i3[B4 + 13 | 0] << 8 | i3[B4 + 14 | 0] << 16 | i3[B4 + 15 | 0] << 24, E3[Q4 + 32 >> 2] = i3[B4 + 16 | 0] | i3[B4 + 17 | 0] << 8 | i3[B4 + 18 | 0] << 16 | i3[B4 + 19 | 0] << 24, E3[Q4 + 36 >> 2] = i3[B4 + 20 | 0] | i3[B4 + 21 | 0] << 8 | i3[B4 + 22 | 0] << 16 | i3[B4 + 23 | 0] << 24, E3[Q4 + 40 >> 2] = i3[B4 + 24 | 0] | i3[B4 + 25 | 0] << 8 | i3[B4 + 26 | 0] << 16 | i3[B4 + 27 | 0] << 24, B4 = i3[B4 + 28 | 0] | i3[B4 + 29 | 0] << 8 | i3[B4 + 30 | 0] << 16 | i3[B4 + 31 | 0] << 24, E3[Q4 + 48 >> 2] = 0, E3[Q4 + 44 >> 2] = B4, E3[Q4 + 52 >> 2] = i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24, E3[Q4 + 56 >> 2] = i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24, E3[Q4 + 60 >> 2] = i3[C4 + 8 | 0] | i3[C4 + 9 | 0] << 8 | i3[C4 + 10 | 0] << 16 | i3[C4 + 11 | 0] << 24, P3(Q4, A8 = VA(A8, 0, I7), A8, I7, g6), MI(Q4, 64)), r3 = Q4 - -64 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, o4, c4) { + var D4; + return A8 |= 0, I7 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0, c4 |= 0, r3 = D4 = r3 + -64 | 0, (g6 |= 0) | (C4 |= 0) && (E3[D4 + 8 >> 2] = 2036477234, E3[D4 + 12 >> 2] = 1797285236, E3[D4 >> 2] = 1634760805, E3[D4 + 4 >> 2] = 857760878, E3[D4 + 16 >> 2] = i3[0 | c4] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, E3[D4 + 20 >> 2] = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, E3[D4 + 24 >> 2] = i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, E3[D4 + 28 >> 2] = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, E3[D4 + 32 >> 2] = i3[c4 + 16 | 0] | i3[c4 + 17 | 0] << 8 | i3[c4 + 18 | 0] << 16 | i3[c4 + 19 | 0] << 24, E3[D4 + 36 >> 2] = i3[c4 + 20 | 0] | i3[c4 + 21 | 0] << 8 | i3[c4 + 22 | 0] << 16 | i3[c4 + 23 | 0] << 24, E3[D4 + 40 >> 2] = i3[c4 + 24 | 0] | i3[c4 + 25 | 0] << 8 | i3[c4 + 26 | 0] << 16 | i3[c4 + 27 | 0] << 24, E3[D4 + 44 >> 2] = i3[c4 + 28 | 0] | i3[c4 + 29 | 0] << 8 | i3[c4 + 30 | 0] << 16 | i3[c4 + 31 | 0] << 24, E3[D4 + 48 >> 2] = Q4, E3[D4 + 52 >> 2] = o4, E3[D4 + 56 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[D4 + 60 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, P3(D4, I7, A8, g6, C4), MI(D4, 64)), r3 = D4 - -64 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, o4) { + var c4; + return A8 |= 0, I7 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0, r3 = c4 = r3 + -64 | 0, (g6 |= 0) | (C4 |= 0) && (E3[c4 + 8 >> 2] = 2036477234, E3[c4 + 12 >> 2] = 1797285236, E3[c4 >> 2] = 1634760805, E3[c4 + 4 >> 2] = 857760878, E3[c4 + 16 >> 2] = i3[0 | o4] | i3[o4 + 1 | 0] << 8 | i3[o4 + 2 | 0] << 16 | i3[o4 + 3 | 0] << 24, E3[c4 + 20 >> 2] = i3[o4 + 4 | 0] | i3[o4 + 5 | 0] << 8 | i3[o4 + 6 | 0] << 16 | i3[o4 + 7 | 0] << 24, E3[c4 + 24 >> 2] = i3[o4 + 8 | 0] | i3[o4 + 9 | 0] << 8 | i3[o4 + 10 | 0] << 16 | i3[o4 + 11 | 0] << 24, E3[c4 + 28 >> 2] = i3[o4 + 12 | 0] | i3[o4 + 13 | 0] << 8 | i3[o4 + 14 | 0] << 16 | i3[o4 + 15 | 0] << 24, E3[c4 + 32 >> 2] = i3[o4 + 16 | 0] | i3[o4 + 17 | 0] << 8 | i3[o4 + 18 | 0] << 16 | i3[o4 + 19 | 0] << 24, E3[c4 + 36 >> 2] = i3[o4 + 20 | 0] | i3[o4 + 21 | 0] << 8 | i3[o4 + 22 | 0] << 16 | i3[o4 + 23 | 0] << 24, E3[c4 + 40 >> 2] = i3[o4 + 24 | 0] | i3[o4 + 25 | 0] << 8 | i3[o4 + 26 | 0] << 16 | i3[o4 + 27 | 0] << 24, o4 = i3[o4 + 28 | 0] | i3[o4 + 29 | 0] << 8 | i3[o4 + 30 | 0] << 16 | i3[o4 + 31 | 0] << 24, E3[c4 + 48 >> 2] = Q4, E3[c4 + 44 >> 2] = o4, E3[c4 + 52 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[c4 + 56 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[c4 + 60 >> 2] = i3[B4 + 8 | 0] | i3[B4 + 9 | 0] << 8 | i3[B4 + 10 | 0] << 16 | i3[B4 + 11 | 0] << 24, P3(c4, I7, A8, g6, C4), MI(c4, 64)), r3 = c4 - -64 | 0, 0; + }], PI.grow = function(A8) { + var I7 = this.length; + return this.length = this.length + A8, I7; + }, PI.set = function(A8, I7) { + this[A8] = I7; + }, PI.get = function(A8) { + return this[A8]; + }, PI); + function RI() { + return g5.byteLength / 65536 | 0; + } + return { e: Object.create(Object.prototype, { grow: { value: function(A8) { + A8 |= 0; + var B4 = 0 | RI(), Q4 = B4 + A8 | 0; + if (B4 < Q4 && Q4 < 65536) { + var D4 = new ArrayBuffer(c3(Q4, 65536)); + new Int8Array(D4).set(C3), C3 = new Int8Array(D4), new Int16Array(D4), E3 = new Int32Array(D4), i3 = new Uint8Array(D4), new Uint16Array(D4), o3 = new Uint32Array(D4), new Float32Array(D4), new Float64Array(D4), g5 = D4, I6 = i3; + } + return B4; + } }, buffer: { get: function() { + return g5; + } } }), f: function() { + }, g: KI, h: YI, i: KI, j: _I, k: GI, l: SI, m: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | bA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, c4 |= 0, D4 |= 0, 36272); + }, n: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | qA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, D4 |= 0, a4 |= 0, 36272); + }, o: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | YA(A8 |= 0, I7 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36276); + }, p: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | XA(A8 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36276); + }, q: _I, r: YI, s: _I, t: _I, u: GI, v: FI, w: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | bA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, c4 |= 0, D4 |= 0, 36280); + }, x: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | qA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, D4 |= 0, a4 |= 0, 36280); + }, y: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | YA(A8 |= 0, I7 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36284); + }, z: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | XA(A8 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36284); + }, A: YI, B: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | JA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, (A8 = 0) | (B4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, D4 |= 0, a4 |= 0); + }, C: function(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return A8 |= 0, I7 |= 0, C4 |= 0, o4 |= 0, D4 |= 0, o4 |= D4 = 0, !(B4 |= 0) & (C4 |= D4) >>> 0 < 4294967280 ? (JA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, i4 |= 0, o4, c4 |= 0, a4 |= 0, y4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8, E3[I7 + 4 >> 2] = B4)) : (iI(), Q3()), 0; + }, D: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | HA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, (A8 = 0) | (B4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, D4 |= 0, a4 |= 0); + }, E: function(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return A8 |= 0, I7 |= 0, C4 |= 0, o4 |= 0, D4 |= 0, o4 |= D4 = 0, !(B4 |= 0) & (C4 |= D4) >>> 0 < 4294967280 ? (HA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, i4 |= 0, o4, c4 |= 0, a4 |= 0, y4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8, E3[I7 + 4 >> 2] = B4)) : (iI(), Q3()), 0; + }, F: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | GA(A8 |= 0, g6 |= 0, (A8 = 0) | (C4 |= 0), B4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, c4 |= 0, D4 |= 0); + }, G: function(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, o4 |= 0, o4 |= 0, g6 = -1, !(Q4 |= 0) & (B4 |= 0) >>> 0 >= 16 | Q4 && (g6 = GA(A8 |= 0, C4, B4 - 16 | 0, Q4 - (B4 >>> 0 < 16) | 0, (C4 + B4 | 0) - 16 | 0, i4 |= 0, o4, c4 |= 0, D4 |= 0, a4 |= 0)), I7 && (E3[I7 >> 2] = g6 ? 0 : B4 - 16 | 0, E3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (B4 >>> 0 < 16) | 0), 0 | g6; + }, H: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | pA(A8 |= 0, g6 |= 0, (A8 = 0) | (C4 |= 0), B4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, c4 |= 0, D4 |= 0); + }, I: function(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, o4 |= 0, o4 |= 0, g6 = -1, !(Q4 |= 0) & (B4 |= 0) >>> 0 >= 16 | Q4 && (g6 = pA(A8 |= 0, C4, B4 - 16 | 0, Q4 - (B4 >>> 0 < 16) | 0, (C4 + B4 | 0) - 16 | 0, i4 |= 0, o4, c4 |= 0, D4 |= 0, a4 |= 0)), I7 && (E3[I7 >> 2] = g6 ? 0 : B4 - 16 | 0, E3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (B4 >>> 0 < 16) | 0), 0 | g6; + }, J: _I, K: function() { + return 12; + }, L: YI, M: KI, N: HI, O: FI, P: _I, Q: UI, R: YI, S: KI, T: HI, U: FI, V: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | sA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, (A8 = 0) | (B4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, D4 |= 0, a4 |= 0); + }, W: function(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return A8 |= 0, I7 |= 0, C4 |= 0, o4 |= 0, D4 |= 0, o4 |= D4 = 0, !(B4 |= 0) & (C4 |= D4) >>> 0 < 4294967280 ? (sA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, i4 |= 0, o4, c4 |= 0, a4 |= 0, y4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8, E3[I7 + 4 >> 2] = B4)) : (iI(), Q3()), 0; + }, X: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | nA(A8 |= 0, g6 |= 0, (A8 = 0) | (C4 |= 0), B4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, c4 |= 0, D4 |= 0); + }, Y: function(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, o4 |= 0, o4 |= 0, g6 = -1, !(Q4 |= 0) & (B4 |= 0) >>> 0 >= 16 | Q4 && (g6 = nA(A8 |= 0, C4, B4 - 16 | 0, Q4 - (B4 >>> 0 < 16) | 0, (C4 + B4 | 0) - 16 | 0, i4 |= 0, o4, c4 |= 0, D4 |= 0, a4 |= 0)), I7 && (E3[I7 >> 2] = g6 ? 0 : B4 - 16 | 0, E3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (B4 >>> 0 < 16) | 0), 0 | g6; + }, Z: _I, _: pI, $: YI, aa: KI, ba: HI, ca: FI, da: _I, ea: _I, fa: function(A8, I7, g6, B4, Q4) { + var i4; + return A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, r3 = i4 = r3 - 480 | 0, wA(i4, Q4 |= 0, 32), tI(i4, I7, g6, B4), WA(i4, i4 + 416 | 0), I7 = E3[i4 + 444 >> 2], g6 = E3[i4 + 440 >> 2], C3[A8 + 24 | 0] = g6, C3[A8 + 25 | 0] = g6 >>> 8, C3[A8 + 26 | 0] = g6 >>> 16, C3[A8 + 27 | 0] = g6 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[i4 + 436 >> 2], g6 = E3[i4 + 432 >> 2], C3[A8 + 16 | 0] = g6, C3[A8 + 17 | 0] = g6 >>> 8, C3[A8 + 18 | 0] = g6 >>> 16, C3[A8 + 19 | 0] = g6 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[i4 + 428 >> 2], g6 = E3[i4 + 424 >> 2], C3[A8 + 8 | 0] = g6, C3[A8 + 9 | 0] = g6 >>> 8, C3[A8 + 10 | 0] = g6 >>> 16, C3[A8 + 11 | 0] = g6 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[i4 + 420 >> 2], g6 = E3[i4 + 416 >> 2], C3[0 | A8] = g6, C3[A8 + 1 | 0] = g6 >>> 8, C3[A8 + 2 | 0] = g6 >>> 16, C3[A8 + 3 | 0] = g6 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, r3 = i4 + 480 | 0, 0; + }, ga: function(A8, I7, g6, C4, B4) { + var Q4, i4; + return A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, r3 = Q4 = r3 - 512 | 0, wA(i4 = Q4 + 32 | 0, B4 |= 0, 32), tI(i4, I7, g6, C4), WA(i4, Q4 + 448 | 0), I7 = E3[Q4 + 476 >> 2], E3[Q4 + 24 >> 2] = E3[Q4 + 472 >> 2], E3[Q4 + 28 >> 2] = I7, I7 = E3[Q4 + 468 >> 2], E3[Q4 + 16 >> 2] = E3[Q4 + 464 >> 2], E3[Q4 + 20 >> 2] = I7, I7 = E3[Q4 + 460 >> 2], E3[Q4 + 8 >> 2] = E3[Q4 + 456 >> 2], E3[Q4 + 12 >> 2] = I7, I7 = E3[Q4 + 452 >> 2], E3[Q4 >> 2] = E3[Q4 + 448 >> 2], E3[Q4 + 4 >> 2] = I7, I7 = UA(A8, Q4), g6 = NA(Q4, A8, 32), r3 = Q4 + 512 | 0, ((0 | A8) == (0 | Q4) ? -1 : I7) | g6; + }, ha: FI, ia: _I, ja: _I, ka: _I, la: _I, ma: pI, na: KI, oa: HI, pa: function(A8, I7, g6) { + A8 |= 0, I7 |= 0; + var B4, Q4 = 0; + return r3 = B4 = r3 + -64 | 0, FA(B4, g6 |= 0, 32, 0), g6 = E3[B4 + 28 >> 2], Q4 = E3[B4 + 24 >> 2], C3[I7 + 24 | 0] = Q4, C3[I7 + 25 | 0] = Q4 >>> 8, C3[I7 + 26 | 0] = Q4 >>> 16, C3[I7 + 27 | 0] = Q4 >>> 24, C3[I7 + 28 | 0] = g6, C3[I7 + 29 | 0] = g6 >>> 8, C3[I7 + 30 | 0] = g6 >>> 16, C3[I7 + 31 | 0] = g6 >>> 24, g6 = E3[B4 + 20 >> 2], Q4 = E3[B4 + 16 >> 2], C3[I7 + 16 | 0] = Q4, C3[I7 + 17 | 0] = Q4 >>> 8, C3[I7 + 18 | 0] = Q4 >>> 16, C3[I7 + 19 | 0] = Q4 >>> 24, C3[I7 + 20 | 0] = g6, C3[I7 + 21 | 0] = g6 >>> 8, C3[I7 + 22 | 0] = g6 >>> 16, C3[I7 + 23 | 0] = g6 >>> 24, g6 = E3[B4 + 12 >> 2], Q4 = E3[B4 + 8 >> 2], C3[I7 + 8 | 0] = Q4, C3[I7 + 9 | 0] = Q4 >>> 8, C3[I7 + 10 | 0] = Q4 >>> 16, C3[I7 + 11 | 0] = Q4 >>> 24, C3[I7 + 12 | 0] = g6, C3[I7 + 13 | 0] = g6 >>> 8, C3[I7 + 14 | 0] = g6 >>> 16, C3[I7 + 15 | 0] = g6 >>> 24, g6 = E3[B4 + 4 >> 2], Q4 = E3[B4 >> 2], C3[0 | I7] = Q4, C3[I7 + 1 | 0] = Q4 >>> 8, C3[I7 + 2 | 0] = Q4 >>> 16, C3[I7 + 3 | 0] = Q4 >>> 24, C3[I7 + 4 | 0] = g6, C3[I7 + 5 | 0] = g6 >>> 8, C3[I7 + 6 | 0] = g6 >>> 16, C3[I7 + 7 | 0] = g6 >>> 24, MI(B4, 64), A8 = hI(A8, I7), r3 = B4 - -64 | 0, 0 | A8; + }, qa: cI, ra: OA, sa: $A, ta: function(A8, I7, g6, C4, B4, Q4, E4, i4) { + A8 |= 0, I7 |= 0, g6 |= 0, Q4 |= 0; + var o4, c4 = 0; + return c4 = C4 |= 0, C4 = B4 |= 0, o4 = 0 | c4, r3 = c4 = r3 - 32 | 0, B4 = -1, OA(c4, E4 |= 0, i4 |= 0) || (B4 = tA(A8, I7, g6, o4, C4, Q4, c4), MI(c4, 32)), r3 = c4 + 32 | 0, 0 | B4; + }, ua: function(A8, I7, g6, C4, B4, E4) { + return A8 |= 0, I7 |= 0, B4 |= 0, E4 |= 0, !(C4 |= 0) & (g6 |= 0) >>> 0 >= 4294967280 | C4 && (iI(), Q3()), 0 | tA(A8 + 16 | 0, A8, I7, g6, C4, B4, E4); + }, va: function(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | zA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + }, wa: AI, xa: function(A8, I7, g6, C4, B4, Q4, E4, i4) { + A8 |= 0, I7 |= 0, g6 |= 0, Q4 |= 0; + var o4, c4 = 0; + return c4 = C4 |= 0, C4 = B4 |= 0, o4 = 0 | c4, r3 = c4 = r3 - 32 | 0, B4 = -1, OA(c4, E4 |= 0, i4 |= 0) || (B4 = kA(A8, I7, g6, o4, C4, Q4, c4), MI(c4, 32)), r3 = c4 + 32 | 0, 0 | B4; + }, ya: jA, za: function(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | xA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + }, Aa: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, Q4 |= 0; + var i4, o4, c4, D4, a4 = 0, y4 = 0; + return a4 = g6 |= 0, g6 = B4 |= 0, D4 = 0 | a4, a4 = B4 = r3, r3 = i4 = B4 - 512 & -64, B4 = -1, cI(o4 = i4 - -64 | 0, c4 = i4 + 32 | 0) || (j(B4 = i4 + 128 | 0, 0, 0, 24), cA(B4, o4, 32, 0), cA(B4, Q4, 32, 0), ZA(B4, y4 = i4 + 96 | 0, 24), B4 = zA(A8 + 32 | 0, I7, D4, g6, y4, Q4, c4), I7 = E3[i4 + 92 >> 2], g6 = E3[i4 + 88 >> 2], C3[A8 + 24 | 0] = g6, C3[A8 + 25 | 0] = g6 >>> 8, C3[A8 + 26 | 0] = g6 >>> 16, C3[A8 + 27 | 0] = g6 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[i4 + 84 >> 2], g6 = E3[i4 + 80 >> 2], C3[A8 + 16 | 0] = g6, C3[A8 + 17 | 0] = g6 >>> 8, C3[A8 + 18 | 0] = g6 >>> 16, C3[A8 + 19 | 0] = g6 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[i4 + 76 >> 2], g6 = E3[i4 + 72 >> 2], C3[A8 + 8 | 0] = g6, C3[A8 + 9 | 0] = g6 >>> 8, C3[A8 + 10 | 0] = g6 >>> 16, C3[A8 + 11 | 0] = g6 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[i4 + 68 >> 2], g6 = E3[i4 + 64 >> 2], C3[0 | A8] = g6, C3[A8 + 1 | 0] = g6 >>> 8, C3[A8 + 2 | 0] = g6 >>> 16, C3[A8 + 3 | 0] = g6 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, MI(c4, 32), MI(o4, 32), MI(y4, 24)), r3 = a4, 0 | B4; + }, Ba: function(A8, I7, g6, C4, B4, Q4) { + A8 |= 0, I7 |= 0, B4 |= 0, Q4 |= 0; + var E4, i4, o4 = 0; + return i4 = o4 = r3, r3 = E4 = o4 - 448 & -64, o4 = -1, !(C4 |= 0) & (g6 |= 0) >>> 0 >= 48 | C4 && (j(o4 = E4 - -64 | 0, 0, 0, 24), cA(o4, I7, 32, 0), cA(o4, B4, 32, 0), ZA(o4, B4 = E4 + 32 | 0, 24), o4 = xA(A8, I7 + 32 | 0, g6 - 32 | 0, C4 - (g6 >>> 0 < 32) | 0, B4, I7, Q4)), r3 = i4, 0 | o4; + }, Ca: function() { + return 48; + }, Da: KI, Ea: JI, Fa: _I, Ga: KI, Ha: JI, Ia: _I, Ja: function() { + return 384; + }, Ka: function(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | CA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + }, La: j, Ma: function(A8, I7, g6, C4) { + return 0 | cA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0); + }, Na: ZA, Oa: FI, Pa: JI, Qa: function(A8, I7, g6, C4) { + return 0 | FA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0); + }, Ra: KI, Sa: JI, Ta: UI, Ua: _I, Va: function(A8, I7, g6, C4, B4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, o4 |= 0; + var c4, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0; + return r3 = c4 = r3 - 32 | 0, D4 = i3[0 | (B4 |= 0)] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, B4 = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[c4 + 24 >> 2] = 0, E3[c4 + 28 >> 2] = 0, E3[c4 + 16 >> 2] = D4, E3[c4 + 20 >> 2] = B4, E3[c4 + 8 >> 2] = 0, E3[c4 + 12 >> 2] = 0, E3[(B4 = c4) >> 2] = g6, E3[B4 + 4 >> 2] = C4, I7 - 65 >>> 0 <= 4294967246 ? (E3[9280] = 28, A8 = -1) : I7 - 65 >>> 0 < 4294967232 ? A8 = -1 : (r3 = B4 = (y4 = r3) - 512 & -64, !o4 | !A8 | ((a4 = 255 & I7) - 65 & 255) >>> 0 <= 191 ? (iI(), Q3()) : (C4 = c4 + 16 | 0, c4 ? (f4 = 725511199 ^ (i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24), e4 = -1694144372 ^ (i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24), g6 = -1377402159 ^ (i3[0 | c4] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24), I7 = 1359893119 ^ (i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24)) : (f4 = 725511199, e4 = -1694144372, g6 = -1377402159, I7 = 1359893119), C4 ? (w4 = 327033209 ^ (i3[C4 + 8 | 0] | i3[C4 + 9 | 0] << 8 | i3[C4 + 10 | 0] << 16 | i3[C4 + 11 | 0] << 24), t4 = 1541459225 ^ (i3[C4 + 12 | 0] | i3[C4 + 13 | 0] << 8 | i3[C4 + 14 | 0] << 16 | i3[C4 + 15 | 0] << 24), D4 = -79577749 ^ (i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24), C4 = 528734635 ^ (i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24)) : (w4 = 327033209, t4 = 1541459225, D4 = -79577749, C4 = 528734635), VA(B4 - -64 | 0, 0, 293), E3[B4 + 56 >> 2] = w4, E3[B4 + 60 >> 2] = t4, E3[B4 + 48 >> 2] = D4, E3[B4 + 52 >> 2] = C4, E3[B4 + 40 >> 2] = f4, E3[B4 + 44 >> 2] = e4, E3[B4 + 32 >> 2] = g6, E3[B4 + 36 >> 2] = I7, E3[B4 + 24 >> 2] = 1595750129, E3[B4 + 28 >> 2] = -1521486534, E3[B4 + 16 >> 2] = -23791573, E3[B4 + 20 >> 2] = 1013904242, E3[B4 + 8 >> 2] = -2067093701, E3[B4 + 12 >> 2] = -1150833019, E3[B4 >> 2] = -222443256 ^ (8192 | a4), E3[B4 + 4 >> 2] = 1779033703, VA(32 + (I7 = B4 + 384 | 0) | 0, 0, 96), TA(I7, o4, 32), TA(B4 + 96 | 0, I7, 128), E3[B4 + 352 >> 2] = 128, MI(I7, 128), m3(B4, A8, a4), r3 = y4), A8 = 0), r3 = c4 + 32 | 0, 0 | A8; + }, Wa: FI, Xa: function(A8, I7, g6) { + return 0 | gA(A8 |= 0, I7 |= 0, g6 |= 0); + }, Ya: function(A8, I7, g6) { + return 0 | kI(A8 |= 0, I7 |= 0, g6 |= 0); + }, Za: function(A8, I7) { + return II(A8 |= 0, I7 |= 0), MI(A8, 4), 0; + }, _a: function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 - 208 | 0, gA(Q4, I7 |= 0, g6 |= 0), kI(Q4, C4, B4), II(Q4, A8), MI(Q4, 4), r3 = Q4 + 208 | 0, 0; + }, $a: FI, ab: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0; + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = o4 = r3 - 256 | 0, C3[o4 + 15 | 0] = 1, I7 >>> 0 <= 8160) { + if (I7 >>> 0 >= 32) for (y4 = A8 - 32 | 0, c4 = 32; a4 = c4, gA(c4 = o4 + 48 | 0, Q4, 32), D4 && kI(c4, D4 + y4 | 0, 32), kI(c4 = o4 + 48 | 0, g6, B4), kI(c4, o4 + 15 | 0, 1), II(c4, A8 + D4 | 0), C3[o4 + 15 | 0] = i3[o4 + 15 | 0] + 1, (c4 = (D4 = a4) + 32 | 0) >>> 0 <= I7 >>> 0; ) ; + (D4 = 31 & I7) && (gA(I7 = o4 + 48 | 0, Q4, 32), a4 && kI(I7, (A8 + a4 | 0) - 32 | 0, 32), kI(I7 = o4 + 48 | 0, g6, B4), kI(I7, o4 + 15 | 0, 1), II(g6 = I7, I7 = o4 + 16 | 0), TA(A8 + a4 | 0, I7, D4), MI(I7, 32)), MI(o4 + 48 | 0, 208), A8 = 0; + } else E3[9280] = 28, A8 = -1; + return r3 = o4 + 256 | 0, 0 | A8; + }, bb: _I, cb: YI, db: function() { + return 8160; + }, eb: NI, fb: function(A8, I7, g6) { + return 0 | wA(A8 |= 0, I7 |= 0, g6 |= 0); + }, gb: function(A8, I7, g6) { + return 0 | tI(A8 |= 0, I7 |= 0, g6 |= 0, 0); + }, hb: function(A8, I7) { + return WA(A8 |= 0, I7 |= 0), MI(A8, 4), 0; + }, ib: function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 - 416 | 0, wA(Q4, I7 |= 0, g6 |= 0), tI(Q4, C4, B4, 0), WA(Q4, A8), MI(Q4, 4), r3 = Q4 + 416 | 0, 0; + }, jb: function(A8) { + LA(A8 |= 0, 64); + }, kb: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0; + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = o4 = r3 - 496 | 0, C3[o4 + 15 | 0] = 1, I7 >>> 0 <= 16320) { + if (I7 >>> 0 >= 64) for (y4 = A8 + -64 | 0, c4 = 64; a4 = c4, wA(c4 = o4 + 80 | 0, Q4, 64), D4 && tI(c4, D4 + y4 | 0, 64, 0), tI(c4 = o4 + 80 | 0, g6, B4, 0), tI(c4, o4 + 15 | 0, 1, 0), WA(c4, A8 + D4 | 0), C3[o4 + 15 | 0] = i3[o4 + 15 | 0] + 1, (c4 = (D4 = a4) - -64 | 0) >>> 0 <= I7 >>> 0; ) ; + (D4 = 63 & I7) && (wA(I7 = o4 + 80 | 0, Q4, 64), a4 && tI(I7, (A8 + a4 | 0) - 64 | 0, 64, 0), tI(I7 = o4 + 80 | 0, g6, B4, 0), tI(I7, o4 + 15 | 0, 1, 0), WA(g6 = I7, I7 = o4 + 16 | 0), TA(A8 + a4 | 0, I7, D4), MI(I7, 64)), MI(o4 + 80 | 0, 416), A8 = 0; + } else E3[9280] = 28, A8 = -1; + return r3 = o4 + 496 | 0, 0 | A8; + }, lb: JI, mb: YI, nb: function() { + return 16320; + }, ob: function() { + return 416; + }, pb: function(A8, I7, g6) { + return A8 |= 0, CA(I7 |= 0, 32, g6 |= 0, 32, 0, 0, 0), 0 | fI(A8, I7); + }, qb: function(A8, I7) { + return A8 |= 0, LA(I7 |= 0, 32), 0 | fI(A8, I7); + }, rb: function(A8, I7, g6, B4, E4) { + I7 |= 0, g6 |= 0, B4 |= 0, E4 |= 0; + var o4, c4, D4 = 0, a4 = 0, y4 = 0; + if (c4 = D4 = r3, r3 = D4 = D4 - 512 & -64, o4 = (A8 |= 0) || I7) { + if (y4 = -1, !EI(a4 = D4 + 96 | 0, B4, E4)) { + for (B4 = I7 || A8, A8 = 0, j(I7 = D4 + 128 | 0, 0, 0, 64), cA(I7, a4, 32, 0), MI(a4, 32), cA(I7, g6, 32, 0), cA(I7, E4, 32, 0), ZA(I7, D4 + 32 | 0, 64), MI(I7, 384); g6 = (I7 = D4 + 32 | 0) + A8 | 0, C3[A8 + o4 | 0] = i3[0 | g6], C3[A8 + B4 | 0] = i3[g6 + 32 | 0], C3[(g6 = 1 | A8) + o4 | 0] = i3[I7 + g6 | 0], C3[g6 + B4 | 0] = i3[I7 + (33 | A8) | 0], 32 != (0 | (A8 = A8 + 2 | 0)); ) ; + MI(I7, 64), y4 = 0; + } + return r3 = c4, 0 | y4; + } + iI(), Q3(); + }, sb: function(A8, I7, g6, B4, E4) { + I7 |= 0, g6 |= 0, B4 |= 0, E4 |= 0; + var o4, c4, D4 = 0, a4 = 0, y4 = 0; + if (c4 = D4 = r3, r3 = D4 = D4 - 512 & -64, o4 = (A8 |= 0) || I7) { + if (y4 = -1, !EI(a4 = D4 + 96 | 0, B4, E4)) { + for (B4 = I7 || A8, A8 = 0, j(I7 = D4 + 128 | 0, 0, 0, 64), cA(I7, a4, 32, 0), MI(a4, 32), cA(I7, E4, 32, 0), cA(I7, g6, 32, 0), ZA(I7, D4 + 32 | 0, 64), MI(I7, 384); g6 = (I7 = D4 + 32 | 0) + A8 | 0, C3[A8 + B4 | 0] = i3[0 | g6], C3[A8 + o4 | 0] = i3[g6 + 32 | 0], C3[(g6 = 1 | A8) + B4 | 0] = i3[I7 + g6 | 0], C3[g6 + o4 | 0] = i3[I7 + (33 | A8) | 0], 32 != (0 | (A8 = A8 + 2 | 0)); ) ; + MI(I7, 64), y4 = 0; + } + return r3 = c4, 0 | y4; + } + iI(), Q3(); + }, tb: _I, ub: _I, vb: _I, wb: _I, xb: fI, yb: EI, zb: _I, Ab: _I, Bb: _I, Cb: pI, Db: KI, Eb: HI, Fb: FI, Gb: $A, Hb: function(A8, I7, g6, C4, B4, E4) { + return A8 |= 0, I7 |= 0, B4 |= 0, E4 |= 0, !(C4 |= 0) & (g6 |= 0) >>> 0 >= 4294967280 | C4 && (iI(), Q3()), tA(A8 + 16 | 0, A8, I7, g6, C4, B4, E4), 0; + }, Ib: AI, Jb: jA, Kb: FI, Lb: function(A8, I7, g6) { + return A8 |= 0, g6 |= 0, LA(I7 |= 0, 24), $(A8, I7, g6), C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, g6 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, I7 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, C3[A8 + 44 | 0] = 0, C3[A8 + 45 | 0] = 0, C3[A8 + 46 | 0] = 0, C3[A8 + 47 | 0] = 0, C3[A8 + 48 | 0] = 0, C3[A8 + 49 | 0] = 0, C3[A8 + 50 | 0] = 0, C3[A8 + 51 | 0] = 0, C3[A8 + 36 | 0] = g6, C3[A8 + 37 | 0] = g6 >>> 8, C3[A8 + 38 | 0] = g6 >>> 16, C3[A8 + 39 | 0] = g6 >>> 24, C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, 0; + }, Mb: function(A8, I7, g6) { + return $(A8 |= 0, I7 |= 0, g6 |= 0), C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, g6 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, I7 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, C3[A8 + 44 | 0] = 0, C3[A8 + 45 | 0] = 0, C3[A8 + 46 | 0] = 0, C3[A8 + 47 | 0] = 0, C3[A8 + 48 | 0] = 0, C3[A8 + 49 | 0] = 0, C3[A8 + 50 | 0] = 0, C3[A8 + 51 | 0] = 0, C3[A8 + 36 | 0] = g6, C3[A8 + 37 | 0] = g6 >>> 8, C3[A8 + 38 | 0] = g6 >>> 16, C3[A8 + 39 | 0] = g6 >>> 24, C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, 0; + }, Nb: function(A8) { + var I7, g6 = 0, B4 = 0; + r3 = I7 = r3 - 48 | 0, g6 = i3[28 + (A8 |= 0) | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[I7 + 24 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[I7 + 28 >> 2] = g6, g6 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[I7 + 16 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[I7 + 20 >> 2] = g6, g6 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[I7 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[I7 + 4 >> 2] = g6, g6 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[I7 + 8 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[I7 + 12 >> 2] = g6, g6 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[I7 + 32 >> 2] = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[I7 + 36 >> 2] = g6, yI(I7, I7, A8 + 32 | 0, A8), g6 = E3[I7 + 28 >> 2], B4 = E3[I7 + 24 >> 2], C3[A8 + 24 | 0] = B4, C3[A8 + 25 | 0] = B4 >>> 8, C3[A8 + 26 | 0] = B4 >>> 16, C3[A8 + 27 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = g6, C3[A8 + 29 | 0] = g6 >>> 8, C3[A8 + 30 | 0] = g6 >>> 16, C3[A8 + 31 | 0] = g6 >>> 24, g6 = E3[I7 + 20 >> 2], B4 = E3[I7 + 16 >> 2], C3[A8 + 16 | 0] = B4, C3[A8 + 17 | 0] = B4 >>> 8, C3[A8 + 18 | 0] = B4 >>> 16, C3[A8 + 19 | 0] = B4 >>> 24, C3[A8 + 20 | 0] = g6, C3[A8 + 21 | 0] = g6 >>> 8, C3[A8 + 22 | 0] = g6 >>> 16, C3[A8 + 23 | 0] = g6 >>> 24, g6 = E3[I7 + 12 >> 2], B4 = E3[I7 + 8 >> 2], C3[A8 + 8 | 0] = B4, C3[A8 + 9 | 0] = B4 >>> 8, C3[A8 + 10 | 0] = B4 >>> 16, C3[A8 + 11 | 0] = B4 >>> 24, C3[A8 + 12 | 0] = g6, C3[A8 + 13 | 0] = g6 >>> 8, C3[A8 + 14 | 0] = g6 >>> 16, C3[A8 + 15 | 0] = g6 >>> 24, g6 = E3[I7 + 4 >> 2], B4 = E3[I7 >> 2], C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 4 | 0] = g6, C3[A8 + 5 | 0] = g6 >>> 8, C3[A8 + 6 | 0] = g6 >>> 16, C3[A8 + 7 | 0] = g6 >>> 24, B4 = E3[I7 + 36 >> 2], g6 = E3[I7 + 32 >> 2], C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, C3[A8 + 36 | 0] = g6, C3[A8 + 37 | 0] = g6 >>> 8, C3[A8 + 38 | 0] = g6 >>> 16, C3[A8 + 39 | 0] = g6 >>> 24, C3[A8 + 40 | 0] = B4, C3[A8 + 41 | 0] = B4 >>> 8, C3[A8 + 42 | 0] = B4 >>> 16, C3[A8 + 43 | 0] = B4 >>> 24, r3 = I7 + 48 | 0; + }, Ob: function(A8, I7, g6, B4, o4, c4, D4, a4, y4, f4) { + A8 |= 0, I7 |= 0, B4 |= 0, c4 |= 0, D4 |= 0, y4 |= 0, f4 |= 0; + var e4, w4 = 0, t4 = 0, h4 = 0; + return w4 = o4 |= 0, w4 |= o4 = 0, e4 = o4 | (a4 |= 0), r3 = o4 = r3 - 384 | 0, (g6 |= 0) && (E3[g6 >> 2] = 0, E3[g6 + 4 >> 2] = 0), !c4 & w4 >>> 0 < 4294967279 ? (eI(t4 = o4 + 16 | 0, 64, h4 = A8 + 32 | 0, A8), nI(a4 = o4 + 80 | 0, t4), MI(t4, 64), rI(a4, D4, e4, y4), rI(a4, 34736, 0 - e4 & 15, 0), E3[o4 + 72 >> 2] = 0, E3[o4 + 76 >> 2] = 0, E3[(D4 = o4 - -64 | 0) >> 2] = 0, E3[D4 + 4 >> 2] = 0, E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, E3[o4 + 16 >> 2] = 0, E3[o4 + 20 >> 2] = 0, E3[o4 + 24 >> 2] = 0, E3[o4 + 28 >> 2] = 0, C3[o4 + 16 | 0] = f4, vA(t4, t4, 64, 0, h4, 1, A8), rI(a4, t4, 64, 0), C3[0 | I7] = i3[o4 + 16 | 0], vA(I7 = I7 + 1 | 0, B4, w4, c4, h4, 2, A8), rI(a4, I7, w4, c4), rI(a4, 34736, 15 & w4, 0), E3[o4 + 8 >> 2] = e4, E3[o4 + 12 >> 2] = y4, rI(a4, B4 = o4 + 8 | 0, 8, 0), E3[o4 + 8 >> 2] = w4 - -64, E3[o4 + 12 >> 2] = c4 - ((w4 >>> 0 < 4294967232) - 1 | 0), rI(a4, B4, 8, 0), sI(a4, I7 = I7 + w4 | 0), MI(a4, 256), C3[A8 + 36 | 0] = i3[A8 + 36 | 0] ^ i3[0 | I7], C3[A8 + 37 | 0] = i3[A8 + 37 | 0] ^ i3[I7 + 1 | 0], C3[A8 + 38 | 0] = i3[A8 + 38 | 0] ^ i3[I7 + 2 | 0], C3[A8 + 39 | 0] = i3[A8 + 39 | 0] ^ i3[I7 + 3 | 0], C3[A8 + 40 | 0] = i3[A8 + 40 | 0] ^ i3[I7 + 4 | 0], C3[A8 + 41 | 0] = i3[A8 + 41 | 0] ^ i3[I7 + 5 | 0], C3[A8 + 42 | 0] = i3[A8 + 42 | 0] ^ i3[I7 + 6 | 0], C3[A8 + 43 | 0] = i3[A8 + 43 | 0] ^ i3[I7 + 7 | 0], dA(h4), (2 & f4 || SA(h4, 4)) && (I7 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[o4 + 360 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[o4 + 364 >> 2] = I7, I7 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[o4 + 352 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[o4 + 356 >> 2] = I7, I7 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[o4 + 336 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[o4 + 340 >> 2] = I7, I7 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[o4 + 344 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[o4 + 348 >> 2] = I7, I7 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[o4 + 368 >> 2] = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[o4 + 372 >> 2] = I7, yI(I7 = o4 + 336 | 0, I7, h4, A8), I7 = E3[o4 + 364 >> 2], B4 = E3[o4 + 360 >> 2], C3[A8 + 24 | 0] = B4, C3[A8 + 25 | 0] = B4 >>> 8, C3[A8 + 26 | 0] = B4 >>> 16, C3[A8 + 27 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[o4 + 356 >> 2], B4 = E3[o4 + 352 >> 2], C3[A8 + 16 | 0] = B4, C3[A8 + 17 | 0] = B4 >>> 8, C3[A8 + 18 | 0] = B4 >>> 16, C3[A8 + 19 | 0] = B4 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[o4 + 348 >> 2], B4 = E3[o4 + 344 >> 2], C3[A8 + 8 | 0] = B4, C3[A8 + 9 | 0] = B4 >>> 8, C3[A8 + 10 | 0] = B4 >>> 16, C3[A8 + 11 | 0] = B4 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[o4 + 340 >> 2], B4 = E3[o4 + 336 >> 2], C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = E3[o4 + 368 >> 2], B4 = E3[o4 + 372 >> 2], C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, C3[A8 + 36 | 0] = I7, C3[A8 + 37 | 0] = I7 >>> 8, C3[A8 + 38 | 0] = I7 >>> 16, C3[A8 + 39 | 0] = I7 >>> 24, C3[A8 + 40 | 0] = B4, C3[A8 + 41 | 0] = B4 >>> 8, C3[A8 + 42 | 0] = B4 >>> 16, C3[A8 + 43 | 0] = B4 >>> 24), g6 && (c4 = (A8 = w4 + 17 | 0) >>> 0 < 17 ? c4 + 1 | 0 : c4, E3[g6 >> 2] = A8, E3[g6 + 4 >> 2] = c4), r3 = o4 + 384 | 0) : (iI(), Q3()), 0; + }, Pb: function(A8, I7, g6, B4, o4, c4, D4, a4, y4, f4) { + A8 |= 0, I7 |= 0, B4 |= 0, o4 |= 0, a4 |= 0, f4 |= 0; + var e4, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0; + w4 = c4 |= 0, c4 = D4 |= 0, t4 = 0 | w4, e4 = y4 |= 0, r3 = D4 = r3 - 400 | 0, (g6 |= 0) && (E3[g6 >> 2] = 0, E3[g6 + 4 >> 2] = 0), B4 && (C3[0 | B4] = 255), s4 = -1; + A: { + I: { + if (!((y4 = t4 >>> 0 < 17) & !c4)) { + if (n4 = w4 = c4 - y4 | 0, !w4 & (y4 = t4 - 17 | 0) >>> 0 >= 4294967279 | w4) break I; + eI(h4 = D4 + 32 | 0, 64, k4 = A8 + 32 | 0, A8), nI(w4 = D4 + 96 | 0, h4), MI(h4, 64), rI(w4, a4, e4, f4), rI(w4, 34736, 0 - e4 & 15, 0), E3[D4 + 88 >> 2] = 0, E3[D4 + 92 >> 2] = 0, E3[D4 + 80 >> 2] = 0, E3[D4 + 84 >> 2] = 0, E3[D4 + 72 >> 2] = 0, E3[D4 + 76 >> 2] = 0, E3[(a4 = D4 - -64 | 0) >> 2] = 0, E3[a4 + 4 >> 2] = 0, E3[D4 + 56 >> 2] = 0, E3[D4 + 60 >> 2] = 0, E3[D4 + 48 >> 2] = 0, E3[D4 + 52 >> 2] = 0, E3[D4 + 40 >> 2] = 0, E3[D4 + 44 >> 2] = 0, E3[D4 + 32 >> 2] = 0, E3[D4 + 36 >> 2] = 0, C3[D4 + 32 | 0] = i3[0 | o4], vA(h4, h4, 64, 0, k4, 1, A8), a4 = i3[D4 + 32 | 0], C3[D4 + 32 | 0] = i3[0 | o4], rI(w4, h4, 64, 0), rI(w4, o4 = o4 + 1 | 0, y4, n4), rI(w4, 34736, t4 - 1 & 15, 0), E3[D4 + 24 >> 2] = e4, E3[D4 + 28 >> 2] = f4, rI(w4, f4 = D4 + 24 | 0, 8, 0), c4 = (t4 = t4 + 47 | 0) >>> 0 < 47 ? c4 + 1 | 0 : c4, E3[D4 + 24 >> 2] = t4, E3[D4 + 28 >> 2] = c4, rI(w4, f4, 8, 0), sI(w4, D4), MI(w4, 256), NA(D4, o4 + y4 | 0, 16) ? MI(D4, 16) : (vA(I7, o4, y4, n4, k4, 2, A8), C3[A8 + 36 | 0] = i3[A8 + 36 | 0] ^ i3[0 | D4], C3[A8 + 37 | 0] = i3[A8 + 37 | 0] ^ i3[D4 + 1 | 0], C3[A8 + 38 | 0] = i3[A8 + 38 | 0] ^ i3[D4 + 2 | 0], C3[A8 + 39 | 0] = i3[A8 + 39 | 0] ^ i3[D4 + 3 | 0], C3[A8 + 40 | 0] = i3[A8 + 40 | 0] ^ i3[D4 + 4 | 0], C3[A8 + 41 | 0] = i3[A8 + 41 | 0] ^ i3[D4 + 5 | 0], C3[A8 + 42 | 0] = i3[A8 + 42 | 0] ^ i3[D4 + 6 | 0], C3[A8 + 43 | 0] = i3[A8 + 43 | 0] ^ i3[D4 + 7 | 0], dA(k4), (2 & a4 || SA(k4, 4)) && (I7 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[D4 + 376 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[D4 + 380 >> 2] = I7, I7 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[D4 + 368 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[D4 + 372 >> 2] = I7, I7 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[D4 + 352 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[D4 + 356 >> 2] = I7, I7 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[D4 + 360 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[D4 + 364 >> 2] = I7, I7 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[D4 + 384 >> 2] = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[D4 + 388 >> 2] = I7, yI(I7 = D4 + 352 | 0, I7, k4, A8), I7 = E3[D4 + 380 >> 2], o4 = E3[D4 + 376 >> 2], C3[A8 + 24 | 0] = o4, C3[A8 + 25 | 0] = o4 >>> 8, C3[A8 + 26 | 0] = o4 >>> 16, C3[A8 + 27 | 0] = o4 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[D4 + 372 >> 2], o4 = E3[D4 + 368 >> 2], C3[A8 + 16 | 0] = o4, C3[A8 + 17 | 0] = o4 >>> 8, C3[A8 + 18 | 0] = o4 >>> 16, C3[A8 + 19 | 0] = o4 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[D4 + 364 >> 2], o4 = E3[D4 + 360 >> 2], C3[A8 + 8 | 0] = o4, C3[A8 + 9 | 0] = o4 >>> 8, C3[A8 + 10 | 0] = o4 >>> 16, C3[A8 + 11 | 0] = o4 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[D4 + 356 >> 2], o4 = E3[D4 + 352 >> 2], C3[0 | A8] = o4, C3[A8 + 1 | 0] = o4 >>> 8, C3[A8 + 2 | 0] = o4 >>> 16, C3[A8 + 3 | 0] = o4 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = E3[D4 + 384 >> 2], o4 = E3[D4 + 388 >> 2], C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, C3[A8 + 36 | 0] = I7, C3[A8 + 37 | 0] = I7 >>> 8, C3[A8 + 38 | 0] = I7 >>> 16, C3[A8 + 39 | 0] = I7 >>> 24, C3[A8 + 40 | 0] = o4, C3[A8 + 41 | 0] = o4 >>> 8, C3[A8 + 42 | 0] = o4 >>> 16, C3[A8 + 43 | 0] = o4 >>> 24), g6 && (E3[g6 >> 2] = y4, E3[g6 + 4 >> 2] = n4), s4 = 0, B4 && (C3[0 | B4] = a4)); + } + r3 = D4 + 400 | 0; + break A; + } + iI(), Q3(); + } + return 0 | s4; + }, Qb: function() { + return 52; + }, Rb: function() { + return 17; + }, Sb: pI, Tb: _I, Ub: function() { + return -18; + }, Vb: YI, Wb: dI, Xb: bI, Yb: function() { + return 3; + }, Zb: UI, _b: KI, $b: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0; + var E4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0; + if (F4 = 1886610805 ^ (c4 = i3[0 | (Q4 |= 0)] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), w4 = 1936682341 ^ (D4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24), c4 ^= 1852142177, a4 = 1819895653 ^ D4, S4 = 1852075885 ^ (D4 = i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24), n4 = 1685025377 ^ (Q4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24), f4 = 2037671283 ^ D4, D4 = 1952801890 ^ Q4, k4 = g6, (0 | (o4 = (g6 + I7 | 0) - (E4 = 7 & g6) | 0)) != (0 | I7)) for (; g6 = (y4 = D4 ^ (s4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24)) + a4 | 0, f4 = B4 = c4 + (Q4 = f4 ^ (r4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24)) | 0, h4 = g6 = B4 >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6, c4 = B4, B4 = g6, g6 = w4 + n4 | 0, g6 = (D4 = F4 + S4 | 0) >>> 0 < F4 >>> 0 ? g6 + 1 | 0 : g6, e4 = (a4 = _A(S4, n4, 13) ^ D4) + c4 | 0, B4 = (c4 = t3 ^ g6) + B4 | 0, c4 = _A(a4, c4, 17) ^ e4, n4 = _A(c4, B4 = (a4 = a4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4) ^ t3, 13), w4 = t3, y4 = _A(Q4, y4, 16), Q4 = h4 ^ t3, y4 ^= f4, h4 = _A(D4, g6, 32), g6 = t3 + Q4 | 0, g6 = (f4 = B4) + (B4 = (D4 = y4 + h4 | 0) >>> 0 < h4 >>> 0 ? g6 + 1 | 0 : g6) | 0, h4 = g6 = (f4 = c4 + D4 | 0) >>> 0 < D4 >>> 0 ? g6 + 1 | 0 : g6, n4 = _A(c4 = f4 ^ n4, g6 ^= w4, 17), w4 = t3, y4 = _A(y4, Q4, 21), Q4 = B4 ^ t3, y4 ^= D4, D4 = _A(e4, a4, 32), B4 = t3 + Q4 | 0, g6 = (D4 = D4 >>> 0 > (a4 = y4 + D4 | 0) >>> 0 ? B4 + 1 | 0 : B4) + g6 | 0, S4 = (c4 = c4 + a4 | 0) ^ n4, B4 = g6 = c4 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, n4 = g6 ^ w4, g6 = _A(y4, Q4, 16), y4 = D4 ^= t3, e4 = _A(g6 ^= a4, D4, 21), a4 = t3, h4 = (D4 = _A(f4, h4, 32)) + g6 | 0, g6 = t3 + y4 | 0, f4 = e4 ^ h4, D4 = (g6 = D4 >>> 0 > h4 >>> 0 ? g6 + 1 | 0 : g6) ^ a4, c4 = _A(c4, B4, 32), a4 = t3, F4 = h4 ^ r4, w4 = g6 ^ s4, (0 | o4) != (0 | (I7 = I7 + 8 | 0)); ) ; + switch (s4 = 0, e4 = k4 << 24, E4 - 1 | 0) { + case 6: + e4 |= i3[I7 + 6 | 0] << 16; + case 5: + e4 |= i3[I7 + 5 | 0] << 8; + case 4: + e4 |= i3[I7 + 4 | 0]; + case 3: + s4 |= (g6 = i3[I7 + 3 | 0]) << 24, e4 |= B4 = g6 >>> 8 | 0; + case 2: + s4 |= (B4 = i3[I7 + 2 | 0]) << 16, e4 |= g6 = B4 >>> 16 | 0; + case 1: + s4 |= (g6 = i3[I7 + 1 | 0]) << 8, e4 |= B4 = g6 >>> 24 | 0; + case 0: + s4 = i3[0 | I7] | s4; + } + return I7 = A8, B4 = _A(Q4 = f4 ^ s4, A8 = D4 ^ e4, 16), A8 = A8 + a4 | 0, D4 = A8 = (h4 = Q4 + c4 | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, r4 = _A(Q4 = B4 ^ h4, A8 ^= g6 = t3, 21), a4 = t3, g6 = w4 + n4 | 0, B4 = g6 = (c4 = F4 + S4 | 0) >>> 0 < F4 >>> 0 ? g6 + 1 | 0 : g6, y4 = Q4, Q4 = _A(c4, g6, 32), g6 = t3 + A8 | 0, A8 = a4, a4 = g6 = Q4 >>> 0 > (f4 = y4 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, w4 = _A(Q4 = f4 ^ r4, A8 ^= g6, 16), y4 = t3, g6 = (c4 = k4 = _A(S4, n4, 13) ^ c4) + h4 | 0, B4 = (r4 = t3 ^ B4) + D4 | 0, h4 = Q4, Q4 = _A(g6, B4 = g6 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, 32), A8 = t3 + A8 | 0, w4 = _A(c4 = w4 ^ (h4 = h4 + Q4 | 0), Q4 = (D4 = Q4 >>> 0 > h4 >>> 0 ? A8 + 1 | 0 : A8) ^ y4, 21), y4 = t3, k4 = _A(k4, r4, 17) ^ g6, g6 = (r4 = t3 ^ B4) + a4 | 0, A8 = g6 = (B4 = f4 = (A8 = k4) + f4 | 0) >>> 0 < A8 >>> 0 ? g6 + 1 | 0 : g6, a4 = c4, c4 = _A(B4, g6, 32), g6 = t3 + Q4 | 0, y4 = g6 = (c4 = c4 >>> 0 > (a4 = a4 + c4 | 0) >>> 0 ? g6 + 1 | 0 : g6) ^ y4, w4 = _A(n4 = a4 ^ w4, g6, 16), f4 = t3, k4 = _A(k4, r4, 13) ^ B4, A8 = (r4 = A8 ^ t3) + D4 | 0, B4 = A8 = (g6 = k4) >>> 0 > (Q4 = g6 + h4 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = _A(Q4, A8, 32), g6 = y4 + t3 | 0, y4 = g6 = (D4 = (A8 = n4 + (255 ^ A8) | 0) >>> 0 < n4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, h4 = A8, w4 = _A(n4 = w4 ^ A8, g6, 21), f4 = t3, k4 = _A(k4, r4, 17) ^ Q4, g6 = (r4 = B4 ^ t3) + (c4 ^ e4) | 0, B4 = g6 = (A8 = a4 ^ s4) >>> 0 > (Q4 = k4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = _A(Q4, g6, 32), g6 = y4 + t3 | 0, y4 = g6 = (c4 = (A8 = A8 + n4 | 0) >>> 0 < n4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, a4 = A8, e4 = _A(w4 ^= A8, g6, 16), f4 = t3, k4 = _A(k4, r4, 13) ^ Q4, A8 = D4 + (r4 = t3 ^ B4) | 0, A8 = _A(Q4 = h4 + k4 | 0, g6 = A8 = Q4 >>> 0 < h4 >>> 0 ? A8 + 1 | 0 : A8, 32), B4 = y4 + t3 | 0, y4 = B4 = (D4 = (A8 = A8 + w4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) ^ f4, h4 = A8, e4 = _A(w4 = e4 ^ A8, B4, 21), f4 = t3, A8 = _A(k4, r4, 17), g6 = c4 + (k4 = g6 ^ t3) | 0, B4 = g6 = (Q4 = a4 + (r4 = A8 ^ Q4) | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, A8 = _A(Q4, g6, 32), g6 = y4 + t3 | 0, a4 = A8 = A8 + w4 | 0, c4 = g6 = A8 >>> 0 < w4 >>> 0 ? g6 + 1 | 0 : g6, e4 = _A(y4 = e4 ^ A8, g6 ^= f4, 16), f4 = t3, A8 = _A(r4, k4, 13), B4 = D4 + (k4 = B4 ^ t3) | 0, A8 = _A(Q4 = h4 + (r4 = A8 ^ Q4) | 0, B4 = Q4 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, 32), g6 = g6 + t3 | 0, y4 = g6 = (D4 = (A8 = A8 + y4 | 0) >>> 0 < y4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, h4 = A8, e4 = _A(w4 = e4 ^ A8, g6, 21), f4 = t3, A8 = _A(r4, k4, 17), g6 = c4 + (k4 = B4 ^ t3) | 0, B4 = g6 = (Q4 = a4 + (r4 = A8 ^ Q4) | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, g6 = _A(Q4, g6, 32), A8 = y4 + t3 | 0, y4 = A8 = (c4 = (g6 = g6 + w4 | 0) >>> 0 < w4 >>> 0 ? A8 + 1 | 0 : A8) ^ f4, a4 = g6, e4 = _A(w4 = e4 ^ g6, A8, 16), f4 = t3, A8 = _A(r4, k4, 13), g6 = D4 + (k4 = B4 ^ t3) | 0, B4 = g6 = (Q4 = h4 + (r4 = A8 ^ Q4) | 0) >>> 0 < h4 >>> 0 ? g6 + 1 | 0 : g6, A8 = _A(Q4, g6, 32), g6 = y4 + t3 | 0, D4 = A8 = A8 + w4 | 0, e4 = _A(e4 ^ A8, (g6 = A8 >>> 0 < w4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, 21), f4 = t3, Q4 = _A(r4, k4, 17) ^ Q4, h4 = _A(Q4, A8 = B4 ^ t3, 13), A8 = A8 + c4 | 0, B4 = A8 = t3 ^ ((Q4 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 : A8), Q4 = _A(c4 = Q4 ^ h4, A8, 17) ^ e4, A8 = t3 ^ f4, B4 = g6 + B4 | 0, g6 = _A(g6 = c4 + D4 | 0, B4 = g6 >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, 32) ^ Q4 ^ g6, C3[0 | I7] = g6, C3[I7 + 1 | 0] = g6 >>> 8, C3[I7 + 2 | 0] = g6 >>> 16, C3[I7 + 3 | 0] = g6 >>> 24, A8 ^= B4 ^ t3, C3[I7 + 4 | 0] = A8, C3[I7 + 5 | 0] = A8 >>> 8, C3[I7 + 6 | 0] = A8 >>> 16, C3[I7 + 7 | 0] = A8 >>> 24, 0; + }, ac: SI, bc: NI, cc: JI, dc: _I, ec: _I, fc: JI, gc: function() { + return -65; + }, hc: function(A8, I7, g6) { + A8 |= 0; + var B4, Q4, E4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0; + return r3 = E4 = r3 - 160 | 0, FA(I7 |= 0, g6 |= 0, 32, 0), C3[0 | I7] = 248 & i3[0 | I7], C3[I7 + 31 | 0] = 63 & i3[I7 + 31 | 0] | 64, Z(E4, I7), mA(A8, E4), D4 = i3[(Q4 = g6) + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24, c4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, a4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, y4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, f4 = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, g6 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, o4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, B4 = I7, I7 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, C3[B4 + 24 | 0] = I7, C3[B4 + 25 | 0] = I7 >>> 8, C3[B4 + 26 | 0] = I7 >>> 16, C3[B4 + 27 | 0] = I7 >>> 24, C3[B4 + 28 | 0] = o4, C3[B4 + 29 | 0] = o4 >>> 8, C3[B4 + 30 | 0] = o4 >>> 16, C3[B4 + 31 | 0] = o4 >>> 24, C3[B4 + 16 | 0] = a4, C3[B4 + 17 | 0] = a4 >>> 8, C3[B4 + 18 | 0] = a4 >>> 16, C3[B4 + 19 | 0] = a4 >>> 24, C3[B4 + 20 | 0] = y4, C3[B4 + 21 | 0] = y4 >>> 8, C3[B4 + 22 | 0] = y4 >>> 16, C3[B4 + 23 | 0] = y4 >>> 24, C3[B4 + 8 | 0] = D4, C3[B4 + 9 | 0] = D4 >>> 8, C3[B4 + 10 | 0] = D4 >>> 16, C3[B4 + 11 | 0] = D4 >>> 24, C3[B4 + 12 | 0] = c4, C3[B4 + 13 | 0] = c4 >>> 8, C3[B4 + 14 | 0] = c4 >>> 16, C3[B4 + 15 | 0] = c4 >>> 24, C3[0 | B4] = f4, C3[B4 + 1 | 0] = f4 >>> 8, C3[B4 + 2 | 0] = f4 >>> 16, C3[B4 + 3 | 0] = f4 >>> 24, C3[B4 + 4 | 0] = g6, C3[B4 + 5 | 0] = g6 >>> 8, C3[B4 + 6 | 0] = g6 >>> 16, C3[B4 + 7 | 0] = g6 >>> 24, a4 = i3[(c4 = A8) + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, y4 = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, f4 = i3[c4 + 16 | 0] | i3[c4 + 17 | 0] << 8 | i3[c4 + 18 | 0] << 16 | i3[c4 + 19 | 0] << 24, g6 = i3[c4 + 20 | 0] | i3[c4 + 21 | 0] << 8 | i3[c4 + 22 | 0] << 16 | i3[c4 + 23 | 0] << 24, I7 = i3[0 | c4] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, A8 = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, D4 = i3[c4 + 28 | 0] | i3[c4 + 29 | 0] << 8 | i3[c4 + 30 | 0] << 16 | i3[c4 + 31 | 0] << 24, c4 = i3[c4 + 24 | 0] | i3[c4 + 25 | 0] << 8 | i3[c4 + 26 | 0] << 16 | i3[c4 + 27 | 0] << 24, C3[B4 + 56 | 0] = c4, C3[B4 + 57 | 0] = c4 >>> 8, C3[B4 + 58 | 0] = c4 >>> 16, C3[B4 + 59 | 0] = c4 >>> 24, C3[B4 + 60 | 0] = D4, C3[B4 + 61 | 0] = D4 >>> 8, C3[B4 + 62 | 0] = D4 >>> 16, C3[B4 + 63 | 0] = D4 >>> 24, C3[B4 + 48 | 0] = f4, C3[B4 + 49 | 0] = f4 >>> 8, C3[B4 + 50 | 0] = f4 >>> 16, C3[B4 + 51 | 0] = f4 >>> 24, C3[B4 + 52 | 0] = g6, C3[B4 + 53 | 0] = g6 >>> 8, C3[B4 + 54 | 0] = g6 >>> 16, C3[B4 + 55 | 0] = g6 >>> 24, C3[B4 + 40 | 0] = a4, C3[B4 + 41 | 0] = a4 >>> 8, C3[B4 + 42 | 0] = a4 >>> 16, C3[B4 + 43 | 0] = a4 >>> 24, C3[B4 + 44 | 0] = y4, C3[B4 + 45 | 0] = y4 >>> 8, C3[B4 + 46 | 0] = y4 >>> 16, C3[B4 + 47 | 0] = y4 >>> 24, C3[B4 + 32 | 0] = I7, C3[B4 + 33 | 0] = I7 >>> 8, C3[B4 + 34 | 0] = I7 >>> 16, C3[B4 + 35 | 0] = I7 >>> 24, C3[B4 + 36 | 0] = A8, C3[B4 + 37 | 0] = A8 >>> 8, C3[B4 + 38 | 0] = A8 >>> 16, C3[B4 + 39 | 0] = A8 >>> 24, r3 = E4 + 160 | 0, 0; + }, ic: function(A8, I7) { + A8 |= 0, I7 |= 0; + var g6, B4, Q4, o4, c4, D4 = 0, a4 = 0, y4 = 0; + return r3 = a4 = r3 - 192 | 0, LA(a4, 32), FA(I7, a4, 32, 0), C3[0 | I7] = 248 & i3[0 | I7], C3[I7 + 31 | 0] = 63 & i3[I7 + 31 | 0] | 64, Z(y4 = a4 + 32 | 0, I7), mA(A8, y4), g6 = a4, y4 = E3[a4 + 28 >> 2], a4 = E3[a4 + 24 >> 2], C3[I7 + 24 | 0] = a4, C3[I7 + 25 | 0] = a4 >>> 8, C3[I7 + 26 | 0] = a4 >>> 16, C3[I7 + 27 | 0] = a4 >>> 24, C3[I7 + 28 | 0] = y4, C3[I7 + 29 | 0] = y4 >>> 8, C3[I7 + 30 | 0] = y4 >>> 16, C3[I7 + 31 | 0] = y4 >>> 24, y4 = E3[g6 + 20 >> 2], a4 = E3[g6 + 16 >> 2], C3[I7 + 16 | 0] = a4, C3[I7 + 17 | 0] = a4 >>> 8, C3[I7 + 18 | 0] = a4 >>> 16, C3[I7 + 19 | 0] = a4 >>> 24, C3[I7 + 20 | 0] = y4, C3[I7 + 21 | 0] = y4 >>> 8, C3[I7 + 22 | 0] = y4 >>> 16, C3[I7 + 23 | 0] = y4 >>> 24, y4 = E3[g6 + 12 >> 2], a4 = E3[g6 + 8 >> 2], C3[I7 + 8 | 0] = a4, C3[I7 + 9 | 0] = a4 >>> 8, C3[I7 + 10 | 0] = a4 >>> 16, C3[I7 + 11 | 0] = a4 >>> 24, C3[I7 + 12 | 0] = y4, C3[I7 + 13 | 0] = y4 >>> 8, C3[I7 + 14 | 0] = y4 >>> 16, C3[I7 + 15 | 0] = y4 >>> 24, y4 = E3[g6 + 4 >> 2], a4 = E3[g6 >> 2], C3[0 | I7] = a4, C3[I7 + 1 | 0] = a4 >>> 8, C3[I7 + 2 | 0] = a4 >>> 16, C3[I7 + 3 | 0] = a4 >>> 24, C3[I7 + 4 | 0] = y4, C3[I7 + 5 | 0] = y4 >>> 8, C3[I7 + 6 | 0] = y4 >>> 16, C3[I7 + 7 | 0] = y4 >>> 24, B4 = i3[(D4 = A8) + 8 | 0] | i3[D4 + 9 | 0] << 8 | i3[D4 + 10 | 0] << 16 | i3[D4 + 11 | 0] << 24, Q4 = i3[D4 + 12 | 0] | i3[D4 + 13 | 0] << 8 | i3[D4 + 14 | 0] << 16 | i3[D4 + 15 | 0] << 24, o4 = i3[D4 + 16 | 0] | i3[D4 + 17 | 0] << 8 | i3[D4 + 18 | 0] << 16 | i3[D4 + 19 | 0] << 24, y4 = i3[D4 + 20 | 0] | i3[D4 + 21 | 0] << 8 | i3[D4 + 22 | 0] << 16 | i3[D4 + 23 | 0] << 24, a4 = i3[0 | D4] | i3[D4 + 1 | 0] << 8 | i3[D4 + 2 | 0] << 16 | i3[D4 + 3 | 0] << 24, A8 = i3[D4 + 4 | 0] | i3[D4 + 5 | 0] << 8 | i3[D4 + 6 | 0] << 16 | i3[D4 + 7 | 0] << 24, c4 = i3[D4 + 28 | 0] | i3[D4 + 29 | 0] << 8 | i3[D4 + 30 | 0] << 16 | i3[D4 + 31 | 0] << 24, D4 = i3[D4 + 24 | 0] | i3[D4 + 25 | 0] << 8 | i3[D4 + 26 | 0] << 16 | i3[D4 + 27 | 0] << 24, C3[I7 + 56 | 0] = D4, C3[I7 + 57 | 0] = D4 >>> 8, C3[I7 + 58 | 0] = D4 >>> 16, C3[I7 + 59 | 0] = D4 >>> 24, C3[I7 + 60 | 0] = c4, C3[I7 + 61 | 0] = c4 >>> 8, C3[I7 + 62 | 0] = c4 >>> 16, C3[I7 + 63 | 0] = c4 >>> 24, C3[I7 + 48 | 0] = o4, C3[I7 + 49 | 0] = o4 >>> 8, C3[I7 + 50 | 0] = o4 >>> 16, C3[I7 + 51 | 0] = o4 >>> 24, C3[I7 + 52 | 0] = y4, C3[I7 + 53 | 0] = y4 >>> 8, C3[I7 + 54 | 0] = y4 >>> 16, C3[I7 + 55 | 0] = y4 >>> 24, C3[I7 + 40 | 0] = B4, C3[I7 + 41 | 0] = B4 >>> 8, C3[I7 + 42 | 0] = B4 >>> 16, C3[I7 + 43 | 0] = B4 >>> 24, C3[I7 + 44 | 0] = Q4, C3[I7 + 45 | 0] = Q4 >>> 8, C3[I7 + 46 | 0] = Q4 >>> 16, C3[I7 + 47 | 0] = Q4 >>> 24, C3[I7 + 32 | 0] = a4, C3[I7 + 33 | 0] = a4 >>> 8, C3[I7 + 34 | 0] = a4 >>> 16, C3[I7 + 35 | 0] = a4 >>> 24, C3[I7 + 36 | 0] = A8, C3[I7 + 37 | 0] = A8 >>> 8, C3[I7 + 38 | 0] = A8 >>> 16, C3[I7 + 39 | 0] = A8 >>> 24, MI(g6, 32), r3 = g6 + 192 | 0, 0; + }, jc: function(A8, I7, g6, C4, B4, Q4) { + I7 |= 0, B4 |= 0, Q4 |= 0; + var i4, o4 = 0; + return r3 = i4 = r3 - 16 | 0, k3(A8 |= 0, i4 + 8 | 0, lA(A8 - -64 | 0, g6 |= 0, C4 |= 0), C4, B4, Q4, 0), 64 != E3[i4 + 8 >> 2] | E3[i4 + 12 >> 2] ? (I7 && (E3[I7 >> 2] = 0, E3[I7 + 4 >> 2] = 0), VA(A8, 0, C4 - -64 | 0), o4 = -1) : I7 && (E3[I7 >> 2] = C4 - -64, E3[I7 + 4 >> 2] = B4 - ((C4 >>> 0 < 4294967232) - 1 | 0)), r3 = i4 + 16 | 0, 0 | o4; + }, kc: function(A8, I7, g6, C4, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0; + var i4 = 0; + A: { + I: { + if (i4 = C4 |= 0, !(!(B4 |= 0) & C4 >>> 0 < 64 || (C4 = B4 - 1 | 0, !(C4 = (B4 = i4 + -64 | 0) >>> 0 < 4294967232 ? C4 + 1 | 0 : C4) & B4 >>> 0 > 4294967231 | C4))) { + if (!F3(g6, i4 = g6 - -64 | 0, B4, C4, Q4 |= 0, 0)) break I; + A8 && VA(A8, 0, B4); + } + if (g6 = -1, !I7) break A; + E3[I7 >> 2] = 0, E3[I7 + 4 >> 2] = 0; + break A; + } + I7 && (E3[I7 >> 2] = B4, E3[I7 + 4 >> 2] = C4), g6 = 0, A8 && lA(A8, i4, B4); + } + return 0 | g6; + }, lc: function(A8, I7, g6, C4, B4, Q4) { + return k3(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, 0), 0; + }, mc: function(A8, I7, g6, C4, B4) { + return 0 | F3(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, 0); + }, nc: function(A8) { + return MA(A8 |= 0), 0; + }, oc: function(A8, I7, g6, C4) { + return 0 | W(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0); + }, pc: function(A8, I7, g6, C4) { + var B4; + return I7 |= 0, g6 |= 0, C4 |= 0, r3 = B4 = r3 + -64 | 0, v3(A8 |= 0, B4), A8 = k3(I7, g6, B4, 64, 0, C4, 1), r3 = B4 - -64 | 0, 0 | A8; + }, qc: function(A8, I7, g6) { + var C4; + return I7 |= 0, g6 |= 0, r3 = C4 = r3 + -64 | 0, v3(A8 |= 0, C4), A8 = F3(I7, C4, 64, 0, g6, 1), r3 = C4 - -64 | 0, 0 | A8; + }, rc: function(A8, I7) { + A8 |= 0; + var g6, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, l3 = 0, z2 = 0, j2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, oA2 = 0, cA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, MA2 = 0, NA2 = 0, _A2 = 0, pA2 = 0, HA2 = 0, GA2 = 0, JA2 = 0, YA2 = 0, UA2 = 0, dA2 = 0, bA2 = 0, vA2 = 0, RA2 = 0, LA2 = 0, xA2 = 0, uA2 = 0, mA2 = 0, qA2 = 0, lA2 = 0; + if (r3 = g6 = r3 - 256 | 0, bA2 = -1, !KA(I7 |= 0) && !q3(B4 = g6 + 96 | 0, I7)) { + for (r3 = i4 = r3 - 2048 | 0, DA(o4 = i4 + 640 | 0, B4), B4 = E3[(I7 = B4) + 36 >> 2], E3[i4 + 352 >> 2] = E3[I7 + 32 >> 2], E3[i4 + 356 >> 2] = B4, B4 = E3[I7 + 28 >> 2], E3[i4 + 344 >> 2] = E3[I7 + 24 >> 2], E3[i4 + 348 >> 2] = B4, B4 = E3[I7 + 20 >> 2], E3[i4 + 336 >> 2] = E3[I7 + 16 >> 2], E3[i4 + 340 >> 2] = B4, B4 = E3[I7 + 12 >> 2], E3[i4 + 328 >> 2] = E3[I7 + 8 >> 2], E3[i4 + 332 >> 2] = B4, B4 = E3[I7 + 4 >> 2], E3[i4 + 320 >> 2] = E3[I7 >> 2], E3[i4 + 324 >> 2] = B4, B4 = E3[I7 + 52 >> 2], E3[i4 + 368 >> 2] = E3[I7 + 48 >> 2], E3[i4 + 372 >> 2] = B4, B4 = E3[I7 + 60 >> 2], E3[i4 + 376 >> 2] = E3[I7 + 56 >> 2], E3[i4 + 380 >> 2] = B4, Q4 = E3[4 + (B4 = I7 - -64 | 0) >> 2], E3[i4 + 384 >> 2] = E3[B4 >> 2], E3[i4 + 388 >> 2] = Q4, B4 = E3[I7 + 76 >> 2], E3[i4 + 392 >> 2] = E3[I7 + 72 >> 2], E3[i4 + 396 >> 2] = B4, B4 = E3[I7 + 44 >> 2], E3[i4 + 360 >> 2] = E3[I7 + 40 >> 2], E3[i4 + 364 >> 2] = B4, B4 = E3[I7 + 92 >> 2], E3[i4 + 408 >> 2] = E3[I7 + 88 >> 2], E3[i4 + 412 >> 2] = B4, B4 = E3[I7 + 100 >> 2], E3[i4 + 416 >> 2] = E3[I7 + 96 >> 2], E3[i4 + 420 >> 2] = B4, B4 = E3[I7 + 108 >> 2], E3[i4 + 424 >> 2] = E3[I7 + 104 >> 2], E3[i4 + 428 >> 2] = B4, B4 = E3[I7 + 116 >> 2], E3[i4 + 432 >> 2] = E3[I7 + 112 >> 2], E3[i4 + 436 >> 2] = B4, B4 = E3[I7 + 84 >> 2], E3[i4 + 400 >> 2] = E3[I7 + 80 >> 2], E3[i4 + 404 >> 2] = B4, _3(I7 = i4 + 480 | 0, B4 = i4 + 320 | 0), M3(Q4 = i4 + 160 | 0, I7, a4 = i4 + 600 | 0), M3(i4 + 200 | 0, f4 = i4 + 520 | 0, e4 = i4 + 560 | 0), M3(i4 + 240 | 0, e4, a4), M3(i4 + 280 | 0, I7, f4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4 = i4 + 360 | 0, f4, e4), M3(S4 = i4 + 400 | 0, e4, a4), M3(k4 = i4 + 440 | 0, I7, f4), DA(o4 = i4 + 800 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 960 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1120 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1280 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1440 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1600 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(i4 + 1760 | 0, B4), E3[i4 + 32 >> 2] = 0, E3[i4 + 36 >> 2] = 0, E3[i4 + 24 >> 2] = 0, E3[i4 + 28 >> 2] = 0, E3[i4 + 16 >> 2] = 0, E3[i4 + 20 >> 2] = 0, E3[i4 + 8 >> 2] = 0, E3[i4 + 12 >> 2] = 0, E3[i4 + 52 >> 2] = 0, E3[i4 + 56 >> 2] = 0, E3[i4 + 60 >> 2] = 0, E3[i4 + 64 >> 2] = 0, E3[i4 + 68 >> 2] = 0, E3[i4 + 72 >> 2] = 0, E3[i4 + 76 >> 2] = 0, E3[i4 + 80 >> 2] = 1, E3[i4 >> 2] = 0, E3[i4 + 4 >> 2] = 0, E3[i4 + 44 >> 2] = 0, E3[i4 + 48 >> 2] = 0, E3[i4 + 40 >> 2] = 1, VA(i4 + 84 | 0, 0, 76), w4 = i4 + 120 | 0, s4 = i4 + 2008 | 0, n4 = i4 + 1968 | 0, B4 = i4 + 80 | 0, Q4 = i4 + 40 | 0, o4 = 252; D4 = E3[i4 + 36 >> 2], E3[(I7 = i4 + 1960 | 0) >> 2] = E3[i4 + 32 >> 2], E3[I7 + 4 >> 2] = D4, D4 = E3[i4 + 28 >> 2], E3[(I7 = i4 + 1952 | 0) >> 2] = E3[i4 + 24 >> 2], E3[I7 + 4 >> 2] = D4, D4 = E3[i4 + 20 >> 2], E3[(I7 = i4 + 1944 | 0) >> 2] = E3[i4 + 16 >> 2], E3[I7 + 4 >> 2] = D4, D4 = E3[i4 + 12 >> 2], E3[(I7 = i4 + 1936 | 0) >> 2] = E3[i4 + 8 >> 2], E3[I7 + 4 >> 2] = D4, I7 = E3[i4 + 4 >> 2], E3[i4 + 1928 >> 2] = E3[i4 >> 2], E3[i4 + 1932 >> 2] = I7, D4 = E3[(I7 = Q4) + 36 >> 2], E3[n4 + 32 >> 2] = E3[I7 + 32 >> 2], E3[n4 + 36 >> 2] = D4, D4 = E3[I7 + 28 >> 2], E3[n4 + 24 >> 2] = E3[I7 + 24 >> 2], E3[n4 + 28 >> 2] = D4, D4 = E3[I7 + 20 >> 2], E3[n4 + 16 >> 2] = E3[I7 + 16 >> 2], E3[n4 + 20 >> 2] = D4, D4 = E3[I7 + 12 >> 2], E3[n4 + 8 >> 2] = E3[I7 + 8 >> 2], E3[n4 + 12 >> 2] = D4, D4 = E3[I7 + 4 >> 2], E3[n4 >> 2] = E3[I7 >> 2], E3[n4 + 4 >> 2] = D4, D4 = E3[(I7 = B4) + 36 >> 2], E3[s4 + 32 >> 2] = E3[I7 + 32 >> 2], E3[s4 + 36 >> 2] = D4, D4 = E3[I7 + 28 >> 2], E3[s4 + 24 >> 2] = E3[I7 + 24 >> 2], E3[s4 + 28 >> 2] = D4, D4 = E3[I7 + 20 >> 2], E3[s4 + 16 >> 2] = E3[I7 + 16 >> 2], E3[s4 + 20 >> 2] = D4, D4 = E3[I7 + 12 >> 2], E3[s4 + 8 >> 2] = E3[I7 + 8 >> 2], E3[s4 + 12 >> 2] = D4, D4 = E3[I7 + 4 >> 2], E3[s4 >> 2] = E3[I7 >> 2], E3[s4 + 4 >> 2] = D4, o4 = C3[(I7 = o4) + 33408 | 0], _3(D4 = i4 + 480 | 0, i4 + 1928 | 0), (0 | o4) > 0 ? (M3(K4 = i4 + 320 | 0, D4, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, D4, f4), X(D4, K4, (i4 + 640 | 0) + c3((254 & o4) >>> 1 | 0, 160) | 0)) : (0 | o4) >= 0 || (M3(K4 = i4 + 320 | 0, D4 = i4 + 480 | 0, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, D4, f4), O(D4, K4, (i4 + 640 | 0) + c3((0 - o4 & 254) >>> 1 | 0, 160) | 0)), M3(i4, o4 = i4 + 480 | 0, a4), M3(Q4, f4, e4), M3(B4, e4, a4), M3(w4, o4, f4), o4 = I7 - 1 | 0, I7; ) ; + eA(I7 = i4 + 640 | 0, i4), I7 = SA(I7, 32), r3 = i4 + 2048 | 0, I7 && (bA2 = 0, u4 = E3[g6 + 172 >> 2], E3[g6 + 36 >> 2] = 0 - u4, F4 = E3[g6 + 168 >> 2], E3[g6 + 32 >> 2] = 0 - F4, m4 = E3[g6 + 164 >> 2], E3[g6 + 28 >> 2] = 0 - m4, f4 = E3[g6 + 160 >> 2], E3[g6 + 24 >> 2] = 0 - f4, l3 = E3[g6 + 156 >> 2], E3[g6 + 20 >> 2] = 0 - l3, e4 = E3[g6 + 152 >> 2], E3[g6 + 16 >> 2] = 0 - e4, z2 = E3[g6 + 148 >> 2], E3[g6 + 12 >> 2] = 0 - z2, s4 = E3[g6 + 144 >> 2], E3[g6 + 8 >> 2] = 0 - s4, j2 = E3[g6 + 140 >> 2], E3[g6 + 4 >> 2] = 0 - j2, i4 = E3[g6 + 136 >> 2], E3[g6 >> 2] = 1 - i4, iA(g6, g6), I7 = PA(S4 = E3[g6 + 4 >> 2], R4 = S4 >> 31, J4 = l3 << 1, oA2 = J4 >> 31), B4 = t3, Q4 = PA(a4 = E3[g6 >> 2], Y4 = a4 >> 31, f4, U4 = f4 >> 31), B4 = t3 + B4 | 0, B4 = (I7 = Q4 + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (o4 = PA(D4 = E3[g6 + 8 >> 2], T2 = D4 >> 31, e4, d4 = e4 >> 31)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(L4 = E3[g6 + 12 >> 2], W2 = L4 >> 31, IA2 = z2 << 1, cA2 = IA2 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(V2 = E3[g6 + 16 >> 2], gA2 = V2 >> 31, s4, b4 = s4 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, HA2 = o4 = E3[g6 + 20 >> 2], n4 = PA(o4, aA2 = o4 >> 31, CA2 = j2 << 1, yA2 = CA2 >> 31), Q4 = t3 + I7 | 0, Q4 = (B4 = n4 + B4 | 0) >>> 0 < n4 >>> 0 ? Q4 + 1 | 0 : Q4, GA2 = p4 = E3[g6 + 24 >> 2], I7 = (i4 = PA(p4, NA2 = p4 >> 31, n4 = i4 + 1 | 0, P4 = n4 >> 31)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, fA2 = E3[g6 + 28 >> 2], Q4 = (i4 = PA(K4 = c3(fA2, 19), $2 = K4 >> 31, BA2 = u4 << 1, wA2 = BA2 >> 31)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, vA2 = E3[g6 + 32 >> 2], Q4 = PA(w4 = c3(vA2, 19), Z2 = w4 >> 31, F4, v4 = F4 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, RA2 = E3[g6 + 36 >> 2], Q4 = PA(k4 = c3(RA2, 19), x4 = k4 >> 31, QA2 = m4 << 1, rA2 = QA2 >> 31), I7 = t3 + I7 | 0, h4 = B4 = Q4 + B4 | 0, i4 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(e4, d4, S4, R4), B4 = t3, y4 = PA(a4, Y4, l3, tA2 = l3 >> 31), Q4 = t3 + B4 | 0, Q4 = (I7 = y4 + I7 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, y4 = PA(D4, T2, z2, hA2 = z2 >> 31), B4 = t3 + Q4 | 0, B4 = (I7 = y4 + I7 | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (y4 = PA(s4, b4, L4, W2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(V2, gA2, j2, kA2 = j2 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(n4, P4, o4, aA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, y4 = PA(p4 = c3(p4, 19), EA2 = p4 >> 31, u4, nA2 = u4 >> 31), Q4 = t3 + I7 | 0, Q4 = (B4 = y4 + B4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (y4 = PA(F4, v4, K4, $2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (y4 = PA(w4, Z2, m4, sA2 = m4 >> 31)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(f4, U4, k4, x4), I7 = t3 + I7 | 0, JA2 = B4 = B4 + Q4 | 0, AA2 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(S4, R4, IA2, cA2), Q4 = t3, B4 = (y4 = PA(a4, Y4, e4, d4)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, y4 = PA(s4, b4, D4, T2), Q4 = t3 + I7 | 0, Q4 = (B4 = y4 + B4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (y4 = PA(L4, W2, CA2, yA2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (y4 = PA(n4, P4, V2, gA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(y4 = c3(o4, 19), FA2 = y4 >> 31, BA2, wA2), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(F4, v4, p4, EA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, o4 = PA(K4, $2, QA2, rA2), Q4 = t3 + I7 | 0, Q4 = (B4 = o4 + B4 | 0) >>> 0 < o4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (o4 = PA(f4, U4, w4, Z2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (o4 = PA(k4, x4, J4, oA2)) + I7 | 0, I7 = t3 + B4 | 0, LA2 = Q4, xA2 = I7 = Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, uA2 = Q4 = Q4 + 33554432 | 0, mA2 = I7 = Q4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, Q4 = (67108863 & I7) << 6 | Q4 >>> 26, I7 = (I7 >> 26) + AA2 | 0, JA2 = o4 = Q4 + JA2 | 0, I7 = Q4 >>> 0 > o4 >>> 0 ? I7 + 1 | 0 : I7, qA2 = o4 = o4 + 16777216 | 0, I7 = (B4 = (Q4 = o4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7) >> 25) + i4 | 0, I7 = (Q4 = (o4 = (33554431 & Q4) << 7 | o4 >>> 25) + h4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, G4 = B4 = Q4 + 33554432 | 0, o4 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[g6 + 72 >> 2] = Q4 - (-67108864 & B4), I7 = PA(S4, R4, CA2, yA2), B4 = t3, i4 = PA(a4, Y4, s4, b4), Q4 = t3 + B4 | 0, Q4 = (I7 = i4 + I7 | 0) >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, B4 = (i4 = PA(n4, P4, D4, T2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(i4 = c3(L4, 19), MA2 = i4 >> 31, BA2, wA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (h4 = PA(AA2 = c3(V2, 19), _A2 = AA2 >> 31, F4, v4)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, h4 = PA(QA2, rA2, y4, FA2), I7 = t3 + B4 | 0, I7 = (Q4 = h4 + Q4 | 0) >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (h4 = PA(f4, U4, p4, EA2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < h4 >>> 0 ? Q4 + 1 | 0 : Q4, h4 = PA(K4, $2, J4, oA2), I7 = t3 + Q4 | 0, I7 = (B4 = h4 + B4 | 0) >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(e4, d4, w4, Z2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (h4 = PA(k4, x4, IA2, cA2)) + B4 | 0, B4 = t3 + I7 | 0, H4 = Q4, YA2 = Q4 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, I7 = PA(n4, P4, S4, R4), B4 = t3, Q4 = (h4 = PA(a4, Y4, j2, kA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, h4 = B4 = c3(D4, 19), B4 = (N4 = PA(B4, pA2 = B4 >> 31, u4, nA2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < N4 >>> 0 ? Q4 + 1 | 0 : Q4, N4 = PA(i4, MA2, F4, v4), I7 = t3 + Q4 | 0, I7 = (B4 = N4 + B4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(AA2, _A2, m4, sA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (N4 = PA(f4, U4, y4, FA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4, N4 = PA(p4, EA2, l3, tA2), I7 = t3 + B4 | 0, I7 = (Q4 = N4 + Q4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (N4 = PA(e4, d4, K4, $2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < N4 >>> 0 ? Q4 + 1 | 0 : Q4, N4 = PA(w4, Z2, z2, hA2), I7 = t3 + Q4 | 0, I7 = (B4 = N4 + B4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(s4, b4, k4, x4), I7 = t3 + I7 | 0, UA2 = B4 = Q4 + B4 | 0, N4 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(I7 = c3(S4, 19), I7 >> 31, BA2, wA2), B4 = t3, Q4 = PA(a4, Y4, n4, P4), B4 = t3 + B4 | 0, B4 = (I7 = Q4 + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (h4 = PA(h4, pA2, F4, v4)) + I7 | 0, I7 = t3 + B4 | 0, B4 = (i4 = PA(i4, MA2, QA2, rA2)) + Q4 | 0, Q4 = t3 + (Q4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7) | 0, Q4 = B4 >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, i4 = PA(f4, U4, AA2, _A2), I7 = t3 + Q4 | 0, I7 = (B4 = i4 + B4 | 0) >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(J4, oA2, y4, FA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (i4 = PA(e4, d4, p4, EA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, i4 = PA(K4, $2, IA2, cA2), I7 = t3 + B4 | 0, I7 = (Q4 = i4 + Q4 | 0) >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (i4 = PA(s4, b4, w4, Z2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, i4 = PA(k4, x4, CA2, yA2), I7 = t3 + Q4 | 0, h4 = B4 = i4 + B4 | 0, MA2 = I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, pA2 = B4 = B4 + 33554432 | 0, lA2 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, Q4 = I7 >> 26, I7 = (67108863 & I7) << 6 | B4 >>> 26, B4 = Q4 + N4 | 0, N4 = i4 = I7 + UA2 | 0, I7 = B4 = I7 >>> 0 > i4 >>> 0 ? B4 + 1 | 0 : B4, UA2 = i4 = i4 + 16777216 | 0, i4 = (33554431 & (I7 = i4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | i4 >>> 25, I7 = (I7 >> 25) + YA2 | 0, I7 = (B4 = i4 + H4 | 0) >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = B4, YA2 = B4 = B4 + 33554432 | 0, i4 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[g6 + 56 >> 2] = Q4 - (-67108864 & B4), I7 = PA(f4, U4, S4, R4), Q4 = t3, B4 = (H4 = PA(a4, Y4, m4, sA2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(D4, T2, l3, tA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(e4, d4, L4, W2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, H4 = PA(V2, gA2, z2, hA2), Q4 = t3 + I7 | 0, Q4 = (B4 = H4 + B4 | 0) >>> 0 < H4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (H4 = PA(s4, b4, HA2, aA2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < H4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (H4 = PA(j2, kA2, GA2, NA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(fA2, dA2 = fA2 >> 31, n4, P4), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(w4, Z2, u4, nA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, H4 = (Q4 = B4) + (B4 = PA(F4, v4, k4, x4)) | 0, Q4 = t3 + I7 | 0, B4 = (I7 = o4 >> 26) + (B4 = B4 >>> 0 > H4 >>> 0 ? Q4 + 1 | 0 : Q4) | 0, G4 = Q4 = (o4 = (67108863 & o4) << 6 | G4 >>> 26) + H4 | 0, I7 = B4 = Q4 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, H4 = Q4 = Q4 + 16777216 | 0, o4 = I7 = Q4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[g6 + 76 >> 2] = G4 - (-33554432 & Q4), I7 = PA(s4, b4, S4, R4), B4 = t3, G4 = PA(a4, Y4, z2, hA2), Q4 = t3 + B4 | 0, Q4 = (I7 = G4 + I7 | 0) >>> 0 < G4 >>> 0 ? Q4 + 1 | 0 : Q4, G4 = PA(D4, T2, j2, kA2), B4 = t3 + Q4 | 0, B4 = (I7 = G4 + I7 | 0) >>> 0 < G4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (G4 = PA(n4, P4, L4, W2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(AA2, _A2, u4, nA2), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(F4, v4, y4, FA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (p4 = PA(p4, EA2, m4, sA2)) + B4 | 0, Q4 = t3 + I7 | 0, I7 = (K4 = PA(f4, U4, K4, $2)) + B4 | 0, B4 = t3 + (B4 >>> 0 < p4 >>> 0 ? Q4 + 1 | 0 : Q4) | 0, Q4 = (w4 = PA(w4, Z2, l3, tA2)) + I7 | 0, I7 = t3 + (I7 >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = Q4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(e4, d4, k4, x4), I7 = t3 + I7 | 0, G4 = B4 = B4 + Q4 | 0, I7 = (I7 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7) + (B4 = i4 >> 26) | 0, w4 = i4 = G4 + (Q4 = (67108863 & i4) << 6 | YA2 >>> 26) | 0, I7 = Q4 >>> 0 > i4 >>> 0 ? I7 + 1 | 0 : I7, K4 = B4 = i4 + 16777216 | 0, i4 = Q4 = B4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[g6 + 60 >> 2] = w4 - (-33554432 & B4), I7 = PA(S4, R4, QA2, rA2), Q4 = t3, B4 = (w4 = PA(a4, Y4, F4, v4)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(f4, U4, D4, T2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, w4 = PA(L4, W2, J4, oA2), Q4 = t3 + I7 | 0, Q4 = (B4 = w4 + B4 | 0) >>> 0 < w4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (w4 = PA(e4, d4, V2, gA2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (w4 = PA(IA2, cA2, HA2, aA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(s4, b4, GA2, NA2), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = B4, B4 = PA(CA2, yA2, fA2, dA2), I7 = t3 + I7 | 0, I7 = B4 >>> 0 > (Q4 = Q4 + B4 | 0) >>> 0 ? I7 + 1 | 0 : I7, w4 = B4 = vA2, B4 = (J4 = PA(B4, p4 = B4 >> 31, n4, P4)) + Q4 | 0, Q4 = t3 + I7 | 0, I7 = (k4 = PA(k4, x4, BA2, wA2)) + B4 | 0, B4 = t3 + (B4 >>> 0 < J4 >>> 0 ? Q4 + 1 | 0 : Q4) | 0, Q4 = I7 >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, B4 = I7, I7 = (I7 = o4 >> 25) + Q4 | 0, I7 = (B4 = B4 + (o4 = (33554431 & o4) << 7 | H4 >>> 25) | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = B4, k4 = B4 = B4 + 33554432 | 0, o4 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[g6 + 80 >> 2] = Q4 - (-67108864 & B4), B4 = i4 >> 25, Q4 = (i4 = (33554431 & i4) << 7 | K4 >>> 25) + (LA2 - (I7 = -67108864 & uA2) | 0) | 0, I7 = B4 + (xA2 - ((I7 >>> 0 > LA2 >>> 0) + mA2 | 0) | 0) | 0, I7 = Q4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, I7 = ((67108863 & (I7 = (B4 = Q4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | B4 >>> 26) + (J4 = JA2 - (-33554432 & qA2) | 0) | 0, E3[g6 + 68 >> 2] = I7, E3[g6 + 64 >> 2] = Q4 - (-67108864 & B4), I7 = PA(F4, v4, S4, R4), Q4 = t3, B4 = (i4 = PA(a4, Y4, u4, nA2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (i4 = PA(D4, T2, m4, sA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, I7 = (i4 = PA(f4, U4, L4, W2)) + Q4 | 0, Q4 = t3 + B4 | 0, Q4 = I7 >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, B4 = (i4 = PA(V2, gA2, l3, tA2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(e4, d4, HA2, aA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(z2, hA2, GA2, NA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (i4 = PA(s4, b4, fA2, dA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, i4 = (I7 = PA(w4, p4, j2, kA2)) + Q4 | 0, Q4 = t3 + B4 | 0, Q4 = I7 >>> 0 > i4 >>> 0 ? Q4 + 1 | 0 : Q4, B4 = i4, i4 = PA(I7 = RA2, I7 >> 31, n4, P4), I7 = t3 + Q4 | 0, Q4 = B4 = B4 + i4 | 0, I7 = (I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7) + (B4 = o4 >> 26) | 0, I7 = (Q4 = Q4 + (o4 = (67108863 & o4) << 6 | k4 >>> 26) | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, I7 = (B4 = Q4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[g6 + 84 >> 2] = Q4 - (-33554432 & B4), o4 = N4 - (-33554432 & UA2) | 0, i4 = h4 - (Q4 = -67108864 & pA2) | 0, a4 = MA2 - ((Q4 >>> 0 > h4 >>> 0) + lA2 | 0) | 0, I7 = PA((33554431 & (Q4 = I7)) << 7 | B4 >>> 25, I7 >>= 25, 19, 0), B4 = t3 + a4 | 0, I7 = I7 >>> 0 > (Q4 = I7 + i4 | 0) >>> 0 ? B4 + 1 | 0 : B4, I7 = ((67108863 & (I7 = (B4 = Q4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | B4 >>> 26) + o4 | 0, E3[g6 + 52 >> 2] = I7, E3[g6 + 48 >> 2] = Q4 - (-67108864 & B4), eA(A8, g6 + 48 | 0)); + } + return r3 = g6 + 256 | 0, 0 | bA2; + }, sc: function(A8, I7) { + A8 |= 0; + var g6, B4 = 0; + return r3 = g6 = r3 + -64 | 0, FA(g6, I7 |= 0, 32, 0), C3[0 | g6] = 248 & i3[0 | g6], C3[g6 + 31 | 0] = 63 & i3[g6 + 31 | 0] | 64, I7 = E3[g6 + 20 >> 2], B4 = E3[g6 + 16 >> 2], C3[A8 + 16 | 0] = B4, C3[A8 + 17 | 0] = B4 >>> 8, C3[A8 + 18 | 0] = B4 >>> 16, C3[A8 + 19 | 0] = B4 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[g6 + 12 >> 2], B4 = E3[g6 + 8 >> 2], C3[A8 + 8 | 0] = B4, C3[A8 + 9 | 0] = B4 >>> 8, C3[A8 + 10 | 0] = B4 >>> 16, C3[A8 + 11 | 0] = B4 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[g6 + 4 >> 2], B4 = E3[g6 >> 2], C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = E3[g6 + 28 >> 2], B4 = E3[g6 + 24 >> 2], C3[A8 + 24 | 0] = B4, C3[A8 + 25 | 0] = B4 >>> 8, C3[A8 + 26 | 0] = B4 >>> 16, C3[A8 + 27 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, MI(g6, 64), r3 = g6 - -64 | 0, 0; + }, tc: function() { + var A8, I7; + return r3 = A8 = r3 - 16 | 0, C3[A8 + 15 | 0] = 0, I7 = 0 | y3(36304, A8 + 15 | 0, 0), r3 = A8 + 16 | 0, 0 | I7; + }, uc: QI, vc: function(A8) { + var I7, g6 = 0, B4 = 0; + if (r3 = I7 = r3 - 16 | 0, (A8 |= 0) >>> 0 >= 2) { + for (g6 = (0 - A8 >>> 0) % (A8 >>> 0) | 0; C3[I7 + 15 | 0] = 0, g6 >>> 0 > (B4 = 0 | y3(36304, I7 + 15 | 0, 0)) >>> 0; ) ; + g6 = (B4 >>> 0) % (A8 >>> 0) | 0; + } + return r3 = I7 + 16 | 0, 0 | g6; + }, wc: LA, xc: function(A8, I7, g6) { + eI(A8 |= 0, I7 |= 0, 33888, g6 |= 0); + }, yc: _I, zc: function() { + var A8 = 0, I7 = 0; + return (A8 = E3[9414]) && (A8 = E3[A8 + 20 >> 2]) && (I7 = 0 | vI[0 | A8]()), 0 | I7; + }, Ac: function(A8, I7, g6) { + A8 |= 0, I7 |= 0; + var B4, E4 = 0, i4 = 0, o4 = 0; + if (r3 = B4 = r3 - 16 | 0, g6 |= 0) f3(1228, 1088, 198, 1024), Q3(); + else { + if (I7 | g6) for (; C3[B4 + 15 | 0] = 0, i4 = A8 + E4 | 0, o4 = 0 | y3(36304, B4 + 15 | 0, 0), C3[0 | i4] = o4, (0 | I7) != (0 | (E4 = E4 + 1 | 0)); ) ; + r3 = B4 + 16 | 0; + } + }, Bc: function(A8, I7, g6, B4) { + A8 |= 0, g6 |= 0; + var E4 = 0, o4 = 0, c4 = 0; + if (!((B4 |= 0) >>> 0 > 2147483646 | B4 << 1 >>> 0 >= (I7 |= 0) >>> 0)) { + if (I7 = 0, B4) { + for (; E4 = (I7 << 1) + A8 | 0, o4 = 15 & (c4 = i3[I7 + g6 | 0]), C3[E4 + 1 | 0] = 22272 + ((o4 << 8) + (o4 + 65526 & 55552) | 0) >>> 8, o4 = E4, E4 = c4 >>> 4 | 0, C3[0 | o4] = 87 + ((E4 + 65526 >>> 8 & 217) + E4 | 0), (0 | B4) != (0 | (I7 = I7 + 1 | 0)); ) ; + I7 = B4 << 1; + } else I7 = 0; + return C3[I7 + A8 | 0] = 0, 0 | A8; + } + iI(), Q3(); + }, Cc: function(A8, I7, g6, B4, Q4, o4, c4) { + A8 |= 0, I7 |= 0, g6 |= 0, Q4 |= 0, o4 |= 0, c4 |= 0; + var D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0; + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + i: { + o: { + if (B4 |= 0) { + if (Q4) break o; + for (a4 = 1, Q4 = 0; ; ) { + if (!(255 & ((r4 = (65526 + (y4 = (223 & (e4 = i3[g6 + D4 | 0])) - 55 & 255) ^ y4 + 65520) >>> 8 | 0) | (t4 = 65526 + (e4 ^= 48) >>> 8 | 0)))) break E; + if (I7 >>> 0 <= w4 >>> 0) break i; + if (y4 = y4 & r4 | e4 & t4, 255 & f4 ? (C3[A8 + w4 | 0] = Q4 | y4, w4 = w4 + 1 | 0) : Q4 = y4 << 4, f4 = ~f4, (0 | (D4 = D4 + 1 | 0)) == (0 | B4)) break; + } + D4 = B4; + break E; + } + if (A8 = 0, !c4) break A; + break g; + } + for (; ; ) { + o: { + c: { + D: { + a: { + y: { + if (!(255 & ((e4 = (65526 + (a4 = (223 & (y4 = i3[g6 + D4 | 0])) - 55 & 255) ^ a4 + 65520) >>> 8 | 0) | (t4 = 65526 + (r4 = 48 ^ y4) >>> 8 | 0)))) { + if (255 & f4) break Q; + if (a4 = 0, !hA(Q4, y4)) break C; + if ((D4 = f4 = D4 + 1 | 0) >>> 0 < B4 >>> 0) break y; + break C; + } + if (I7 >>> 0 <= w4 >>> 0) break i; + if (a4 = a4 & e4 | r4 & t4, !(255 & f4)) break a; + C3[A8 + w4 | 0] = a4 | h4, w4 = w4 + 1 | 0; + break o; + } + for (; ; ) { + if (!(255 & ((r4 = (65526 + (e4 = (223 & (y4 = i3[g6 + D4 | 0])) - 55 & 255) ^ e4 + 65520) >>> 8 | 0) | (h4 = 65526 + (t4 = 48 ^ y4) >>> 8 | 0)))) { + if (!hA(Q4, y4)) break C; + if ((D4 = D4 + 1 | 0) >>> 0 < B4 >>> 0) continue; + break D; + } + break; + } + if (I7 >>> 0 <= w4 >>> 0) break c; + a4 = e4 & r4 | t4 & h4; + } + h4 = a4 << 4, f4 = 0; + break o; + } + D4 = B4 >>> 0 > f4 >>> 0 ? B4 : f4; + break C; + } + f4 = 0; + break i; + } + if (f4 = ~f4, a4 = 1, !((D4 = D4 + 1 | 0) >>> 0 < B4 >>> 0)) break; + } + break E; + } + E3[9280] = 68, a4 = 0; + } + if (!(255 & f4)) break B; + } + E3[9280] = 28, a4 = -1, D4 = D4 - 1 | 0, w4 = 0; + break C; + } + w4 = a4 ? w4 : 0, a4 = a4 - 1 | 0; + } + if (!c4) { + if ((0 | B4) != (0 | D4)) break I; + A8 = a4; + break A; + } + } + E3[c4 >> 2] = g6 + D4, A8 = a4; + break A; + } + E3[9280] = 28, A8 = -1; + } + return o4 && (E3[o4 >> 2] = w4), 0 | A8; + }, Dc: function(A8, I7) { + A8 |= 0; + var g6 = 0; + return 1 != (-7 & (I7 |= 0)) && (iI(), Q3()), 1 + ((3 & (g6 = (g6 = A8) + c3(A8 = (A8 >>> 0) / 3 | 0, -3) | 0) ? 2 & I7 ? g6 + 1 | 0 : 4 : 0) + (A8 << 2) | 0) | 0; + }, Ec: function(A8, I7, g6, B4, E4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0; + var o4 = 0, D4 = 0, a4 = 0, y4 = 0, e4 = 0, w4 = 0, r4 = 0; + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + if (1 == (-7 & (E4 |= 0)) && (a4 = (o4 = (B4 >>> 0) / 3 | 0) << 2, (o4 = c3(o4, -3) + B4 | 0) && (a4 = 2 & E4 ? 2 + ((o4 >>> 1 | 0) + a4 | 0) | 0 : a4 + 4 | 0), !(I7 >>> 0 <= a4 >>> 0))) { + if (!(E4 >>> 0 >= 4)) { + if (!B4) { + E4 = 0; + break C; + } + o4 = 0, E4 = 0; + break E; + } + if (!B4) { + E4 = 0; + break C; + } + for (o4 = 0, E4 = 0; ; ) { + for (e4 = i3[g6 + y4 | 0] | e4 << 8, o4 |= 8; w4 = 65510 + (D4 = e4 >>> (o4 = o4 - 6 | 0) & 63) >>> 8 | 0, r4 = D4 + 65484 >>> 8 | 0, C3[A8 + E4 | 0] = ~(1 + (16321 ^ D4)) >>> 8 & 45 | D4 + 252 & D4 + 65474 >>> 8 & ~r4 | ~(D4 + 32705) >>> 8 & 95 | w4 & D4 + 65 | r4 & D4 + 71 & ~w4, E4 = E4 + 1 | 0, o4 >>> 0 > 5; ) ; + if ((0 | (y4 = y4 + 1 | 0)) == (0 | B4)) break; + } + if (!o4) break B; + y4 = 45, D4 = 32705, B4 = 95; + break Q; + } + iI(), Q3(); + } + for (; ; ) { + for (e4 = i3[g6 + y4 | 0] | e4 << 8, o4 |= 8; w4 = 65510 + (D4 = e4 >>> (o4 = o4 - 6 | 0) & 63) >>> 8 | 0, r4 = D4 + 65484 >>> 8 | 0, C3[A8 + E4 | 0] = ~(1 + (16321 ^ D4)) >>> 8 & 43 | D4 + 252 & D4 + 65474 >>> 8 & ~r4 | ~(D4 + 16321) >>> 8 & 47 | w4 & D4 + 65 | r4 & D4 + 71 & ~w4, E4 = E4 + 1 | 0, o4 >>> 0 > 5; ) ; + if ((0 | (y4 = y4 + 1 | 0)) == (0 | B4)) break; + } + if (!o4) break B; + y4 = 43, D4 = 16321, B4 = 47; + } + D4 = ~((g6 = e4 << 6 - o4 & 63) + D4) >>> 8 & B4 | (o4 = g6 + 65510 >>> 8 | 0) & g6 + 65, B4 = g6 + 65484 >>> 8 | 0, C3[A8 + E4 | 0] = ~(1 + (16321 ^ g6)) >>> 8 & y4 | D4 | g6 + 252 & g6 + 65474 >>> 8 & ~B4 | B4 & g6 + 71 & ~o4, E4 = E4 + 1 | 0; + } + if (E4 >>> 0 > a4 >>> 0) break g; + } + if (E4 >>> 0 < a4 >>> 0) break I; + a4 = E4; + break A; + } + f3(1036, 1114, 231, 1300), Q3(); + } + VA(A8 + E4 | 0, 61, a4 - E4 | 0); + } + return VA(A8 + a4 | 0, 0, (I7 >>> 0 > (g6 = a4 + 1 | 0) >>> 0 ? I7 : g6) - a4 | 0), 0 | A8; + }, Fc: function(A8, I7, g6, B4, o4, c4, D4, a4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0; + var y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0; + if (1 == (-7 & (a4 |= 0))) { + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + if (B4) { + i: { + o: { + if (a4 >>> 0 <= 3) { + for (; ; ) { + w4 = f4; + c: { + D: { + a: { + y: { + for (; ; ) { + if (y4 = (y4 = (e4 = C3[g6 + w4 | 0]) - 65 | 0) & (~(90 - e4) & ~y4) >>> 8 & 255 | e4 + 4 & (~(e4 + 65488) & ~(57 - e4)) >>> 8 & 255 | e4 + 185 & (~(e4 + 65439) & ~(122 - e4)) >>> 8 & 255 | ~(1 + (16336 ^ e4)) >>> 8 & 63 | ~(1 + (16340 ^ e4)) >>> 8 & 62, 255 != (0 | (y4 |= (y4 - 1 & 1 + (65470 ^ e4)) >>> 8 & 255))) break y; + if (y4 = 0, !o4) break i; + if (!hA(o4, e4)) break; + if ((w4 = w4 + 1 | 0) >>> 0 >= B4 >>> 0) break a; + } + f4 = w4; + break i; + } + if (h4 = y4 + (h4 << 6) | 0, r4 >>> 0 > 1) break D; + r4 = r4 + 6 | 0; + break c; + } + f4 = (A8 = f4 + 1 | 0) >>> 0 < B4 >>> 0 ? B4 : A8; + break i; + } + if (r4 = r4 - 2 | 0, I7 >>> 0 <= t4 >>> 0) break o; + C3[A8 + t4 | 0] = h4 >>> r4, t4 = t4 + 1 | 0; + } + if (y4 = 0, !((f4 = w4 + 1 | 0) >>> 0 < B4 >>> 0)) break; + } + break i; + } + for (; ; ) { + c: { + if (y4 = (y4 = (e4 = C3[g6 + w4 | 0]) - 65 | 0) & (~(90 - e4) & ~y4) >>> 8 & 255 | e4 + 4 & (~(e4 + 65488) & ~(57 - e4)) >>> 8 & 255 | e4 + 185 & (~(e4 + 65439) & ~(122 - e4)) >>> 8 & 255 | ~(1 + (16288 ^ e4)) >>> 8 & 63 | ~(1 + (16338 ^ e4)) >>> 8 & 62, 255 == (0 | (y4 |= (y4 - 1 & 1 + (65470 ^ e4)) >>> 8 & 255))) { + if (y4 = 0, !o4) break i; + if (hA(o4, e4)) { + if ((w4 = w4 + 1 | 0) >>> 0 >= B4 >>> 0) break c; + continue; + } + f4 = w4; + break i; + } + if (h4 = y4 + (h4 << 6) | 0, r4 >>> 0 < 2) r4 = r4 + 6 | 0; + else { + if (r4 = r4 - 2 | 0, I7 >>> 0 <= t4 >>> 0) break o; + C3[A8 + t4 | 0] = h4 >>> r4, t4 = t4 + 1 | 0; + } + if (y4 = 0, (f4 = w4 + 1 | 0) >>> 0 >= B4 >>> 0) break i; + w4 = f4; + continue; + } + break; + } + f4 = (A8 = f4 + 1 | 0) >>> 0 < B4 >>> 0 ? B4 : A8; + break i; + } + f4 = w4, E3[9280] = 68, y4 = 1; + } + if (r4 >>> 0 > 4) break E; + A8 = f4; + } else A8 = 0; + if (I7 = -1, y4) { + f4 = A8; + break A; + } + if (~(-1 << r4) & h4) { + f4 = A8; + break A; + } + if (2 & a4) { + a4 = A8; + break B; + } + if (r4 >>> 0 < 2) { + a4 = A8; + break B; + } + if (f4 = A8 >>> 0 > B4 >>> 0 ? A8 : B4, w4 = r4 >>> 1 | 0, !o4) break Q; + for (a4 = A8; ; ) { + if ((0 | a4) == (0 | f4)) { + y4 = 68; + break C; + } + if (61 != (0 | (A8 = C3[g6 + a4 | 0]))) { + if (!hA(o4, A8)) { + y4 = 28, f4 = a4; + break C; + } + } else w4 = w4 - 1 | 0; + if (a4 = a4 + 1 | 0, !w4) break; + } + break B; + } + I7 = -1; + break A; + } + if (y4 = 68, A8 >>> 0 >= B4 >>> 0) break C; + if (61 != i3[A8 + g6 | 0]) { + f4 = A8, y4 = 28; + break C; + } + if (a4 = A8 + w4 | 0, 1 != (0 | w4)) { + if ((0 | (r4 = A8 + 1 | 0)) == (0 | f4)) break C; + if (61 != i3[g6 + r4 | 0]) { + f4 = r4, y4 = 28; + break C; + } + if (2 != (0 | w4)) { + if ((0 | (A8 = A8 + 2 | 0)) == (0 | f4)) break C; + if (y4 = 28, f4 = A8, 61 != i3[A8 + g6 | 0]) break C; + } + } + } + if (I7 = 0, o4) break g; + break I; + } + E3[9280] = y4; + break A; + } + if (!(B4 >>> 0 <= a4 >>> 0)) { + for (; ; ) { + if (!hA(o4, C3[g6 + a4 | 0])) break I; + if ((0 | (a4 = a4 + 1 | 0)) == (0 | B4)) break; + } + a4 = B4; + } + } + f4 = a4, k4 = t4; + } + return D4 ? E3[D4 >> 2] = g6 + f4 : (0 | B4) != (0 | f4) && (E3[9280] = 28, I7 = -1), c4 && (E3[c4 >> 2] = k4), 0 | I7; + } + iI(), Q3(); + }, Gc: function() { + var A8 = 0; + return E3[9412] ? A8 = 1 : (QI(), LA(37632, 16), E3[9412] = 1, A8 = 0), 0 | A8; + }, Hc: function(A8, I7, g6, B4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, o4 |= 0; + var c4, D4 = 0, a4 = 0, y4 = 0; + r3 = c4 = r3 - 16 | 0; + A: { + if (B4 |= 0) { + if ((D4 = B4 - 1 | 0) & B4 ? (a4 = ~g6, D4 = D4 - ((g6 >>> 0) % (B4 >>> 0) | 0) | 0) : D4 &= a4 = ~g6, D4 >>> 0 >= a4 >>> 0) break A; + if ((g6 = g6 + D4 | 0) >>> 0 >= o4 >>> 0) I7 = -1; + else for (A8 && (E3[A8 >> 2] = g6 + 1), A8 = I7 + g6 | 0, I7 = 0, C3[c4 + 15 | 0] = 0, g6 = 0; a4 = o4 = A8 - g6 | 0, y4 = i3[0 | o4] & i3[c4 + 15 | 0], o4 = (g6 ^ D4) - 1 >>> 24 | 0, C3[0 | a4] = y4 | 128 & o4, C3[c4 + 15 | 0] = o4 | i3[c4 + 15 | 0], (0 | B4) != (0 | (g6 = g6 + 1 | 0)); ) ; + } else I7 = -1; + return r3 = c4 + 16 | 0, 0 | I7; + } + iI(), Q3(); + }, Ic: function(A8, I7, g6, C4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0; + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0; + if (E3[12 + (B4 = r3 - 16 | 0) >> 2] = 0, C4 - 1 >>> 0 < g6 >>> 0) { + for (a4 = (Q4 = g6 - 1 | 0) + I7 | 0, g6 = 0, I7 = 0; D4 = ((128 ^ (o4 = i3[a4 - g6 | 0])) - 1 & E3[B4 + 12 >> 2] - 1 & c4 - 1) >>> 8 & 1, E3[B4 + 12 >> 2] = E3[B4 + 12 >> 2] | 0 - D4 & g6, I7 |= D4, c4 |= o4, (0 | C4) != (0 | (g6 = g6 + 1 | 0)); ) ; + E3[A8 >> 2] = Q4 - E3[B4 + 12 >> 2], A8 = (255 & I7) - 1 | 0; + } else A8 = -1; + return 0 | A8; + }, Jc: function() { + return 1318; + }, Kc: function() { + return 26; + }, Lc: bI, Mc: dI, Nc: function(A8) { + var I7, g6 = 0, C4 = 0, B4 = 0, Q4 = 0, c4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0; + r3 = I7 = r3 - 16 | 0; + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + i: { + o: { + c: { + if ((A8 |= 0) >>> 0 <= 244) { + if (3 & (g6 = (Q4 = E3[9281]) >>> (A8 = (y4 = A8 >>> 0 < 11 ? 16 : A8 + 11 & 504) >>> 3 | 0) | 0)) { + A8 = 37164 + (g6 = (C4 = A8 + (1 & ~g6) | 0) << 3) | 0, g6 = E3[g6 + 37172 >> 2], (0 | A8) != (0 | (B4 = E3[g6 + 8 >> 2])) ? (E3[B4 + 12 >> 2] = A8, E3[A8 + 8 >> 2] = B4) : (t4 = 37124, h4 = gI(-2, C4) & Q4, E3[t4 >> 2] = h4), A8 = g6 + 8 | 0, C4 <<= 3, E3[g6 + 4 >> 2] = 3 | C4, E3[4 + (g6 = g6 + C4 | 0) >> 2] = 1 | E3[g6 + 4 >> 2]; + break A; + } + if ((f4 = E3[9283]) >>> 0 >= y4 >>> 0) break c; + if (g6) { + g6 = 37164 + (C4 = (A8 = aI((0 - (C4 = 2 << A8) | C4) & g6 << A8)) << 3) | 0, C4 = E3[C4 + 37172 >> 2], (0 | g6) != (0 | (B4 = E3[C4 + 8 >> 2])) ? (E3[B4 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = B4) : (Q4 = gI(-2, A8) & Q4, E3[9281] = Q4), E3[C4 + 4 >> 2] = 3 | y4, c4 = (A8 <<= 3) - y4 | 0, E3[4 + (a4 = C4 + y4 | 0) >> 2] = 1 | c4, E3[A8 + C4 >> 2] = c4, f4 && (A8 = 37164 + (-8 & f4) | 0, B4 = E3[9286], (g6 = 1 << (f4 >>> 3)) & Q4 ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | Q4, g6 = A8), E3[A8 + 8 >> 2] = B4, E3[g6 + 12 >> 2] = B4, E3[B4 + 12 >> 2] = A8, E3[B4 + 8 >> 2] = g6), A8 = C4 + 8 | 0, E3[9286] = a4, E3[9283] = c4; + break A; + } + if (!(w4 = E3[9282])) break c; + for (C4 = E3[37428 + (aI(w4) << 2) >> 2], c4 = (-8 & E3[C4 + 4 >> 2]) - y4 | 0, g6 = C4; (A8 = E3[g6 + 16 >> 2]) || (A8 = E3[g6 + 20 >> 2]); ) c4 = (g6 = (B4 = (-8 & E3[A8 + 4 >> 2]) - y4 | 0) >>> 0 < c4 >>> 0) ? B4 : c4, C4 = g6 ? A8 : C4, g6 = A8; + if (e4 = E3[C4 + 24 >> 2], (0 | C4) != (0 | (A8 = E3[C4 + 12 >> 2]))) { + g6 = E3[C4 + 8 >> 2], E3[g6 + 12 >> 2] = A8, E3[A8 + 8 >> 2] = g6; + break I; + } + if (g6 = E3[C4 + 20 >> 2]) B4 = C4 + 20 | 0; + else { + if (!(g6 = E3[C4 + 16 >> 2])) break o; + B4 = C4 + 16 | 0; + } + for (; a4 = B4, B4 = (A8 = g6) + 20 | 0, (g6 = E3[A8 + 20 >> 2]) || (B4 = A8 + 16 | 0, g6 = E3[A8 + 16 >> 2]); ) ; + E3[a4 >> 2] = 0; + break I; + } + if (y4 = -1, !(A8 >>> 0 > 4294967231) && (y4 = -8 & (g6 = A8 + 11 | 0), a4 = E3[9282])) { + f4 = 31, c4 = 0 - y4 | 0, A8 >>> 0 <= 16777204 && (f4 = 62 + ((y4 >>> 38 - (A8 = D3(g6 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0); + D: { + a: { + if (g6 = E3[37428 + (f4 << 2) >> 2]) for (A8 = 0, C4 = y4 << (31 != (0 | f4) ? 25 - (f4 >>> 1 | 0) : 0); ; ) { + if (!((Q4 = (-8 & E3[g6 + 4 >> 2]) - y4 | 0) >>> 0 >= c4 >>> 0 || (B4 = g6, c4 = Q4))) { + c4 = 0, A8 = g6; + break a; + } + if (Q4 = E3[g6 + 20 >> 2], g6 = E3[16 + ((C4 >>> 29 & 4) + g6 | 0) >> 2], A8 = Q4 ? (0 | Q4) == (0 | g6) ? A8 : Q4 : A8, C4 <<= 1, !g6) break; + } + else A8 = 0; + if (!(A8 | B4)) { + if (B4 = 0, !(A8 = (0 - (A8 = 2 << f4) | A8) & a4)) break c; + A8 = E3[37428 + (aI(A8) << 2) >> 2]; + } + if (!A8) break D; + } + for (; c4 = (g6 = (C4 = (-8 & E3[A8 + 4 >> 2]) - y4 | 0) >>> 0 < c4 >>> 0) ? C4 : c4, B4 = g6 ? A8 : B4, A8 = (g6 = E3[A8 + 16 >> 2]) || E3[A8 + 20 >> 2]; ) ; + } + if (!(!B4 | E3[9283] - y4 >>> 0 <= c4 >>> 0)) { + if (f4 = E3[B4 + 24 >> 2], (0 | B4) != (0 | (A8 = E3[B4 + 12 >> 2]))) { + g6 = E3[B4 + 8 >> 2], E3[g6 + 12 >> 2] = A8, E3[A8 + 8 >> 2] = g6; + break g; + } + if (g6 = E3[B4 + 20 >> 2]) C4 = B4 + 20 | 0; + else { + if (!(g6 = E3[B4 + 16 >> 2])) break i; + C4 = B4 + 16 | 0; + } + for (; Q4 = C4, C4 = (A8 = g6) + 20 | 0, (g6 = E3[A8 + 20 >> 2]) || (C4 = A8 + 16 | 0, g6 = E3[A8 + 16 >> 2]); ) ; + E3[Q4 >> 2] = 0; + break g; + } + } + } + if ((B4 = E3[9283]) >>> 0 >= y4 >>> 0) { + A8 = E3[9286], (g6 = B4 - y4 | 0) >>> 0 >= 16 ? (E3[4 + (C4 = A8 + y4 | 0) >> 2] = 1 | g6, E3[A8 + B4 >> 2] = g6, E3[A8 + 4 >> 2] = 3 | y4) : (E3[A8 + 4 >> 2] = 3 | B4, E3[4 + (g6 = A8 + B4 | 0) >> 2] = 1 | E3[g6 + 4 >> 2], C4 = 0, g6 = 0), E3[9283] = g6, E3[9286] = C4, A8 = A8 + 8 | 0; + break A; + } + if ((C4 = E3[9284]) >>> 0 > y4 >>> 0) { + g6 = C4 - y4 | 0, E3[9284] = g6, C4 = (A8 = E3[9287]) + y4 | 0, E3[9287] = C4, E3[C4 + 4 >> 2] = 1 | g6, E3[A8 + 4 >> 2] = 3 | y4, A8 = A8 + 8 | 0; + break A; + } + if (A8 = 0, c4 = y4 + 47 | 0, E3[9399] ? g6 = E3[9401] : (E3[9402] = -1, E3[9403] = -1, E3[9400] = 4096, E3[9401] = 4096, E3[9399] = I7 + 12 & -16 ^ 1431655768, E3[9404] = 0, E3[9392] = 0, g6 = 4096), (g6 = (Q4 = c4 + g6 | 0) & (a4 = 0 - g6 | 0)) >>> 0 <= y4 >>> 0) break A; + if ((f4 = E3[9391]) && (B4 = (e4 = E3[9389]) + g6 | 0) >>> 0 <= e4 >>> 0 | B4 >>> 0 > f4 >>> 0) break A; + c: { + if (!(4 & i3[37568])) { + D: { + a: { + y: { + f: { + if (B4 = E3[9287]) for (A8 = 37572; ; ) { + if ((f4 = E3[A8 >> 2]) >>> 0 <= B4 >>> 0 & B4 >>> 0 < f4 + E3[A8 + 4 >> 2] >>> 0) break f; + if (!(A8 = E3[A8 + 8 >> 2])) break; + } + if (-1 == (0 | (C4 = uA(0)))) break D; + if (Q4 = g6, (B4 = (A8 = E3[9400]) - 1 | 0) & C4 && (Q4 = (g6 - C4 | 0) + (C4 + B4 & 0 - A8) | 0), Q4 >>> 0 <= y4 >>> 0) break D; + if ((B4 = E3[9391]) && (A8 = (a4 = E3[9389]) + Q4 | 0) >>> 0 <= a4 >>> 0 | A8 >>> 0 > B4 >>> 0) break D; + if ((0 | C4) != (0 | (A8 = uA(Q4)))) break y; + break c; + } + if ((0 | (C4 = uA(Q4 = a4 & Q4 - C4))) == (E3[A8 >> 2] + E3[A8 + 4 >> 2] | 0)) break a; + A8 = C4; + } + if (-1 == (0 | A8)) break D; + if (y4 + 48 >>> 0 <= Q4 >>> 0) { + C4 = A8; + break c; + } + if (-1 == (0 | uA(C4 = (C4 = E3[9401]) + (c4 - Q4 | 0) & 0 - C4))) break D; + Q4 = C4 + Q4 | 0, C4 = A8; + break c; + } + if (-1 != (0 | C4)) break c; + } + E3[9392] = 4 | E3[9392]; + } + if (-1 == (0 | (C4 = uA(g6))) | -1 == (0 | (A8 = uA(0))) | A8 >>> 0 <= C4 >>> 0) break B; + if ((Q4 = A8 - C4 | 0) >>> 0 <= y4 + 40 >>> 0) break B; + } + A8 = E3[9389] + Q4 | 0, E3[9389] = A8, A8 >>> 0 > o3[9390] && (E3[9390] = A8); + c: { + if (c4 = E3[9287]) { + for (A8 = 37572; ; ) { + if (((g6 = E3[A8 >> 2]) + (B4 = E3[A8 + 4 >> 2]) | 0) == (0 | C4)) break c; + if (!(A8 = E3[A8 + 8 >> 2])) break; + } + break E; + } + for ((A8 = E3[9285]) >>> 0 <= C4 >>> 0 && A8 || (E3[9285] = C4), A8 = 0, E3[9394] = Q4, E3[9393] = C4, E3[9289] = -1, E3[9290] = E3[9399], E3[9396] = 0; B4 = 37164 + (g6 = A8 << 3) | 0, E3[g6 + 37172 >> 2] = B4, E3[g6 + 37176 >> 2] = B4, 32 != (0 | (A8 = A8 + 1 | 0)); ) ; + B4 = (A8 = Q4 - 40 | 0) - (g6 = -8 - C4 & 7) | 0, E3[9284] = B4, g6 = g6 + C4 | 0, E3[9287] = g6, E3[g6 + 4 >> 2] = 1 | B4, E3[4 + (A8 + C4 | 0) >> 2] = 40, E3[9288] = E3[9403]; + break Q; + } + if (8 & E3[A8 + 12 >> 2] | C4 >>> 0 <= c4 >>> 0 | g6 >>> 0 > c4 >>> 0) break E; + E3[A8 + 4 >> 2] = B4 + Q4, g6 = (A8 = -8 - c4 & 7) + c4 | 0, E3[9287] = g6, A8 = (C4 = E3[9284] + Q4 | 0) - A8 | 0, E3[9284] = A8, E3[g6 + 4 >> 2] = 1 | A8, E3[4 + (C4 + c4 | 0) >> 2] = 40, E3[9288] = E3[9403]; + break Q; + } + A8 = 0; + break I; + } + A8 = 0; + break g; + } + o3[9285] > C4 >>> 0 && (E3[9285] = C4), B4 = C4 + Q4 | 0, A8 = 37572; + E: { + for (; ; ) { + if ((0 | (g6 = E3[A8 >> 2])) != (0 | B4)) { + if (A8 = E3[A8 + 8 >> 2]) continue; + break E; + } + break; + } + if (!(8 & i3[A8 + 12 | 0])) break C; + } + for (A8 = 37572; !((g6 = E3[A8 >> 2]) >>> 0 <= c4 >>> 0 && (B4 = g6 + E3[A8 + 4 >> 2] | 0) >>> 0 > c4 >>> 0); ) A8 = E3[A8 + 8 >> 2]; + for (a4 = (A8 = Q4 - 40 | 0) - (g6 = -8 - C4 & 7) | 0, E3[9284] = a4, g6 = g6 + C4 | 0, E3[9287] = g6, E3[g6 + 4 >> 2] = 1 | a4, E3[4 + (A8 + C4 | 0) >> 2] = 40, E3[9288] = E3[9403], E3[(g6 = (A8 = (B4 + (39 - B4 & 7) | 0) - 47 | 0) >>> 0 < c4 + 16 >>> 0 ? c4 : A8) + 4 >> 2] = 27, A8 = E3[9396], E3[g6 + 16 >> 2] = E3[9395], E3[g6 + 20 >> 2] = A8, A8 = E3[9394], E3[g6 + 8 >> 2] = E3[9393], E3[g6 + 12 >> 2] = A8, E3[9395] = g6 + 8, E3[9394] = Q4, E3[9393] = C4, E3[9396] = 0, A8 = g6 + 24 | 0; E3[A8 + 4 >> 2] = 7, C4 = A8 + 8 | 0, A8 = A8 + 4 | 0, C4 >>> 0 < B4 >>> 0; ) ; + if ((0 | g6) != (0 | c4)) { + E3[g6 + 4 >> 2] = -2 & E3[g6 + 4 >> 2], C4 = g6 - c4 | 0, E3[c4 + 4 >> 2] = 1 | C4, E3[g6 >> 2] = C4; + E: if (C4 >>> 0 <= 255) A8 = 37164 + (-8 & C4) | 0, (g6 = E3[9281]) & (C4 = 1 << (C4 >>> 3)) ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | C4, g6 = A8), E3[A8 + 8 >> 2] = c4, E3[g6 + 12 >> 2] = c4, B4 = 8, C4 = 12; + else { + A8 = 31, C4 >>> 0 <= 16777215 && (A8 = 62 + ((C4 >>> 38 - (A8 = D3(C4 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0), E3[c4 + 28 >> 2] = A8, E3[c4 + 16 >> 2] = 0, E3[c4 + 20 >> 2] = 0, g6 = 37428 + (A8 << 2) | 0; + i: { + if ((B4 = E3[9282]) & (Q4 = 1 << A8)) { + for (A8 = C4 << (31 != (0 | A8) ? 25 - (A8 >>> 1 | 0) : 0), B4 = E3[g6 >> 2]; ; ) { + if ((0 | C4) == (-8 & E3[(g6 = B4) + 4 >> 2])) break i; + if (B4 = A8 >>> 29 | 0, A8 <<= 1, !(B4 = E3[16 + (Q4 = (4 & B4) + g6 | 0) >> 2])) break; + } + E3[Q4 + 16 >> 2] = c4; + } else E3[9282] = B4 | Q4, E3[g6 >> 2] = c4; + E3[c4 + 24 >> 2] = g6, A8 = g6 = c4, B4 = 12, C4 = 8; + break E; + } + A8 = E3[g6 + 8 >> 2], E3[A8 + 12 >> 2] = c4, E3[g6 + 8 >> 2] = c4, E3[c4 + 8 >> 2] = A8, A8 = 0, B4 = 12, C4 = 24; + } + E3[B4 + c4 >> 2] = g6, E3[C4 + c4 >> 2] = A8; + } + } + if (!((A8 = E3[9284]) >>> 0 <= y4 >>> 0)) { + g6 = A8 - y4 | 0, E3[9284] = g6, C4 = (A8 = E3[9287]) + y4 | 0, E3[9287] = C4, E3[C4 + 4 >> 2] = 1 | g6, E3[A8 + 4 >> 2] = 3 | y4, A8 = A8 + 8 | 0; + break A; + } + } + E3[9280] = 48, A8 = 0; + break A; + } + E3[A8 >> 2] = C4, E3[A8 + 4 >> 2] = E3[A8 + 4 >> 2] + Q4, E3[4 + (f4 = (-8 - C4 & 7) + C4 | 0) >> 2] = 3 | y4, a4 = (Q4 = g6 + (-8 - g6 & 7) | 0) - (c4 = y4 + f4 | 0) | 0; + C: if (E3[9287] != (0 | Q4)) if (E3[9286] != (0 | Q4)) { + if (1 == (3 & (A8 = E3[Q4 + 4 >> 2]))) { + e4 = -8 & A8, C4 = E3[Q4 + 12 >> 2]; + B: if (A8 >>> 0 <= 255) { + if ((0 | (g6 = E3[Q4 + 8 >> 2])) == (0 | C4)) { + t4 = 37124, h4 = E3[9281] & gI(-2, A8 >>> 3 | 0), E3[t4 >> 2] = h4; + break B; + } + E3[g6 + 12 >> 2] = C4, E3[C4 + 8 >> 2] = g6; + } else { + y4 = E3[Q4 + 24 >> 2]; + Q: if ((0 | C4) == (0 | Q4)) { + E: { + if (A8 = E3[Q4 + 20 >> 2]) g6 = Q4 + 20 | 0; + else { + if (!(A8 = E3[Q4 + 16 >> 2])) break E; + g6 = Q4 + 16 | 0; + } + for (; B4 = g6, C4 = A8, g6 = A8 + 20 | 0, (A8 = E3[A8 + 20 >> 2]) || (g6 = C4 + 16 | 0, A8 = E3[C4 + 16 >> 2]); ) ; + E3[B4 >> 2] = 0; + break Q; + } + C4 = 0; + } else A8 = E3[Q4 + 8 >> 2], E3[A8 + 12 >> 2] = C4, E3[C4 + 8 >> 2] = A8; + if (y4) { + A8 = E3[Q4 + 28 >> 2]; + Q: { + if (E3[(g6 = 37428 + (A8 << 2) | 0) >> 2] == (0 | Q4)) { + if (E3[g6 >> 2] = C4, C4) break Q; + t4 = 37128, h4 = E3[9282] & gI(-2, A8), E3[t4 >> 2] = h4; + break B; + } + if (E3[y4 + (E3[y4 + 16 >> 2] == (0 | Q4) ? 16 : 20) >> 2] = C4, !C4) break B; + } + E3[C4 + 24 >> 2] = y4, (A8 = E3[Q4 + 16 >> 2]) && (E3[C4 + 16 >> 2] = A8, E3[A8 + 24 >> 2] = C4), (A8 = E3[Q4 + 20 >> 2]) && (E3[C4 + 20 >> 2] = A8, E3[A8 + 24 >> 2] = C4); + } + } + a4 = a4 + e4 | 0, A8 = E3[4 + (Q4 = Q4 + e4 | 0) >> 2]; + } + if (E3[Q4 + 4 >> 2] = -2 & A8, E3[c4 + 4 >> 2] = 1 | a4, E3[c4 + a4 >> 2] = a4, a4 >>> 0 <= 255) A8 = 37164 + (-8 & a4) | 0, (g6 = E3[9281]) & (C4 = 1 << (a4 >>> 3)) ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | C4, g6 = A8), E3[A8 + 8 >> 2] = c4, E3[g6 + 12 >> 2] = c4, E3[c4 + 12 >> 2] = A8, E3[c4 + 8 >> 2] = g6; + else { + C4 = 31, a4 >>> 0 <= 16777215 && (C4 = 62 + ((a4 >>> 38 - (A8 = D3(a4 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0), E3[c4 + 28 >> 2] = C4, E3[c4 + 16 >> 2] = 0, E3[c4 + 20 >> 2] = 0, A8 = 37428 + (C4 << 2) | 0; + B: { + if ((g6 = E3[9282]) & (B4 = 1 << C4)) { + for (C4 = a4 << (31 != (0 | C4) ? 25 - (C4 >>> 1 | 0) : 0), g6 = E3[A8 >> 2]; ; ) { + if ((-8 & E3[(A8 = g6) + 4 >> 2]) == (0 | a4)) break B; + if (g6 = C4 >>> 29 | 0, C4 <<= 1, !(g6 = E3[16 + (B4 = (4 & g6) + A8 | 0) >> 2])) break; + } + E3[B4 + 16 >> 2] = c4; + } else E3[9282] = g6 | B4, E3[A8 >> 2] = c4; + E3[c4 + 24 >> 2] = A8, E3[c4 + 12 >> 2] = c4, E3[c4 + 8 >> 2] = c4; + break C; + } + g6 = E3[A8 + 8 >> 2], E3[g6 + 12 >> 2] = c4, E3[A8 + 8 >> 2] = c4, E3[c4 + 24 >> 2] = 0, E3[c4 + 12 >> 2] = A8, E3[c4 + 8 >> 2] = g6; + } + } else E3[9286] = c4, A8 = E3[9283] + a4 | 0, E3[9283] = A8, E3[c4 + 4 >> 2] = 1 | A8, E3[A8 + c4 >> 2] = A8; + else E3[9287] = c4, A8 = E3[9284] + a4 | 0, E3[9284] = A8, E3[c4 + 4 >> 2] = 1 | A8; + A8 = f4 + 8 | 0; + break A; + } + g: if (f4) { + g6 = E3[B4 + 28 >> 2]; + C: { + if (E3[(C4 = 37428 + (g6 << 2) | 0) >> 2] == (0 | B4)) { + if (E3[C4 >> 2] = A8, A8) break C; + a4 = gI(-2, g6) & a4, E3[9282] = a4; + break g; + } + if (E3[f4 + (E3[f4 + 16 >> 2] == (0 | B4) ? 16 : 20) >> 2] = A8, !A8) break g; + } + E3[A8 + 24 >> 2] = f4, (g6 = E3[B4 + 16 >> 2]) && (E3[A8 + 16 >> 2] = g6, E3[g6 + 24 >> 2] = A8), (g6 = E3[B4 + 20 >> 2]) && (E3[A8 + 20 >> 2] = g6, E3[g6 + 24 >> 2] = A8); + } + g: if (c4 >>> 0 <= 15) A8 = c4 + y4 | 0, E3[B4 + 4 >> 2] = 3 | A8, E3[4 + (A8 = A8 + B4 | 0) >> 2] = 1 | E3[A8 + 4 >> 2]; + else if (E3[B4 + 4 >> 2] = 3 | y4, E3[4 + (Q4 = B4 + y4 | 0) >> 2] = 1 | c4, E3[c4 + Q4 >> 2] = c4, c4 >>> 0 <= 255) A8 = 37164 + (-8 & c4) | 0, (g6 = E3[9281]) & (C4 = 1 << (c4 >>> 3)) ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | C4, g6 = A8), E3[A8 + 8 >> 2] = Q4, E3[g6 + 12 >> 2] = Q4, E3[Q4 + 12 >> 2] = A8, E3[Q4 + 8 >> 2] = g6; + else { + A8 = 31, c4 >>> 0 <= 16777215 && (A8 = 62 + ((c4 >>> 38 - (A8 = D3(c4 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0), E3[Q4 + 28 >> 2] = A8, E3[Q4 + 16 >> 2] = 0, E3[Q4 + 20 >> 2] = 0, g6 = 37428 + (A8 << 2) | 0; + C: { + if ((C4 = 1 << A8) & a4) { + for (A8 = c4 << (31 != (0 | A8) ? 25 - (A8 >>> 1 | 0) : 0), g6 = E3[g6 >> 2]; ; ) { + if (C4 = g6, (-8 & E3[g6 + 4 >> 2]) == (0 | c4)) break C; + if (a4 = A8 >>> 29 | 0, A8 <<= 1, !(g6 = E3[16 + (a4 = g6 + (4 & a4) | 0) >> 2])) break; + } + E3[a4 + 16 >> 2] = Q4, E3[Q4 + 24 >> 2] = C4; + } else E3[9282] = C4 | a4, E3[g6 >> 2] = Q4, E3[Q4 + 24 >> 2] = g6; + E3[Q4 + 12 >> 2] = Q4, E3[Q4 + 8 >> 2] = Q4; + break g; + } + A8 = E3[C4 + 8 >> 2], E3[A8 + 12 >> 2] = Q4, E3[C4 + 8 >> 2] = Q4, E3[Q4 + 24 >> 2] = 0, E3[Q4 + 12 >> 2] = C4, E3[Q4 + 8 >> 2] = A8; + } + A8 = B4 + 8 | 0; + break A; + } + I: if (e4) { + g6 = E3[C4 + 28 >> 2]; + g: { + if (E3[(B4 = 37428 + (g6 << 2) | 0) >> 2] == (0 | C4)) { + if (E3[B4 >> 2] = A8, A8) break g; + t4 = 37128, h4 = gI(-2, g6) & w4, E3[t4 >> 2] = h4; + break I; + } + if (E3[e4 + (E3[e4 + 16 >> 2] == (0 | C4) ? 16 : 20) >> 2] = A8, !A8) break I; + } + E3[A8 + 24 >> 2] = e4, (g6 = E3[C4 + 16 >> 2]) && (E3[A8 + 16 >> 2] = g6, E3[g6 + 24 >> 2] = A8), (g6 = E3[C4 + 20 >> 2]) && (E3[A8 + 20 >> 2] = g6, E3[g6 + 24 >> 2] = A8); + } + c4 >>> 0 <= 15 ? (A8 = c4 + y4 | 0, E3[C4 + 4 >> 2] = 3 | A8, E3[4 + (A8 = A8 + C4 | 0) >> 2] = 1 | E3[A8 + 4 >> 2]) : (E3[C4 + 4 >> 2] = 3 | y4, E3[4 + (a4 = C4 + y4 | 0) >> 2] = 1 | c4, E3[c4 + a4 >> 2] = c4, f4 && (A8 = 37164 + (-8 & f4) | 0, B4 = E3[9286], (g6 = 1 << (f4 >>> 3)) & Q4 ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | Q4, g6 = A8), E3[A8 + 8 >> 2] = B4, E3[g6 + 12 >> 2] = B4, E3[B4 + 12 >> 2] = A8, E3[B4 + 8 >> 2] = g6), E3[9286] = a4, E3[9283] = c4), A8 = C4 + 8 | 0; + } + return r3 = I7 + 16 | 0, 0 | A8; + }, Oc: function(A8) { + var I7 = 0, g6 = 0, C4 = 0, B4 = 0, Q4 = 0, i4 = 0, c4 = 0, a4 = 0, y4 = 0; + A: if (A8 |= 0) { + Q4 = (C4 = A8 - 8 | 0) + (A8 = -8 & (I7 = E3[A8 - 4 >> 2])) | 0; + I: if (!(1 & I7)) { + if (!(2 & I7)) break A; + if ((C4 = C4 - (I7 = E3[C4 >> 2]) | 0) >>> 0 < o3[9285]) break A; + A8 = A8 + I7 | 0; + g: { + C: { + B: { + if (E3[9286] != (0 | C4)) { + if (g6 = E3[C4 + 12 >> 2], I7 >>> 0 <= 255) { + if ((0 | (B4 = E3[C4 + 8 >> 2])) != (0 | g6)) break B; + a4 = 37124, y4 = E3[9281] & gI(-2, I7 >>> 3 | 0), E3[a4 >> 2] = y4; + break I; + } + if (c4 = E3[C4 + 24 >> 2], (0 | g6) != (0 | C4)) { + I7 = E3[C4 + 8 >> 2], E3[I7 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = I7; + break g; + } + if (B4 = E3[C4 + 20 >> 2]) I7 = C4 + 20 | 0; + else { + if (!(B4 = E3[C4 + 16 >> 2])) break C; + I7 = C4 + 16 | 0; + } + for (; i4 = I7, I7 = (g6 = B4) + 20 | 0, (B4 = E3[g6 + 20 >> 2]) || (I7 = g6 + 16 | 0, B4 = E3[g6 + 16 >> 2]); ) ; + E3[i4 >> 2] = 0; + break g; + } + if (3 & ~(I7 = E3[Q4 + 4 >> 2])) break I; + return E3[9283] = A8, E3[Q4 + 4 >> 2] = -2 & I7, E3[C4 + 4 >> 2] = 1 | A8, void (E3[Q4 >> 2] = A8); + } + E3[B4 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = B4; + break I; + } + g6 = 0; + } + if (c4) { + I7 = E3[C4 + 28 >> 2]; + g: { + if (E3[(B4 = 37428 + (I7 << 2) | 0) >> 2] == (0 | C4)) { + if (E3[B4 >> 2] = g6, g6) break g; + a4 = 37128, y4 = E3[9282] & gI(-2, I7), E3[a4 >> 2] = y4; + break I; + } + if (E3[c4 + (E3[c4 + 16 >> 2] == (0 | C4) ? 16 : 20) >> 2] = g6, !g6) break I; + } + E3[g6 + 24 >> 2] = c4, (I7 = E3[C4 + 16 >> 2]) && (E3[g6 + 16 >> 2] = I7, E3[I7 + 24 >> 2] = g6), (I7 = E3[C4 + 20 >> 2]) && (E3[g6 + 20 >> 2] = I7, E3[I7 + 24 >> 2] = g6); + } + } + if (!(C4 >>> 0 >= Q4 >>> 0) && 1 & (I7 = E3[Q4 + 4 >> 2])) { + I: { + g: { + C: { + B: { + if (!(2 & I7)) { + if ((0 | Q4) == E3[9287]) { + if (E3[9287] = C4, A8 = E3[9284] + A8 | 0, E3[9284] = A8, E3[C4 + 4 >> 2] = 1 | A8, E3[9286] != (0 | C4)) break A; + return E3[9283] = 0, void (E3[9286] = 0); + } + if ((0 | Q4) == E3[9286]) return E3[9286] = C4, A8 = E3[9283] + A8 | 0, E3[9283] = A8, E3[C4 + 4 >> 2] = 1 | A8, void (E3[A8 + C4 >> 2] = A8); + if (A8 = (-8 & I7) + A8 | 0, g6 = E3[Q4 + 12 >> 2], I7 >>> 0 <= 255) { + if ((0 | (B4 = E3[Q4 + 8 >> 2])) == (0 | g6)) { + a4 = 37124, y4 = E3[9281] & gI(-2, I7 >>> 3 | 0), E3[a4 >> 2] = y4; + break g; + } + E3[B4 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = B4; + break g; + } + if (c4 = E3[Q4 + 24 >> 2], (0 | g6) != (0 | Q4)) { + I7 = E3[Q4 + 8 >> 2], E3[I7 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = I7; + break C; + } + if (B4 = E3[Q4 + 20 >> 2]) I7 = Q4 + 20 | 0; + else { + if (!(B4 = E3[Q4 + 16 >> 2])) break B; + I7 = Q4 + 16 | 0; + } + for (; i4 = I7, I7 = (g6 = B4) + 20 | 0, (B4 = E3[g6 + 20 >> 2]) || (I7 = g6 + 16 | 0, B4 = E3[g6 + 16 >> 2]); ) ; + E3[i4 >> 2] = 0; + break C; + } + E3[Q4 + 4 >> 2] = -2 & I7, E3[C4 + 4 >> 2] = 1 | A8, E3[A8 + C4 >> 2] = A8; + break I; + } + g6 = 0; + } + if (c4) { + I7 = E3[Q4 + 28 >> 2]; + C: { + if ((0 | Q4) == E3[(B4 = 37428 + (I7 << 2) | 0) >> 2]) { + if (E3[B4 >> 2] = g6, g6) break C; + a4 = 37128, y4 = E3[9282] & gI(-2, I7), E3[a4 >> 2] = y4; + break g; + } + if (E3[c4 + ((0 | Q4) == E3[c4 + 16 >> 2] ? 16 : 20) >> 2] = g6, !g6) break g; + } + E3[g6 + 24 >> 2] = c4, (I7 = E3[Q4 + 16 >> 2]) && (E3[g6 + 16 >> 2] = I7, E3[I7 + 24 >> 2] = g6), (I7 = E3[Q4 + 20 >> 2]) && (E3[g6 + 20 >> 2] = I7, E3[I7 + 24 >> 2] = g6); + } + } + if (E3[C4 + 4 >> 2] = 1 | A8, E3[A8 + C4 >> 2] = A8, E3[9286] == (0 | C4)) return void (E3[9283] = A8); + } + if (A8 >>> 0 <= 255) return I7 = 37164 + (-8 & A8) | 0, (B4 = E3[9281]) & (A8 = 1 << (A8 >>> 3)) ? A8 = E3[I7 + 8 >> 2] : (E3[9281] = A8 | B4, A8 = I7), E3[I7 + 8 >> 2] = C4, E3[A8 + 12 >> 2] = C4, E3[C4 + 12 >> 2] = I7, void (E3[C4 + 8 >> 2] = A8); + g6 = 31, A8 >>> 0 <= 16777215 && (g6 = 62 + ((A8 >>> 38 - (I7 = D3(A8 >>> 8 | 0)) & 1) - (I7 << 1) | 0) | 0), E3[C4 + 28 >> 2] = g6, E3[C4 + 16 >> 2] = 0, E3[C4 + 20 >> 2] = 0, i4 = 37428 + (g6 << 2) | 0; + I: { + g: { + if ((I7 = E3[9282]) & (B4 = 1 << g6)) { + for (g6 = A8 << (31 != (0 | g6) ? 25 - (g6 >>> 1 | 0) : 0), I7 = E3[i4 >> 2]; ; ) { + if (B4 = I7, (-8 & E3[I7 + 4 >> 2]) == (0 | A8)) break g; + if (I7 = g6 >>> 29 | 0, g6 <<= 1, !(I7 = E3[(i4 = 16 + ((4 & I7) + B4 | 0) | 0) >> 2])) break; + } + g6 = 24, I7 = B4; + } else E3[9282] = I7 | B4, g6 = 24, I7 = i4; + B4 = C4, Q4 = C4, A8 = 8; + break I; + } + I7 = E3[B4 + 8 >> 2], E3[I7 + 12 >> 2] = C4, g6 = 8, i4 = B4 + 8 | 0, Q4 = 0, A8 = 24; + } + E3[i4 >> 2] = C4, E3[g6 + C4 >> 2] = I7, E3[C4 + 12 >> 2] = B4, E3[A8 + C4 >> 2] = Q4, A8 = E3[9289] - 1 | 0, E3[9289] = A8 || -1; + } + } + }, Pc: vI }; + }(A6); + }(I5); + }, instantiate: function(A5, I5) { + return { then: function(g4) { + var C2 = new w2.Module(A5); + g4({ instance: new w2.Instance(C2, I5) }); + } }; + }, RuntimeError: Error }; + y2 = []; + var r2, t2, h2, k2, n2, s2, F2, S2 = false; + function M2() { + var A5 = e2.buffer; + B2.HEAP8 = r2 = new Int8Array(A5), B2.HEAP16 = h2 = new Int16Array(A5), B2.HEAPU8 = t2 = new Uint8Array(A5), B2.HEAPU16 = new Uint16Array(A5), B2.HEAP32 = k2 = new Int32Array(A5), B2.HEAPU32 = n2 = new Uint32Array(A5), B2.HEAPF32 = s2 = new Float32Array(A5), B2.HEAPF64 = F2 = new Float64Array(A5); + } + var N2 = [], K2 = [], _2 = [], p2 = 0, H2 = null, G2 = null; + function J2(A5) { + throw B2.onAbort?.(A5), f2(A5 = "Aborted(" + A5 + ")"), S2 = true, A5 += ". Build with -sASSERTIONS for more info.", new w2.RuntimeError(A5); + } + var Y2, U2 = (A5) => A5.startsWith("file://"); + var d2 = { 36304: () => B2.getRandomValue(), 36340: () => { + if (void 0 === B2.getRandomValue) try { + var A5 = "object" == typeof window ? window : self, I5 = void 0 !== A5.crypto ? A5.crypto : A5.msCrypto; + I5 = void 0 === I5 ? C2 : I5; + var g4 = function() { + var A6 = new Uint32Array(1); + return I5.getRandomValues(A6), A6[0] >>> 0; + }; + g4(), B2.getRandomValue = g4; + } catch (A6) { + try { + var C2 = require("crypto"), Q3 = function() { + var A7 = C2.randomBytes(4); + return (A7[0] << 24 | A7[1] << 16 | A7[2] << 8 | A7[3]) >>> 0; + }; + Q3(), B2.getRandomValue = Q3; + } catch (A7) { + throw "No secure random number generator found"; + } + } + } }, b2 = (A5) => { + for (; A5.length > 0; ) A5.shift()(B2); + }; + B2.noExitRuntime; + var P2, v2 = "undefined" != typeof TextDecoder ? new TextDecoder() : void 0, R2 = (A5, I5) => A5 ? ((A6, I6, g4) => { + for (var C2 = I6 + g4, B3 = I6; A6[B3] && !(B3 >= C2); ) ++B3; + if (B3 - I6 > 16 && A6.buffer && v2) return v2.decode(A6.subarray(I6, B3)); + for (var Q3 = ""; I6 < B3; ) { + var E3 = A6[I6++]; + if (128 & E3) { + var i3 = 63 & A6[I6++]; + if (192 != (224 & E3)) { + var o3 = 63 & A6[I6++]; + if ((E3 = 224 == (240 & E3) ? (15 & E3) << 12 | i3 << 6 | o3 : (7 & E3) << 18 | i3 << 12 | o3 << 6 | 63 & A6[I6++]) < 65536) Q3 += String.fromCharCode(E3); + else { + var c3 = E3 - 65536; + Q3 += String.fromCharCode(55296 | c3 >> 10, 56320 | 1023 & c3); + } + } else Q3 += String.fromCharCode((31 & E3) << 6 | i3); + } else Q3 += String.fromCharCode(E3); + } + return Q3; + })(t2, A5, I5) : "", L2 = [], x2 = (A5) => { + var I5 = (A5 - e2.buffer.byteLength + 65535) / 65536; + try { + return e2.grow(I5), M2(), 1; + } catch (A6) { + } + }, u2 = { b: (A5, I5, g4, C2) => { + J2(`Assertion failed: ${R2(A5)}, at: ` + [I5 ? R2(I5) : "unknown filename", g4, C2 ? R2(C2) : "unknown function"]); + }, c: () => { + J2(""); + }, a: (A5, I5, g4) => ((A6, I6, g5) => { + var C2 = ((A7, I7) => { + var g6; + for (L2.length = 0; g6 = t2[A7++]; ) { + var C3 = 105 != g6; + I7 += (C3 &= 112 != g6) && I7 % 8 ? 4 : 0, L2.push(112 == g6 ? n2[I7 >> 2] : 105 == g6 ? k2[I7 >> 2] : F2[I7 >> 3]), I7 += C3 ? 8 : 4; + } + return L2; + })(I6, g5); + return d2[A6](...C2); + })(A5, I5, g4), d: (A5) => { + var I5 = t2.length, g4 = 2147483648; + if ((A5 >>>= 0) > g4) return false; + for (var C2, B3 = 1; B3 <= 4; B3 *= 2) { + var Q3 = I5 * (1 + 0.2 / B3); + Q3 = Math.min(Q3, A5 + 100663296); + var E3 = Math.min(g4, (C2 = Math.max(A5, Q3)) + (65536 - C2 % 65536) % 65536); + if (x2(E3)) return true; + } + return false; + } }, m2 = function() { + var A5 = { a: u2 }; + function I5(A6, I6) { + var g4; + return m2 = A6.exports, e2 = m2.e, M2(), g4 = m2.f, K2.unshift(g4), function(A7) { + if (p2--, B2.monitorRunDependencies?.(p2), 0 == p2 && (null !== H2 && (clearInterval(H2), H2 = null), G2)) { + var I7 = G2; + G2 = null, I7(); + } + }(), m2; + } + if (p2++, B2.monitorRunDependencies?.(p2), B2.instantiateWasm) try { + return B2.instantiateWasm(A5, I5); + } catch (A6) { + return f2(`Module.instantiateWasm callback failed with error: ${A6}`), false; + } + return Y2 || (Y2 = "<<< WASM_BINARY_FILE >>>"), function(A6, I6, C2) { + (function(A7) { + return Promise.resolve().then(() => function(A8) { + if (A8 == Y2 && y2) return new Uint8Array(y2); + if (g3) return g3(A8); + throw "both async and sync fetching of the wasm failed"; + }(A7)); + })(A6).then((A7) => w2.instantiate(A7, I6)).then(C2, (A7) => { + f2(`failed to asynchronously prepare wasm: ${A7}`), J2(A7); + }); + }(Y2, A5, function(A6) { + I5(A6.instance); + }), {}; + }(); + function q2() { + function A5() { + P2 || (P2 = true, B2.calledRun = true, S2 || (b2(K2), B2.onRuntimeInitialized?.(), function() { + if (B2.postRun) for ("function" == typeof B2.postRun && (B2.postRun = [B2.postRun]); B2.postRun.length; ) A6 = B2.postRun.shift(), _2.unshift(A6); + var A6; + b2(_2); + }())); + } + p2 > 0 || (function() { + if (B2.preRun) for ("function" == typeof B2.preRun && (B2.preRun = [B2.preRun]); B2.preRun.length; ) A6 = B2.preRun.shift(), N2.unshift(A6); + var A6; + b2(N2); + }(), p2 > 0 || (B2.setStatus ? (B2.setStatus("Running..."), setTimeout(function() { + setTimeout(function() { + B2.setStatus(""); + }, 1), A5(); + }, 1)) : A5())); + } + if (B2._crypto_aead_aegis128l_keybytes = () => (B2._crypto_aead_aegis128l_keybytes = m2.g)(), B2._crypto_aead_aegis128l_nsecbytes = () => (B2._crypto_aead_aegis128l_nsecbytes = m2.h)(), B2._crypto_aead_aegis128l_npubbytes = () => (B2._crypto_aead_aegis128l_npubbytes = m2.i)(), B2._crypto_aead_aegis128l_abytes = () => (B2._crypto_aead_aegis128l_abytes = m2.j)(), B2._crypto_aead_aegis128l_messagebytes_max = () => (B2._crypto_aead_aegis128l_messagebytes_max = m2.k)(), B2._crypto_aead_aegis128l_keygen = (A5) => (B2._crypto_aead_aegis128l_keygen = m2.l)(A5), B2._crypto_aead_aegis128l_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis128l_encrypt = m2.m)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis128l_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_aegis128l_encrypt_detached = m2.n)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_aegis128l_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis128l_decrypt = m2.o)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis128l_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis128l_decrypt_detached = m2.p)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis256_keybytes = () => (B2._crypto_aead_aegis256_keybytes = m2.q)(), B2._crypto_aead_aegis256_nsecbytes = () => (B2._crypto_aead_aegis256_nsecbytes = m2.r)(), B2._crypto_aead_aegis256_npubbytes = () => (B2._crypto_aead_aegis256_npubbytes = m2.s)(), B2._crypto_aead_aegis256_abytes = () => (B2._crypto_aead_aegis256_abytes = m2.t)(), B2._crypto_aead_aegis256_messagebytes_max = () => (B2._crypto_aead_aegis256_messagebytes_max = m2.u)(), B2._crypto_aead_aegis256_keygen = (A5) => (B2._crypto_aead_aegis256_keygen = m2.v)(A5), B2._crypto_aead_aegis256_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis256_encrypt = m2.w)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis256_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_aegis256_encrypt_detached = m2.x)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_aegis256_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis256_decrypt = m2.y)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis256_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis256_decrypt_detached = m2.z)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aes256gcm_is_available = () => (B2._crypto_aead_aes256gcm_is_available = m2.A)(), B2._crypto_aead_chacha20poly1305_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_chacha20poly1305_encrypt_detached = m2.B)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_chacha20poly1305_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_encrypt = m2.C)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_chacha20poly1305_ietf_encrypt_detached = m2.D)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_chacha20poly1305_ietf_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_ietf_encrypt = m2.E)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_decrypt_detached = m2.F)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_decrypt = m2.G)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_ietf_decrypt_detached = m2.H)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_ietf_decrypt = m2.I)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_keybytes = () => (B2._crypto_aead_chacha20poly1305_ietf_keybytes = m2.J)(), B2._crypto_aead_chacha20poly1305_ietf_npubbytes = () => (B2._crypto_aead_chacha20poly1305_ietf_npubbytes = m2.K)(), B2._crypto_aead_chacha20poly1305_ietf_nsecbytes = () => (B2._crypto_aead_chacha20poly1305_ietf_nsecbytes = m2.L)(), B2._crypto_aead_chacha20poly1305_ietf_abytes = () => (B2._crypto_aead_chacha20poly1305_ietf_abytes = m2.M)(), B2._crypto_aead_chacha20poly1305_ietf_messagebytes_max = () => (B2._crypto_aead_chacha20poly1305_ietf_messagebytes_max = m2.N)(), B2._crypto_aead_chacha20poly1305_ietf_keygen = (A5) => (B2._crypto_aead_chacha20poly1305_ietf_keygen = m2.O)(A5), B2._crypto_aead_chacha20poly1305_keybytes = () => (B2._crypto_aead_chacha20poly1305_keybytes = m2.P)(), B2._crypto_aead_chacha20poly1305_npubbytes = () => (B2._crypto_aead_chacha20poly1305_npubbytes = m2.Q)(), B2._crypto_aead_chacha20poly1305_nsecbytes = () => (B2._crypto_aead_chacha20poly1305_nsecbytes = m2.R)(), B2._crypto_aead_chacha20poly1305_abytes = () => (B2._crypto_aead_chacha20poly1305_abytes = m2.S)(), B2._crypto_aead_chacha20poly1305_messagebytes_max = () => (B2._crypto_aead_chacha20poly1305_messagebytes_max = m2.T)(), B2._crypto_aead_chacha20poly1305_keygen = (A5) => (B2._crypto_aead_chacha20poly1305_keygen = m2.U)(A5), B2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = m2.V)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_xchacha20poly1305_ietf_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_xchacha20poly1305_ietf_encrypt = m2.W)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = m2.X)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_xchacha20poly1305_ietf_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_xchacha20poly1305_ietf_decrypt = m2.Y)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_xchacha20poly1305_ietf_keybytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_keybytes = m2.Z)(), B2._crypto_aead_xchacha20poly1305_ietf_npubbytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_npubbytes = m2._)(), B2._crypto_aead_xchacha20poly1305_ietf_nsecbytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_nsecbytes = m2.$)(), B2._crypto_aead_xchacha20poly1305_ietf_abytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_abytes = m2.aa)(), B2._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = () => (B2._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = m2.ba)(), B2._crypto_aead_xchacha20poly1305_ietf_keygen = (A5) => (B2._crypto_aead_xchacha20poly1305_ietf_keygen = m2.ca)(A5), B2._crypto_auth_bytes = () => (B2._crypto_auth_bytes = m2.da)(), B2._crypto_auth_keybytes = () => (B2._crypto_auth_keybytes = m2.ea)(), B2._crypto_auth = (A5, I5, g4, C2, Q3) => (B2._crypto_auth = m2.fa)(A5, I5, g4, C2, Q3), B2._crypto_auth_verify = (A5, I5, g4, C2, Q3) => (B2._crypto_auth_verify = m2.ga)(A5, I5, g4, C2, Q3), B2._crypto_auth_keygen = (A5) => (B2._crypto_auth_keygen = m2.ha)(A5), B2._crypto_box_seedbytes = () => (B2._crypto_box_seedbytes = m2.ia)(), B2._crypto_box_publickeybytes = () => (B2._crypto_box_publickeybytes = m2.ja)(), B2._crypto_box_secretkeybytes = () => (B2._crypto_box_secretkeybytes = m2.ka)(), B2._crypto_box_beforenmbytes = () => (B2._crypto_box_beforenmbytes = m2.la)(), B2._crypto_box_noncebytes = () => (B2._crypto_box_noncebytes = m2.ma)(), B2._crypto_box_macbytes = () => (B2._crypto_box_macbytes = m2.na)(), B2._crypto_box_messagebytes_max = () => (B2._crypto_box_messagebytes_max = m2.oa)(), B2._crypto_box_seed_keypair = (A5, I5, g4) => (B2._crypto_box_seed_keypair = m2.pa)(A5, I5, g4), B2._crypto_box_keypair = (A5, I5) => (B2._crypto_box_keypair = m2.qa)(A5, I5), B2._crypto_box_beforenm = (A5, I5, g4) => (B2._crypto_box_beforenm = m2.ra)(A5, I5, g4), B2._crypto_box_detached_afternm = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_detached_afternm = m2.sa)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_detached = (A5, I5, g4, C2, Q3, E3, i3, o3) => (B2._crypto_box_detached = m2.ta)(A5, I5, g4, C2, Q3, E3, i3, o3), B2._crypto_box_easy_afternm = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_box_easy_afternm = m2.ua)(A5, I5, g4, C2, Q3, E3), B2._crypto_box_easy = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_easy = m2.va)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_open_detached_afternm = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_open_detached_afternm = m2.wa)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_open_detached = (A5, I5, g4, C2, Q3, E3, i3, o3) => (B2._crypto_box_open_detached = m2.xa)(A5, I5, g4, C2, Q3, E3, i3, o3), B2._crypto_box_open_easy_afternm = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_box_open_easy_afternm = m2.ya)(A5, I5, g4, C2, Q3, E3), B2._crypto_box_open_easy = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_open_easy = m2.za)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_seal = (A5, I5, g4, C2, Q3) => (B2._crypto_box_seal = m2.Aa)(A5, I5, g4, C2, Q3), B2._crypto_box_seal_open = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_box_seal_open = m2.Ba)(A5, I5, g4, C2, Q3, E3), B2._crypto_box_sealbytes = () => (B2._crypto_box_sealbytes = m2.Ca)(), B2._crypto_generichash_bytes_min = () => (B2._crypto_generichash_bytes_min = m2.Da)(), B2._crypto_generichash_bytes_max = () => (B2._crypto_generichash_bytes_max = m2.Ea)(), B2._crypto_generichash_bytes = () => (B2._crypto_generichash_bytes = m2.Fa)(), B2._crypto_generichash_keybytes_min = () => (B2._crypto_generichash_keybytes_min = m2.Ga)(), B2._crypto_generichash_keybytes_max = () => (B2._crypto_generichash_keybytes_max = m2.Ha)(), B2._crypto_generichash_keybytes = () => (B2._crypto_generichash_keybytes = m2.Ia)(), B2._crypto_generichash_statebytes = () => (B2._crypto_generichash_statebytes = m2.Ja)(), B2._crypto_generichash = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_generichash = m2.Ka)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_generichash_init = (A5, I5, g4, C2) => (B2._crypto_generichash_init = m2.La)(A5, I5, g4, C2), B2._crypto_generichash_update = (A5, I5, g4, C2) => (B2._crypto_generichash_update = m2.Ma)(A5, I5, g4, C2), B2._crypto_generichash_final = (A5, I5, g4) => (B2._crypto_generichash_final = m2.Na)(A5, I5, g4), B2._crypto_generichash_keygen = (A5) => (B2._crypto_generichash_keygen = m2.Oa)(A5), B2._crypto_hash_bytes = () => (B2._crypto_hash_bytes = m2.Pa)(), B2._crypto_hash = (A5, I5, g4, C2) => (B2._crypto_hash = m2.Qa)(A5, I5, g4, C2), B2._crypto_kdf_bytes_min = () => (B2._crypto_kdf_bytes_min = m2.Ra)(), B2._crypto_kdf_bytes_max = () => (B2._crypto_kdf_bytes_max = m2.Sa)(), B2._crypto_kdf_contextbytes = () => (B2._crypto_kdf_contextbytes = m2.Ta)(), B2._crypto_kdf_keybytes = () => (B2._crypto_kdf_keybytes = m2.Ua)(), B2._crypto_kdf_derive_from_key = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_kdf_derive_from_key = m2.Va)(A5, I5, g4, C2, Q3, E3), B2._crypto_kdf_keygen = (A5) => (B2._crypto_kdf_keygen = m2.Wa)(A5), B2._crypto_kdf_hkdf_sha256_extract_init = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha256_extract_init = m2.Xa)(A5, I5, g4), B2._crypto_kdf_hkdf_sha256_extract_update = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha256_extract_update = m2.Ya)(A5, I5, g4), B2._crypto_kdf_hkdf_sha256_extract_final = (A5, I5) => (B2._crypto_kdf_hkdf_sha256_extract_final = m2.Za)(A5, I5), B2._crypto_kdf_hkdf_sha256_extract = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha256_extract = m2._a)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha256_keygen = (A5) => (B2._crypto_kdf_hkdf_sha256_keygen = m2.$a)(A5), B2._crypto_kdf_hkdf_sha256_expand = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha256_expand = m2.ab)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha256_keybytes = () => (B2._crypto_kdf_hkdf_sha256_keybytes = m2.bb)(), B2._crypto_kdf_hkdf_sha256_bytes_min = () => (B2._crypto_kdf_hkdf_sha256_bytes_min = m2.cb)(), B2._crypto_kdf_hkdf_sha256_bytes_max = () => (B2._crypto_kdf_hkdf_sha256_bytes_max = m2.db)(), B2._crypto_kdf_hkdf_sha256_statebytes = () => (B2._crypto_kdf_hkdf_sha256_statebytes = m2.eb)(), B2._crypto_kdf_hkdf_sha512_extract_init = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha512_extract_init = m2.fb)(A5, I5, g4), B2._crypto_kdf_hkdf_sha512_extract_update = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha512_extract_update = m2.gb)(A5, I5, g4), B2._crypto_kdf_hkdf_sha512_extract_final = (A5, I5) => (B2._crypto_kdf_hkdf_sha512_extract_final = m2.hb)(A5, I5), B2._crypto_kdf_hkdf_sha512_extract = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha512_extract = m2.ib)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha512_keygen = (A5) => (B2._crypto_kdf_hkdf_sha512_keygen = m2.jb)(A5), B2._crypto_kdf_hkdf_sha512_expand = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha512_expand = m2.kb)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha512_keybytes = () => (B2._crypto_kdf_hkdf_sha512_keybytes = m2.lb)(), B2._crypto_kdf_hkdf_sha512_bytes_min = () => (B2._crypto_kdf_hkdf_sha512_bytes_min = m2.mb)(), B2._crypto_kdf_hkdf_sha512_bytes_max = () => (B2._crypto_kdf_hkdf_sha512_bytes_max = m2.nb)(), B2._crypto_kdf_hkdf_sha512_statebytes = () => (B2._crypto_kdf_hkdf_sha512_statebytes = m2.ob)(), B2._crypto_kx_seed_keypair = (A5, I5, g4) => (B2._crypto_kx_seed_keypair = m2.pb)(A5, I5, g4), B2._crypto_kx_keypair = (A5, I5) => (B2._crypto_kx_keypair = m2.qb)(A5, I5), B2._crypto_kx_client_session_keys = (A5, I5, g4, C2, Q3) => (B2._crypto_kx_client_session_keys = m2.rb)(A5, I5, g4, C2, Q3), B2._crypto_kx_server_session_keys = (A5, I5, g4, C2, Q3) => (B2._crypto_kx_server_session_keys = m2.sb)(A5, I5, g4, C2, Q3), B2._crypto_kx_publickeybytes = () => (B2._crypto_kx_publickeybytes = m2.tb)(), B2._crypto_kx_secretkeybytes = () => (B2._crypto_kx_secretkeybytes = m2.ub)(), B2._crypto_kx_seedbytes = () => (B2._crypto_kx_seedbytes = m2.vb)(), B2._crypto_kx_sessionkeybytes = () => (B2._crypto_kx_sessionkeybytes = m2.wb)(), B2._crypto_scalarmult_base = (A5, I5) => (B2._crypto_scalarmult_base = m2.xb)(A5, I5), B2._crypto_scalarmult = (A5, I5, g4) => (B2._crypto_scalarmult = m2.yb)(A5, I5, g4), B2._crypto_scalarmult_bytes = () => (B2._crypto_scalarmult_bytes = m2.zb)(), B2._crypto_scalarmult_scalarbytes = () => (B2._crypto_scalarmult_scalarbytes = m2.Ab)(), B2._crypto_secretbox_keybytes = () => (B2._crypto_secretbox_keybytes = m2.Bb)(), B2._crypto_secretbox_noncebytes = () => (B2._crypto_secretbox_noncebytes = m2.Cb)(), B2._crypto_secretbox_macbytes = () => (B2._crypto_secretbox_macbytes = m2.Db)(), B2._crypto_secretbox_messagebytes_max = () => (B2._crypto_secretbox_messagebytes_max = m2.Eb)(), B2._crypto_secretbox_keygen = (A5) => (B2._crypto_secretbox_keygen = m2.Fb)(A5), B2._crypto_secretbox_detached = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_secretbox_detached = m2.Gb)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_secretbox_easy = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_secretbox_easy = m2.Hb)(A5, I5, g4, C2, Q3, E3), B2._crypto_secretbox_open_detached = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_secretbox_open_detached = m2.Ib)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_secretbox_open_easy = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_secretbox_open_easy = m2.Jb)(A5, I5, g4, C2, Q3, E3), B2._crypto_secretstream_xchacha20poly1305_keygen = (A5) => (B2._crypto_secretstream_xchacha20poly1305_keygen = m2.Kb)(A5), B2._crypto_secretstream_xchacha20poly1305_init_push = (A5, I5, g4) => (B2._crypto_secretstream_xchacha20poly1305_init_push = m2.Lb)(A5, I5, g4), B2._crypto_secretstream_xchacha20poly1305_init_pull = (A5, I5, g4) => (B2._crypto_secretstream_xchacha20poly1305_init_pull = m2.Mb)(A5, I5, g4), B2._crypto_secretstream_xchacha20poly1305_rekey = (A5) => (B2._crypto_secretstream_xchacha20poly1305_rekey = m2.Nb)(A5), B2._crypto_secretstream_xchacha20poly1305_push = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3) => (B2._crypto_secretstream_xchacha20poly1305_push = m2.Ob)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3), B2._crypto_secretstream_xchacha20poly1305_pull = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3) => (B2._crypto_secretstream_xchacha20poly1305_pull = m2.Pb)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3), B2._crypto_secretstream_xchacha20poly1305_statebytes = () => (B2._crypto_secretstream_xchacha20poly1305_statebytes = m2.Qb)(), B2._crypto_secretstream_xchacha20poly1305_abytes = () => (B2._crypto_secretstream_xchacha20poly1305_abytes = m2.Rb)(), B2._crypto_secretstream_xchacha20poly1305_headerbytes = () => (B2._crypto_secretstream_xchacha20poly1305_headerbytes = m2.Sb)(), B2._crypto_secretstream_xchacha20poly1305_keybytes = () => (B2._crypto_secretstream_xchacha20poly1305_keybytes = m2.Tb)(), B2._crypto_secretstream_xchacha20poly1305_messagebytes_max = () => (B2._crypto_secretstream_xchacha20poly1305_messagebytes_max = m2.Ub)(), B2._crypto_secretstream_xchacha20poly1305_tag_message = () => (B2._crypto_secretstream_xchacha20poly1305_tag_message = m2.Vb)(), B2._crypto_secretstream_xchacha20poly1305_tag_push = () => (B2._crypto_secretstream_xchacha20poly1305_tag_push = m2.Wb)(), B2._crypto_secretstream_xchacha20poly1305_tag_rekey = () => (B2._crypto_secretstream_xchacha20poly1305_tag_rekey = m2.Xb)(), B2._crypto_secretstream_xchacha20poly1305_tag_final = () => (B2._crypto_secretstream_xchacha20poly1305_tag_final = m2.Yb)(), B2._crypto_shorthash_bytes = () => (B2._crypto_shorthash_bytes = m2.Zb)(), B2._crypto_shorthash_keybytes = () => (B2._crypto_shorthash_keybytes = m2._b)(), B2._crypto_shorthash = (A5, I5, g4, C2, Q3) => (B2._crypto_shorthash = m2.$b)(A5, I5, g4, C2, Q3), B2._crypto_shorthash_keygen = (A5) => (B2._crypto_shorthash_keygen = m2.ac)(A5), B2._crypto_sign_statebytes = () => (B2._crypto_sign_statebytes = m2.bc)(), B2._crypto_sign_bytes = () => (B2._crypto_sign_bytes = m2.cc)(), B2._crypto_sign_seedbytes = () => (B2._crypto_sign_seedbytes = m2.dc)(), B2._crypto_sign_publickeybytes = () => (B2._crypto_sign_publickeybytes = m2.ec)(), B2._crypto_sign_secretkeybytes = () => (B2._crypto_sign_secretkeybytes = m2.fc)(), B2._crypto_sign_messagebytes_max = () => (B2._crypto_sign_messagebytes_max = m2.gc)(), B2._crypto_sign_seed_keypair = (A5, I5, g4) => (B2._crypto_sign_seed_keypair = m2.hc)(A5, I5, g4), B2._crypto_sign_keypair = (A5, I5) => (B2._crypto_sign_keypair = m2.ic)(A5, I5), B2._crypto_sign = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_sign = m2.jc)(A5, I5, g4, C2, Q3, E3), B2._crypto_sign_open = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_sign_open = m2.kc)(A5, I5, g4, C2, Q3, E3), B2._crypto_sign_detached = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_sign_detached = m2.lc)(A5, I5, g4, C2, Q3, E3), B2._crypto_sign_verify_detached = (A5, I5, g4, C2, Q3) => (B2._crypto_sign_verify_detached = m2.mc)(A5, I5, g4, C2, Q3), B2._crypto_sign_init = (A5) => (B2._crypto_sign_init = m2.nc)(A5), B2._crypto_sign_update = (A5, I5, g4, C2) => (B2._crypto_sign_update = m2.oc)(A5, I5, g4, C2), B2._crypto_sign_final_create = (A5, I5, g4, C2) => (B2._crypto_sign_final_create = m2.pc)(A5, I5, g4, C2), B2._crypto_sign_final_verify = (A5, I5, g4) => (B2._crypto_sign_final_verify = m2.qc)(A5, I5, g4), B2._crypto_sign_ed25519_pk_to_curve25519 = (A5, I5) => (B2._crypto_sign_ed25519_pk_to_curve25519 = m2.rc)(A5, I5), B2._crypto_sign_ed25519_sk_to_curve25519 = (A5, I5) => (B2._crypto_sign_ed25519_sk_to_curve25519 = m2.sc)(A5, I5), B2._randombytes_random = () => (B2._randombytes_random = m2.tc)(), B2._randombytes_stir = () => (B2._randombytes_stir = m2.uc)(), B2._randombytes_uniform = (A5) => (B2._randombytes_uniform = m2.vc)(A5), B2._randombytes_buf = (A5, I5) => (B2._randombytes_buf = m2.wc)(A5, I5), B2._randombytes_buf_deterministic = (A5, I5, g4) => (B2._randombytes_buf_deterministic = m2.xc)(A5, I5, g4), B2._randombytes_seedbytes = () => (B2._randombytes_seedbytes = m2.yc)(), B2._randombytes_close = () => (B2._randombytes_close = m2.zc)(), B2._randombytes = (A5, I5, g4) => (B2._randombytes = m2.Ac)(A5, I5, g4), B2._sodium_bin2hex = (A5, I5, g4, C2) => (B2._sodium_bin2hex = m2.Bc)(A5, I5, g4, C2), B2._sodium_hex2bin = (A5, I5, g4, C2, Q3, E3, i3) => (B2._sodium_hex2bin = m2.Cc)(A5, I5, g4, C2, Q3, E3, i3), B2._sodium_base64_encoded_len = (A5, I5) => (B2._sodium_base64_encoded_len = m2.Dc)(A5, I5), B2._sodium_bin2base64 = (A5, I5, g4, C2, Q3) => (B2._sodium_bin2base64 = m2.Ec)(A5, I5, g4, C2, Q3), B2._sodium_base642bin = (A5, I5, g4, C2, Q3, E3, i3, o3) => (B2._sodium_base642bin = m2.Fc)(A5, I5, g4, C2, Q3, E3, i3, o3), B2._sodium_init = () => (B2._sodium_init = m2.Gc)(), B2._sodium_pad = (A5, I5, g4, C2, Q3) => (B2._sodium_pad = m2.Hc)(A5, I5, g4, C2, Q3), B2._sodium_unpad = (A5, I5, g4, C2) => (B2._sodium_unpad = m2.Ic)(A5, I5, g4, C2), B2._sodium_version_string = () => (B2._sodium_version_string = m2.Jc)(), B2._sodium_library_version_major = () => (B2._sodium_library_version_major = m2.Kc)(), B2._sodium_library_version_minor = () => (B2._sodium_library_version_minor = m2.Lc)(), B2._sodium_library_minimal = () => (B2._sodium_library_minimal = m2.Mc)(), B2._malloc = (A5) => (B2._malloc = m2.Nc)(A5), B2._free = (A5) => (B2._free = m2.Oc)(A5), B2.setValue = function(A5, I5, g4 = "i8") { + switch (g4.endsWith("*") && (g4 = "*"), g4) { + case "i1": + case "i8": + r2[A5] = I5; + break; + case "i16": + h2[A5 >> 1] = I5; + break; + case "i32": + k2[A5 >> 2] = I5; + break; + case "i64": + J2("to do setValue(i64) use WASM_BIGINT"); + case "float": + s2[A5 >> 2] = I5; + break; + case "double": + F2[A5 >> 3] = I5; + break; + case "*": + n2[A5 >> 2] = I5; + break; + default: + J2(`invalid type for setValue: ${g4}`); + } + }, B2.getValue = function(A5, I5 = "i8") { + switch (I5.endsWith("*") && (I5 = "*"), I5) { + case "i1": + case "i8": + return r2[A5]; + case "i16": + return h2[A5 >> 1]; + case "i32": + return k2[A5 >> 2]; + case "i64": + J2("to do getValue(i64) use WASM_BIGINT"); + case "float": + return s2[A5 >> 2]; + case "double": + return F2[A5 >> 3]; + case "*": + return n2[A5 >> 2]; + default: + J2(`invalid type for getValue: ${I5}`); + } + }, B2.UTF8ToString = R2, G2 = function A5() { + P2 || q2(), P2 || (G2 = A5); + }, B2.preInit) for ("function" == typeof B2.preInit && (B2.preInit = [B2.preInit]); B2.preInit.length > 0; ) B2.preInit.pop()(); + q2(); + }); + }; + var g2, B = void 0 !== B ? B : {}, Q = "object" == typeof window, E = "function" == typeof importScripts, i = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, o = Object.assign({}, B), c = ""; + if (i) { + var D = require("fs"), a = require("path"); + c = __dirname + "/", g2 = (A4) => (A4 = U(A4) ? new URL(A4) : a.normalize(A4), D.readFileSync(A4)), !B.thisProgram && process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2), "undefined" != typeof module2 && (module2.exports = B); + } else (Q || E) && (E ? c = self.location.href : "undefined" != typeof document && document.currentScript && (c = document.currentScript.src), c = c.startsWith("blob:") ? "" : c.substr(0, c.replace(/[?#].*/, "").lastIndexOf("/") + 1), E && (g2 = (A4) => { + var I4 = new XMLHttpRequest(); + return I4.open("GET", A4, false), I4.responseType = "arraybuffer", I4.send(null), new Uint8Array(I4.response); + })); + B.print; + var y, f, e = B.printErr || void 0; + Object.assign(B, o), o = null, B.arguments && B.arguments, B.thisProgram && B.thisProgram, B.quit && B.quit, B.wasmBinary && (y = B.wasmBinary); + var w, r, t, h, k, n, s, F = false; + function S() { + var A4 = f.buffer; + B.HEAP8 = w = new Int8Array(A4), B.HEAP16 = t = new Int16Array(A4), B.HEAPU8 = r = new Uint8Array(A4), B.HEAPU16 = new Uint16Array(A4), B.HEAP32 = h = new Int32Array(A4), B.HEAPU32 = k = new Uint32Array(A4), B.HEAPF32 = n = new Float32Array(A4), B.HEAPF64 = s = new Float64Array(A4); + } + var M = [], N = [], K = [], _ = 0, p = null, H = null; + function G(A4) { + throw B.onAbort?.(A4), e(A4 = "Aborted(" + A4 + ")"), F = true, A4 += ". Build with -sASSERTIONS for more info.", new WebAssembly.RuntimeError(A4); + } + var J, Y = "data:application/octet-stream;base64,", U = (A4) => A4.startsWith("file://"); + function d(A4) { + return Promise.resolve().then(() => function(A5) { + if (A5 == J && y) return new Uint8Array(y); + var I4 = function(A6) { + if (((A7) => A7.startsWith(Y))(A6)) return function(A7) { + if (void 0 !== i && i) { + var I5 = Buffer.from(A7, "base64"); + return new Uint8Array(I5.buffer, I5.byteOffset, I5.length); + } + for (var g3 = atob(A7), C2 = new Uint8Array(g3.length), B2 = 0; B2 < g3.length; ++B2) C2[B2] = g3.charCodeAt(B2); + return C2; + }(A6.slice(37)); + }(A5); + if (I4) return I4; + if (g2) return g2(A5); + throw "both async and sync fetching of the wasm failed"; + }(A4)); + } + var b = { 36304: () => B.getRandomValue(), 36340: () => { + if (void 0 === B.getRandomValue) try { + var A4 = "object" == typeof window ? window : self, I4 = void 0 !== A4.crypto ? A4.crypto : A4.msCrypto; + I4 = void 0 === I4 ? C2 : I4; + var g3 = function() { + var A5 = new Uint32Array(1); + return I4.getRandomValues(A5), A5[0] >>> 0; + }; + g3(), B.getRandomValue = g3; + } catch (A5) { + try { + var C2 = require("crypto"), Q2 = function() { + var A6 = C2.randomBytes(4); + return (A6[0] << 24 | A6[1] << 16 | A6[2] << 8 | A6[3]) >>> 0; + }; + Q2(), B.getRandomValue = Q2; + } catch (A6) { + throw "No secure random number generator found"; + } + } + } }, P = (A4) => { + for (; A4.length > 0; ) A4.shift()(B); + }; + B.noExitRuntime; + var v, R = "undefined" != typeof TextDecoder ? new TextDecoder() : void 0, L = (A4, I4) => A4 ? ((A5, I5, g3) => { + for (var C2 = I5 + g3, B2 = I5; A5[B2] && !(B2 >= C2); ) ++B2; + if (B2 - I5 > 16 && A5.buffer && R) return R.decode(A5.subarray(I5, B2)); + for (var Q2 = ""; I5 < B2; ) { + var E2 = A5[I5++]; + if (128 & E2) { + var i2 = 63 & A5[I5++]; + if (192 != (224 & E2)) { + var o2 = 63 & A5[I5++]; + if ((E2 = 224 == (240 & E2) ? (15 & E2) << 12 | i2 << 6 | o2 : (7 & E2) << 18 | i2 << 12 | o2 << 6 | 63 & A5[I5++]) < 65536) Q2 += String.fromCharCode(E2); + else { + var c2 = E2 - 65536; + Q2 += String.fromCharCode(55296 | c2 >> 10, 56320 | 1023 & c2); + } + } else Q2 += String.fromCharCode((31 & E2) << 6 | i2); + } else Q2 += String.fromCharCode(E2); + } + return Q2; + })(r, A4, I4) : "", x = [], u = (A4) => { + var I4 = (A4 - f.buffer.byteLength + 65535) / 65536; + try { + return f.grow(I4), S(), 1; + } catch (A5) { + } + }, m = { b: (A4, I4, g3, C2) => { + G(`Assertion failed: ${L(A4)}, at: ` + [I4 ? L(I4) : "unknown filename", g3, C2 ? L(C2) : "unknown function"]); + }, c: () => { + G(""); + }, d: (A4, I4, g3) => r.copyWithin(A4, I4, I4 + g3), a: (A4, I4, g3) => ((A5, I5, g4) => { + var C2 = ((A6, I6) => { + var g5; + for (x.length = 0; g5 = r[A6++]; ) { + var C3 = 105 != g5; + I6 += (C3 &= 112 != g5) && I6 % 8 ? 4 : 0, x.push(112 == g5 ? k[I6 >> 2] : 105 == g5 ? h[I6 >> 2] : s[I6 >> 3]), I6 += C3 ? 8 : 4; + } + return x; + })(I5, g4); + return b[A5](...C2); + })(A4, I4, g3), e: (A4) => { + var I4 = r.length, g3 = 2147483648; + if ((A4 >>>= 0) > g3) return false; + for (var C2, B2 = 1; B2 <= 4; B2 *= 2) { + var Q2 = I4 * (1 + 0.2 / B2); + Q2 = Math.min(Q2, A4 + 100663296); + var E2 = Math.min(g3, (C2 = Math.max(A4, Q2)) + (65536 - C2 % 65536) % 65536); + if (u(E2)) return true; + } + return false; + } }, q = function() { + var A4, I4 = { a: m }; + function g3(A5, I5) { + return q = A5.exports, f = q.f, S(), function(A6) { + if (_--, B.monitorRunDependencies?.(_), 0 == _ && (null !== p && (clearInterval(p), p = null), H)) { + var I6 = H; + H = null, I6(); + } + }(), q; + } + if (_++, B.monitorRunDependencies?.(_), B.instantiateWasm) try { + return B.instantiateWasm(I4, g3); + } catch (A5) { + return e(`Module.instantiateWasm callback failed with error: ${A5}`), false; + } + return J || (J = "data:application/octet-stream;base64,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"), A4 = I4, d(J).then((I5) => WebAssembly.instantiate(I5, A4)).then(function(A5) { + g3(A5.instance); + }, (A5) => { + e(`failed to asynchronously prepare wasm: ${A5}`), G(A5); + }), {}; + }(); + function l() { + function A4() { + v || (v = true, B.calledRun = true, F || (P(N), B.onRuntimeInitialized?.(), function() { + if (B.postRun) for ("function" == typeof B.postRun && (B.postRun = [B.postRun]); B.postRun.length; ) A5 = B.postRun.shift(), K.unshift(A5); + var A5; + P(K); + }())); + } + _ > 0 || (function() { + if (B.preRun) for ("function" == typeof B.preRun && (B.preRun = [B.preRun]); B.preRun.length; ) A5 = B.preRun.shift(), M.unshift(A5); + var A5; + P(M); + }(), _ > 0 || (B.setStatus ? (B.setStatus("Running..."), setTimeout(function() { + setTimeout(function() { + B.setStatus(""); + }, 1), A4(); + }, 1)) : A4())); + } + if (B._crypto_aead_aegis128l_keybytes = () => (B._crypto_aead_aegis128l_keybytes = q.g)(), B._crypto_aead_aegis128l_nsecbytes = () => (B._crypto_aead_aegis128l_nsecbytes = q.h)(), B._crypto_aead_aegis128l_npubbytes = () => (B._crypto_aead_aegis128l_npubbytes = q.i)(), B._crypto_aead_aegis128l_abytes = () => (B._crypto_aead_aegis128l_abytes = q.j)(), B._crypto_aead_aegis128l_messagebytes_max = () => (B._crypto_aead_aegis128l_messagebytes_max = q.k)(), B._crypto_aead_aegis128l_keygen = (A4) => (B._crypto_aead_aegis128l_keygen = q.l)(A4), B._crypto_aead_aegis128l_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis128l_encrypt = q.m)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis128l_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_aegis128l_encrypt_detached = q.n)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_aegis128l_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis128l_decrypt = q.o)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis128l_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis128l_decrypt_detached = q.p)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis256_keybytes = () => (B._crypto_aead_aegis256_keybytes = q.q)(), B._crypto_aead_aegis256_nsecbytes = () => (B._crypto_aead_aegis256_nsecbytes = q.r)(), B._crypto_aead_aegis256_npubbytes = () => (B._crypto_aead_aegis256_npubbytes = q.s)(), B._crypto_aead_aegis256_abytes = () => (B._crypto_aead_aegis256_abytes = q.t)(), B._crypto_aead_aegis256_messagebytes_max = () => (B._crypto_aead_aegis256_messagebytes_max = q.u)(), B._crypto_aead_aegis256_keygen = (A4) => (B._crypto_aead_aegis256_keygen = q.v)(A4), B._crypto_aead_aegis256_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis256_encrypt = q.w)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis256_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_aegis256_encrypt_detached = q.x)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_aegis256_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis256_decrypt = q.y)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis256_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis256_decrypt_detached = q.z)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aes256gcm_is_available = () => (B._crypto_aead_aes256gcm_is_available = q.A)(), B._crypto_aead_chacha20poly1305_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_chacha20poly1305_encrypt_detached = q.B)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_chacha20poly1305_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_encrypt = q.C)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_chacha20poly1305_ietf_encrypt_detached = q.D)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_chacha20poly1305_ietf_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_ietf_encrypt = q.E)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_decrypt_detached = q.F)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_decrypt = q.G)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_ietf_decrypt_detached = q.H)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_ietf_decrypt = q.I)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_keybytes = () => (B._crypto_aead_chacha20poly1305_ietf_keybytes = q.J)(), B._crypto_aead_chacha20poly1305_ietf_npubbytes = () => (B._crypto_aead_chacha20poly1305_ietf_npubbytes = q.K)(), B._crypto_aead_chacha20poly1305_ietf_nsecbytes = () => (B._crypto_aead_chacha20poly1305_ietf_nsecbytes = q.L)(), B._crypto_aead_chacha20poly1305_ietf_abytes = () => (B._crypto_aead_chacha20poly1305_ietf_abytes = q.M)(), B._crypto_aead_chacha20poly1305_ietf_messagebytes_max = () => (B._crypto_aead_chacha20poly1305_ietf_messagebytes_max = q.N)(), B._crypto_aead_chacha20poly1305_ietf_keygen = (A4) => (B._crypto_aead_chacha20poly1305_ietf_keygen = q.O)(A4), B._crypto_aead_chacha20poly1305_keybytes = () => (B._crypto_aead_chacha20poly1305_keybytes = q.P)(), B._crypto_aead_chacha20poly1305_npubbytes = () => (B._crypto_aead_chacha20poly1305_npubbytes = q.Q)(), B._crypto_aead_chacha20poly1305_nsecbytes = () => (B._crypto_aead_chacha20poly1305_nsecbytes = q.R)(), B._crypto_aead_chacha20poly1305_abytes = () => (B._crypto_aead_chacha20poly1305_abytes = q.S)(), B._crypto_aead_chacha20poly1305_messagebytes_max = () => (B._crypto_aead_chacha20poly1305_messagebytes_max = q.T)(), B._crypto_aead_chacha20poly1305_keygen = (A4) => (B._crypto_aead_chacha20poly1305_keygen = q.U)(A4), B._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = q.V)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_xchacha20poly1305_ietf_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_xchacha20poly1305_ietf_encrypt = q.W)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = q.X)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_xchacha20poly1305_ietf_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_xchacha20poly1305_ietf_decrypt = q.Y)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_xchacha20poly1305_ietf_keybytes = () => (B._crypto_aead_xchacha20poly1305_ietf_keybytes = q.Z)(), B._crypto_aead_xchacha20poly1305_ietf_npubbytes = () => (B._crypto_aead_xchacha20poly1305_ietf_npubbytes = q._)(), B._crypto_aead_xchacha20poly1305_ietf_nsecbytes = () => (B._crypto_aead_xchacha20poly1305_ietf_nsecbytes = q.$)(), B._crypto_aead_xchacha20poly1305_ietf_abytes = () => (B._crypto_aead_xchacha20poly1305_ietf_abytes = q.aa)(), B._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = () => (B._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = q.ba)(), B._crypto_aead_xchacha20poly1305_ietf_keygen = (A4) => (B._crypto_aead_xchacha20poly1305_ietf_keygen = q.ca)(A4), B._crypto_auth_bytes = () => (B._crypto_auth_bytes = q.da)(), B._crypto_auth_keybytes = () => (B._crypto_auth_keybytes = q.ea)(), B._crypto_auth = (A4, I4, g3, C2, Q2) => (B._crypto_auth = q.fa)(A4, I4, g3, C2, Q2), B._crypto_auth_verify = (A4, I4, g3, C2, Q2) => (B._crypto_auth_verify = q.ga)(A4, I4, g3, C2, Q2), B._crypto_auth_keygen = (A4) => (B._crypto_auth_keygen = q.ha)(A4), B._crypto_box_seedbytes = () => (B._crypto_box_seedbytes = q.ia)(), B._crypto_box_publickeybytes = () => (B._crypto_box_publickeybytes = q.ja)(), B._crypto_box_secretkeybytes = () => (B._crypto_box_secretkeybytes = q.ka)(), B._crypto_box_beforenmbytes = () => (B._crypto_box_beforenmbytes = q.la)(), B._crypto_box_noncebytes = () => (B._crypto_box_noncebytes = q.ma)(), B._crypto_box_macbytes = () => (B._crypto_box_macbytes = q.na)(), B._crypto_box_messagebytes_max = () => (B._crypto_box_messagebytes_max = q.oa)(), B._crypto_box_seed_keypair = (A4, I4, g3) => (B._crypto_box_seed_keypair = q.pa)(A4, I4, g3), B._crypto_box_keypair = (A4, I4) => (B._crypto_box_keypair = q.qa)(A4, I4), B._crypto_box_beforenm = (A4, I4, g3) => (B._crypto_box_beforenm = q.ra)(A4, I4, g3), B._crypto_box_detached_afternm = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_detached_afternm = q.sa)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_detached = (A4, I4, g3, C2, Q2, E2, i2, o2) => (B._crypto_box_detached = q.ta)(A4, I4, g3, C2, Q2, E2, i2, o2), B._crypto_box_easy_afternm = (A4, I4, g3, C2, Q2, E2) => (B._crypto_box_easy_afternm = q.ua)(A4, I4, g3, C2, Q2, E2), B._crypto_box_easy = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_easy = q.va)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_open_detached_afternm = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_open_detached_afternm = q.wa)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_open_detached = (A4, I4, g3, C2, Q2, E2, i2, o2) => (B._crypto_box_open_detached = q.xa)(A4, I4, g3, C2, Q2, E2, i2, o2), B._crypto_box_open_easy_afternm = (A4, I4, g3, C2, Q2, E2) => (B._crypto_box_open_easy_afternm = q.ya)(A4, I4, g3, C2, Q2, E2), B._crypto_box_open_easy = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_open_easy = q.za)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_seal = (A4, I4, g3, C2, Q2) => (B._crypto_box_seal = q.Aa)(A4, I4, g3, C2, Q2), B._crypto_box_seal_open = (A4, I4, g3, C2, Q2, E2) => (B._crypto_box_seal_open = q.Ba)(A4, I4, g3, C2, Q2, E2), B._crypto_box_sealbytes = () => (B._crypto_box_sealbytes = q.Ca)(), B._crypto_generichash_bytes_min = () => (B._crypto_generichash_bytes_min = q.Da)(), B._crypto_generichash_bytes_max = () => (B._crypto_generichash_bytes_max = q.Ea)(), B._crypto_generichash_bytes = () => (B._crypto_generichash_bytes = q.Fa)(), B._crypto_generichash_keybytes_min = () => (B._crypto_generichash_keybytes_min = q.Ga)(), B._crypto_generichash_keybytes_max = () => (B._crypto_generichash_keybytes_max = q.Ha)(), B._crypto_generichash_keybytes = () => (B._crypto_generichash_keybytes = q.Ia)(), B._crypto_generichash_statebytes = () => (B._crypto_generichash_statebytes = q.Ja)(), B._crypto_generichash = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_generichash = q.Ka)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_generichash_init = (A4, I4, g3, C2) => (B._crypto_generichash_init = q.La)(A4, I4, g3, C2), B._crypto_generichash_update = (A4, I4, g3, C2) => (B._crypto_generichash_update = q.Ma)(A4, I4, g3, C2), B._crypto_generichash_final = (A4, I4, g3) => (B._crypto_generichash_final = q.Na)(A4, I4, g3), B._crypto_generichash_keygen = (A4) => (B._crypto_generichash_keygen = q.Oa)(A4), B._crypto_hash_bytes = () => (B._crypto_hash_bytes = q.Pa)(), B._crypto_hash = (A4, I4, g3, C2) => (B._crypto_hash = q.Qa)(A4, I4, g3, C2), B._crypto_kdf_bytes_min = () => (B._crypto_kdf_bytes_min = q.Ra)(), B._crypto_kdf_bytes_max = () => (B._crypto_kdf_bytes_max = q.Sa)(), B._crypto_kdf_contextbytes = () => (B._crypto_kdf_contextbytes = q.Ta)(), B._crypto_kdf_keybytes = () => (B._crypto_kdf_keybytes = q.Ua)(), B._crypto_kdf_derive_from_key = (A4, I4, g3, C2, Q2, E2) => (B._crypto_kdf_derive_from_key = q.Va)(A4, I4, g3, C2, Q2, E2), B._crypto_kdf_keygen = (A4) => (B._crypto_kdf_keygen = q.Wa)(A4), B._crypto_kdf_hkdf_sha256_extract_init = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha256_extract_init = q.Xa)(A4, I4, g3), B._crypto_kdf_hkdf_sha256_extract_update = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha256_extract_update = q.Ya)(A4, I4, g3), B._crypto_kdf_hkdf_sha256_extract_final = (A4, I4) => (B._crypto_kdf_hkdf_sha256_extract_final = q.Za)(A4, I4), B._crypto_kdf_hkdf_sha256_extract = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha256_extract = q._a)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha256_keygen = (A4) => (B._crypto_kdf_hkdf_sha256_keygen = q.$a)(A4), B._crypto_kdf_hkdf_sha256_expand = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha256_expand = q.ab)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha256_keybytes = () => (B._crypto_kdf_hkdf_sha256_keybytes = q.bb)(), B._crypto_kdf_hkdf_sha256_bytes_min = () => (B._crypto_kdf_hkdf_sha256_bytes_min = q.cb)(), B._crypto_kdf_hkdf_sha256_bytes_max = () => (B._crypto_kdf_hkdf_sha256_bytes_max = q.db)(), B._crypto_kdf_hkdf_sha256_statebytes = () => (B._crypto_kdf_hkdf_sha256_statebytes = q.eb)(), B._crypto_kdf_hkdf_sha512_extract_init = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha512_extract_init = q.fb)(A4, I4, g3), B._crypto_kdf_hkdf_sha512_extract_update = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha512_extract_update = q.gb)(A4, I4, g3), B._crypto_kdf_hkdf_sha512_extract_final = (A4, I4) => (B._crypto_kdf_hkdf_sha512_extract_final = q.hb)(A4, I4), B._crypto_kdf_hkdf_sha512_extract = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha512_extract = q.ib)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha512_keygen = (A4) => (B._crypto_kdf_hkdf_sha512_keygen = q.jb)(A4), B._crypto_kdf_hkdf_sha512_expand = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha512_expand = q.kb)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha512_keybytes = () => (B._crypto_kdf_hkdf_sha512_keybytes = q.lb)(), B._crypto_kdf_hkdf_sha512_bytes_min = () => (B._crypto_kdf_hkdf_sha512_bytes_min = q.mb)(), B._crypto_kdf_hkdf_sha512_bytes_max = () => (B._crypto_kdf_hkdf_sha512_bytes_max = q.nb)(), B._crypto_kdf_hkdf_sha512_statebytes = () => (B._crypto_kdf_hkdf_sha512_statebytes = q.ob)(), B._crypto_kx_seed_keypair = (A4, I4, g3) => (B._crypto_kx_seed_keypair = q.pb)(A4, I4, g3), B._crypto_kx_keypair = (A4, I4) => (B._crypto_kx_keypair = q.qb)(A4, I4), B._crypto_kx_client_session_keys = (A4, I4, g3, C2, Q2) => (B._crypto_kx_client_session_keys = q.rb)(A4, I4, g3, C2, Q2), B._crypto_kx_server_session_keys = (A4, I4, g3, C2, Q2) => (B._crypto_kx_server_session_keys = q.sb)(A4, I4, g3, C2, Q2), B._crypto_kx_publickeybytes = () => (B._crypto_kx_publickeybytes = q.tb)(), B._crypto_kx_secretkeybytes = () => (B._crypto_kx_secretkeybytes = q.ub)(), B._crypto_kx_seedbytes = () => (B._crypto_kx_seedbytes = q.vb)(), B._crypto_kx_sessionkeybytes = () => (B._crypto_kx_sessionkeybytes = q.wb)(), B._crypto_scalarmult_base = (A4, I4) => (B._crypto_scalarmult_base = q.xb)(A4, I4), B._crypto_scalarmult = (A4, I4, g3) => (B._crypto_scalarmult = q.yb)(A4, I4, g3), B._crypto_scalarmult_bytes = () => (B._crypto_scalarmult_bytes = q.zb)(), B._crypto_scalarmult_scalarbytes = () => (B._crypto_scalarmult_scalarbytes = q.Ab)(), B._crypto_secretbox_keybytes = () => (B._crypto_secretbox_keybytes = q.Bb)(), B._crypto_secretbox_noncebytes = () => (B._crypto_secretbox_noncebytes = q.Cb)(), B._crypto_secretbox_macbytes = () => (B._crypto_secretbox_macbytes = q.Db)(), B._crypto_secretbox_messagebytes_max = () => (B._crypto_secretbox_messagebytes_max = q.Eb)(), B._crypto_secretbox_keygen = (A4) => (B._crypto_secretbox_keygen = q.Fb)(A4), B._crypto_secretbox_detached = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_secretbox_detached = q.Gb)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_secretbox_easy = (A4, I4, g3, C2, Q2, E2) => (B._crypto_secretbox_easy = q.Hb)(A4, I4, g3, C2, Q2, E2), B._crypto_secretbox_open_detached = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_secretbox_open_detached = q.Ib)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_secretbox_open_easy = (A4, I4, g3, C2, Q2, E2) => (B._crypto_secretbox_open_easy = q.Jb)(A4, I4, g3, C2, Q2, E2), B._crypto_secretstream_xchacha20poly1305_keygen = (A4) => (B._crypto_secretstream_xchacha20poly1305_keygen = q.Kb)(A4), B._crypto_secretstream_xchacha20poly1305_init_push = (A4, I4, g3) => (B._crypto_secretstream_xchacha20poly1305_init_push = q.Lb)(A4, I4, g3), B._crypto_secretstream_xchacha20poly1305_init_pull = (A4, I4, g3) => (B._crypto_secretstream_xchacha20poly1305_init_pull = q.Mb)(A4, I4, g3), B._crypto_secretstream_xchacha20poly1305_rekey = (A4) => (B._crypto_secretstream_xchacha20poly1305_rekey = q.Nb)(A4), B._crypto_secretstream_xchacha20poly1305_push = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2) => (B._crypto_secretstream_xchacha20poly1305_push = q.Ob)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2), B._crypto_secretstream_xchacha20poly1305_pull = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2) => (B._crypto_secretstream_xchacha20poly1305_pull = q.Pb)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2), B._crypto_secretstream_xchacha20poly1305_statebytes = () => (B._crypto_secretstream_xchacha20poly1305_statebytes = q.Qb)(), B._crypto_secretstream_xchacha20poly1305_abytes = () => (B._crypto_secretstream_xchacha20poly1305_abytes = q.Rb)(), B._crypto_secretstream_xchacha20poly1305_headerbytes = () => (B._crypto_secretstream_xchacha20poly1305_headerbytes = q.Sb)(), B._crypto_secretstream_xchacha20poly1305_keybytes = () => (B._crypto_secretstream_xchacha20poly1305_keybytes = q.Tb)(), B._crypto_secretstream_xchacha20poly1305_messagebytes_max = () => (B._crypto_secretstream_xchacha20poly1305_messagebytes_max = q.Ub)(), B._crypto_secretstream_xchacha20poly1305_tag_message = () => (B._crypto_secretstream_xchacha20poly1305_tag_message = q.Vb)(), B._crypto_secretstream_xchacha20poly1305_tag_push = () => (B._crypto_secretstream_xchacha20poly1305_tag_push = q.Wb)(), B._crypto_secretstream_xchacha20poly1305_tag_rekey = () => (B._crypto_secretstream_xchacha20poly1305_tag_rekey = q.Xb)(), B._crypto_secretstream_xchacha20poly1305_tag_final = () => (B._crypto_secretstream_xchacha20poly1305_tag_final = q.Yb)(), B._crypto_shorthash_bytes = () => (B._crypto_shorthash_bytes = q.Zb)(), B._crypto_shorthash_keybytes = () => (B._crypto_shorthash_keybytes = q._b)(), B._crypto_shorthash = (A4, I4, g3, C2, Q2) => (B._crypto_shorthash = q.$b)(A4, I4, g3, C2, Q2), B._crypto_shorthash_keygen = (A4) => (B._crypto_shorthash_keygen = q.ac)(A4), B._crypto_sign_statebytes = () => (B._crypto_sign_statebytes = q.bc)(), B._crypto_sign_bytes = () => (B._crypto_sign_bytes = q.cc)(), B._crypto_sign_seedbytes = () => (B._crypto_sign_seedbytes = q.dc)(), B._crypto_sign_publickeybytes = () => (B._crypto_sign_publickeybytes = q.ec)(), B._crypto_sign_secretkeybytes = () => (B._crypto_sign_secretkeybytes = q.fc)(), B._crypto_sign_messagebytes_max = () => (B._crypto_sign_messagebytes_max = q.gc)(), B._crypto_sign_seed_keypair = (A4, I4, g3) => (B._crypto_sign_seed_keypair = q.hc)(A4, I4, g3), B._crypto_sign_keypair = (A4, I4) => (B._crypto_sign_keypair = q.ic)(A4, I4), B._crypto_sign = (A4, I4, g3, C2, Q2, E2) => (B._crypto_sign = q.jc)(A4, I4, g3, C2, Q2, E2), B._crypto_sign_open = (A4, I4, g3, C2, Q2, E2) => (B._crypto_sign_open = q.kc)(A4, I4, g3, C2, Q2, E2), B._crypto_sign_detached = (A4, I4, g3, C2, Q2, E2) => (B._crypto_sign_detached = q.lc)(A4, I4, g3, C2, Q2, E2), B._crypto_sign_verify_detached = (A4, I4, g3, C2, Q2) => (B._crypto_sign_verify_detached = q.mc)(A4, I4, g3, C2, Q2), B._crypto_sign_init = (A4) => (B._crypto_sign_init = q.nc)(A4), B._crypto_sign_update = (A4, I4, g3, C2) => (B._crypto_sign_update = q.oc)(A4, I4, g3, C2), B._crypto_sign_final_create = (A4, I4, g3, C2) => (B._crypto_sign_final_create = q.pc)(A4, I4, g3, C2), B._crypto_sign_final_verify = (A4, I4, g3) => (B._crypto_sign_final_verify = q.qc)(A4, I4, g3), B._crypto_sign_ed25519_pk_to_curve25519 = (A4, I4) => (B._crypto_sign_ed25519_pk_to_curve25519 = q.rc)(A4, I4), B._crypto_sign_ed25519_sk_to_curve25519 = (A4, I4) => (B._crypto_sign_ed25519_sk_to_curve25519 = q.sc)(A4, I4), B._randombytes_random = () => (B._randombytes_random = q.tc)(), B._randombytes_stir = () => (B._randombytes_stir = q.uc)(), B._randombytes_uniform = (A4) => (B._randombytes_uniform = q.vc)(A4), B._randombytes_buf = (A4, I4) => (B._randombytes_buf = q.wc)(A4, I4), B._randombytes_buf_deterministic = (A4, I4, g3) => (B._randombytes_buf_deterministic = q.xc)(A4, I4, g3), B._randombytes_seedbytes = () => (B._randombytes_seedbytes = q.yc)(), B._randombytes_close = () => (B._randombytes_close = q.zc)(), B._randombytes = (A4, I4, g3) => (B._randombytes = q.Ac)(A4, I4, g3), B._sodium_bin2hex = (A4, I4, g3, C2) => (B._sodium_bin2hex = q.Bc)(A4, I4, g3, C2), B._sodium_hex2bin = (A4, I4, g3, C2, Q2, E2, i2) => (B._sodium_hex2bin = q.Cc)(A4, I4, g3, C2, Q2, E2, i2), B._sodium_base64_encoded_len = (A4, I4) => (B._sodium_base64_encoded_len = q.Dc)(A4, I4), B._sodium_bin2base64 = (A4, I4, g3, C2, Q2) => (B._sodium_bin2base64 = q.Ec)(A4, I4, g3, C2, Q2), B._sodium_base642bin = (A4, I4, g3, C2, Q2, E2, i2, o2) => (B._sodium_base642bin = q.Fc)(A4, I4, g3, C2, Q2, E2, i2, o2), B._sodium_init = () => (B._sodium_init = q.Gc)(), B._sodium_pad = (A4, I4, g3, C2, Q2) => (B._sodium_pad = q.Hc)(A4, I4, g3, C2, Q2), B._sodium_unpad = (A4, I4, g3, C2) => (B._sodium_unpad = q.Ic)(A4, I4, g3, C2), B._sodium_version_string = () => (B._sodium_version_string = q.Jc)(), B._sodium_library_version_major = () => (B._sodium_library_version_major = q.Kc)(), B._sodium_library_version_minor = () => (B._sodium_library_version_minor = q.Lc)(), B._sodium_library_minimal = () => (B._sodium_library_minimal = q.Mc)(), B._malloc = (A4) => (B._malloc = q.Nc)(A4), B._free = (A4) => (B._free = q.Oc)(A4), B.setValue = function(A4, I4, g3 = "i8") { + switch (g3.endsWith("*") && (g3 = "*"), g3) { + case "i1": + case "i8": + w[A4] = I4; + break; + case "i16": + t[A4 >> 1] = I4; + break; + case "i32": + h[A4 >> 2] = I4; + break; + case "i64": + G("to do setValue(i64) use WASM_BIGINT"); + case "float": + n[A4 >> 2] = I4; + break; + case "double": + s[A4 >> 3] = I4; + break; + case "*": + k[A4 >> 2] = I4; + break; + default: + G(`invalid type for setValue: ${g3}`); + } + }, B.getValue = function(A4, I4 = "i8") { + switch (I4.endsWith("*") && (I4 = "*"), I4) { + case "i1": + case "i8": + return w[A4]; + case "i16": + return t[A4 >> 1]; + case "i32": + return h[A4 >> 2]; + case "i64": + G("to do getValue(i64) use WASM_BIGINT"); + case "float": + return n[A4 >> 2]; + case "double": + return s[A4 >> 3]; + case "*": + return k[A4 >> 2]; + default: + G(`invalid type for getValue: ${I4}`); + } + }, B.UTF8ToString = L, H = function A4() { + v || l(), v || (H = A4); + }, B.preInit) for ("function" == typeof B.preInit && (B.preInit = [B.preInit]); B.preInit.length > 0; ) B.preInit.pop()(); + l(); + }).catch(function() { + return C.useBackupModule(); + }), I2; + } + "function" == typeof define && define.amd ? define(["exports"], I) : "object" == typeof exports2 && "string" != typeof exports2.nodeName ? I(exports2) : A.libsodium = I(A.libsodium_mod || (A.commonJsStrict = {})); + }(exports2); + } +}); + +// node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js +var require_libsodium_wrappers = __commonJS({ + "node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js"(exports2) { + !function(e) { + function a(e2, a2) { + "use strict"; + var r2, t = "uint8array", _ = a2.ready.then(function() { + function t2() { + if (0 !== r2._sodium_init()) throw new Error("libsodium was not correctly initialized."); + for (var a3 = ["crypto_aead_aegis128l_decrypt", "crypto_aead_aegis128l_decrypt_detached", "crypto_aead_aegis128l_encrypt", "crypto_aead_aegis128l_encrypt_detached", "crypto_aead_aegis128l_keygen", "crypto_aead_aegis256_decrypt", "crypto_aead_aegis256_decrypt_detached", "crypto_aead_aegis256_encrypt", "crypto_aead_aegis256_encrypt_detached", "crypto_aead_aegis256_keygen", "crypto_aead_chacha20poly1305_decrypt", "crypto_aead_chacha20poly1305_decrypt_detached", "crypto_aead_chacha20poly1305_encrypt", "crypto_aead_chacha20poly1305_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_decrypt", "crypto_aead_chacha20poly1305_ietf_decrypt_detached", "crypto_aead_chacha20poly1305_ietf_encrypt", "crypto_aead_chacha20poly1305_ietf_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_keygen", "crypto_aead_chacha20poly1305_keygen", "crypto_aead_xchacha20poly1305_ietf_decrypt", "crypto_aead_xchacha20poly1305_ietf_decrypt_detached", "crypto_aead_xchacha20poly1305_ietf_encrypt", "crypto_aead_xchacha20poly1305_ietf_encrypt_detached", "crypto_aead_xchacha20poly1305_ietf_keygen", "crypto_auth", "crypto_auth_hmacsha256", "crypto_auth_hmacsha256_final", "crypto_auth_hmacsha256_init", "crypto_auth_hmacsha256_keygen", "crypto_auth_hmacsha256_update", "crypto_auth_hmacsha256_verify", "crypto_auth_hmacsha512", "crypto_auth_hmacsha512256", "crypto_auth_hmacsha512256_final", "crypto_auth_hmacsha512256_init", "crypto_auth_hmacsha512256_keygen", "crypto_auth_hmacsha512256_update", "crypto_auth_hmacsha512256_verify", "crypto_auth_hmacsha512_final", "crypto_auth_hmacsha512_init", "crypto_auth_hmacsha512_keygen", "crypto_auth_hmacsha512_update", "crypto_auth_hmacsha512_verify", "crypto_auth_keygen", "crypto_auth_verify", "crypto_box_beforenm", "crypto_box_curve25519xchacha20poly1305_beforenm", "crypto_box_curve25519xchacha20poly1305_detached", "crypto_box_curve25519xchacha20poly1305_detached_afternm", "crypto_box_curve25519xchacha20poly1305_easy", "crypto_box_curve25519xchacha20poly1305_easy_afternm", "crypto_box_curve25519xchacha20poly1305_keypair", "crypto_box_curve25519xchacha20poly1305_open_detached", "crypto_box_curve25519xchacha20poly1305_open_detached_afternm", "crypto_box_curve25519xchacha20poly1305_open_easy", "crypto_box_curve25519xchacha20poly1305_open_easy_afternm", "crypto_box_curve25519xchacha20poly1305_seal", "crypto_box_curve25519xchacha20poly1305_seal_open", "crypto_box_curve25519xchacha20poly1305_seed_keypair", "crypto_box_detached", "crypto_box_easy", "crypto_box_easy_afternm", "crypto_box_keypair", "crypto_box_open_detached", "crypto_box_open_easy", "crypto_box_open_easy_afternm", "crypto_box_seal", "crypto_box_seal_open", "crypto_box_seed_keypair", "crypto_core_ed25519_add", "crypto_core_ed25519_from_hash", "crypto_core_ed25519_from_uniform", "crypto_core_ed25519_is_valid_point", "crypto_core_ed25519_random", "crypto_core_ed25519_scalar_add", "crypto_core_ed25519_scalar_complement", "crypto_core_ed25519_scalar_invert", "crypto_core_ed25519_scalar_mul", "crypto_core_ed25519_scalar_negate", "crypto_core_ed25519_scalar_random", "crypto_core_ed25519_scalar_reduce", "crypto_core_ed25519_scalar_sub", "crypto_core_ed25519_sub", "crypto_core_hchacha20", "crypto_core_hsalsa20", "crypto_core_ristretto255_add", "crypto_core_ristretto255_from_hash", "crypto_core_ristretto255_is_valid_point", "crypto_core_ristretto255_random", "crypto_core_ristretto255_scalar_add", "crypto_core_ristretto255_scalar_complement", "crypto_core_ristretto255_scalar_invert", "crypto_core_ristretto255_scalar_mul", "crypto_core_ristretto255_scalar_negate", "crypto_core_ristretto255_scalar_random", "crypto_core_ristretto255_scalar_reduce", "crypto_core_ristretto255_scalar_sub", "crypto_core_ristretto255_sub", "crypto_generichash", "crypto_generichash_blake2b_salt_personal", "crypto_generichash_final", "crypto_generichash_init", "crypto_generichash_keygen", "crypto_generichash_update", "crypto_hash", "crypto_hash_sha256", "crypto_hash_sha256_final", "crypto_hash_sha256_init", "crypto_hash_sha256_update", "crypto_hash_sha512", "crypto_hash_sha512_final", "crypto_hash_sha512_init", "crypto_hash_sha512_update", "crypto_kdf_derive_from_key", "crypto_kdf_keygen", "crypto_kx_client_session_keys", "crypto_kx_keypair", "crypto_kx_seed_keypair", "crypto_kx_server_session_keys", "crypto_onetimeauth", "crypto_onetimeauth_final", "crypto_onetimeauth_init", "crypto_onetimeauth_keygen", "crypto_onetimeauth_update", "crypto_onetimeauth_verify", "crypto_pwhash", "crypto_pwhash_scryptsalsa208sha256", "crypto_pwhash_scryptsalsa208sha256_ll", "crypto_pwhash_scryptsalsa208sha256_str", "crypto_pwhash_scryptsalsa208sha256_str_verify", "crypto_pwhash_str", "crypto_pwhash_str_needs_rehash", "crypto_pwhash_str_verify", "crypto_scalarmult", "crypto_scalarmult_base", "crypto_scalarmult_ed25519", "crypto_scalarmult_ed25519_base", "crypto_scalarmult_ed25519_base_noclamp", "crypto_scalarmult_ed25519_noclamp", "crypto_scalarmult_ristretto255", "crypto_scalarmult_ristretto255_base", "crypto_secretbox_detached", "crypto_secretbox_easy", "crypto_secretbox_keygen", "crypto_secretbox_open_detached", "crypto_secretbox_open_easy", "crypto_secretstream_xchacha20poly1305_init_pull", "crypto_secretstream_xchacha20poly1305_init_push", "crypto_secretstream_xchacha20poly1305_keygen", "crypto_secretstream_xchacha20poly1305_pull", "crypto_secretstream_xchacha20poly1305_push", "crypto_secretstream_xchacha20poly1305_rekey", "crypto_shorthash", "crypto_shorthash_keygen", "crypto_shorthash_siphashx24", "crypto_sign", "crypto_sign_detached", "crypto_sign_ed25519_pk_to_curve25519", "crypto_sign_ed25519_sk_to_curve25519", "crypto_sign_ed25519_sk_to_pk", "crypto_sign_ed25519_sk_to_seed", "crypto_sign_final_create", "crypto_sign_final_verify", "crypto_sign_init", "crypto_sign_keypair", "crypto_sign_open", "crypto_sign_seed_keypair", "crypto_sign_update", "crypto_sign_verify_detached", "crypto_stream_chacha20", "crypto_stream_chacha20_ietf_xor", "crypto_stream_chacha20_ietf_xor_ic", "crypto_stream_chacha20_keygen", "crypto_stream_chacha20_xor", "crypto_stream_chacha20_xor_ic", "crypto_stream_keygen", "crypto_stream_xchacha20_keygen", "crypto_stream_xchacha20_xor", "crypto_stream_xchacha20_xor_ic", "randombytes_buf", "randombytes_buf_deterministic", "randombytes_close", "randombytes_random", "randombytes_set_implementation", "randombytes_stir", "randombytes_uniform", "sodium_version_string"], t3 = [x, k, S, T, w, Y, B, A, M, I, K, N, L, O, U, C, P, R, X, G, D, F, V, H, W, q, j, z, J, Q, Z, $, ee, ae, re, te, _e, ne, se, ce, he, oe, pe, ye, ie, le, ue, de, ve, ge, be, fe, me, Ee, xe, ke, Se, Te, we, Ye, Be, Ae, Me, Ie, Ke, Ne, Le, Oe, Ue, Ce, Pe, Re, Xe, Ge, De, Fe, Ve, He, We, qe, je, ze, Je, Qe, Ze, $e, ea, aa, ra, ta, _a2, na, sa, ca, ha, oa, pa, ya, ia, la, ua, da, va, ga, ba, fa, ma, Ea, xa, ka, Sa, Ta, wa, Ya, Ba, Aa, Ma, Ia, Ka, Na, La, Oa, Ua, Ca, Pa, Ra, Xa, Ga, Da, Fa, Va, Ha, Wa, qa, ja, za, Ja, Qa, Za, $a, er, ar, rr, tr, _r, nr, sr, cr, hr, or, pr, yr, ir, lr, ur, dr, vr, gr, br, fr, mr, Er, xr, kr, Sr, Tr, wr, Yr, Br, Ar, Mr, Ir, Kr, Nr, Lr, Or, Ur, Cr, Pr, Rr, Xr, Gr, Dr, Fr, Vr, Hr, Wr, qr], _3 = 0; _3 < t3.length; _3++) "function" == typeof r2["_" + a3[_3]] && (e2[a3[_3]] = t3[_3]); + var n3 = ["SODIUM_LIBRARY_VERSION_MAJOR", "SODIUM_LIBRARY_VERSION_MINOR", "crypto_aead_aegis128l_ABYTES", "crypto_aead_aegis128l_KEYBYTES", "crypto_aead_aegis128l_MESSAGEBYTES_MAX", "crypto_aead_aegis128l_NPUBBYTES", "crypto_aead_aegis128l_NSECBYTES", "crypto_aead_aegis256_ABYTES", "crypto_aead_aegis256_KEYBYTES", "crypto_aead_aegis256_MESSAGEBYTES_MAX", "crypto_aead_aegis256_NPUBBYTES", "crypto_aead_aegis256_NSECBYTES", "crypto_aead_aes256gcm_ABYTES", "crypto_aead_aes256gcm_KEYBYTES", "crypto_aead_aes256gcm_MESSAGEBYTES_MAX", "crypto_aead_aes256gcm_NPUBBYTES", "crypto_aead_aes256gcm_NSECBYTES", "crypto_aead_chacha20poly1305_ABYTES", "crypto_aead_chacha20poly1305_IETF_ABYTES", "crypto_aead_chacha20poly1305_IETF_KEYBYTES", "crypto_aead_chacha20poly1305_IETF_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_IETF_NPUBBYTES", "crypto_aead_chacha20poly1305_IETF_NSECBYTES", "crypto_aead_chacha20poly1305_KEYBYTES", "crypto_aead_chacha20poly1305_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_NPUBBYTES", "crypto_aead_chacha20poly1305_NSECBYTES", "crypto_aead_chacha20poly1305_ietf_ABYTES", "crypto_aead_chacha20poly1305_ietf_KEYBYTES", "crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_ietf_NPUBBYTES", "crypto_aead_chacha20poly1305_ietf_NSECBYTES", "crypto_aead_xchacha20poly1305_IETF_ABYTES", "crypto_aead_xchacha20poly1305_IETF_KEYBYTES", "crypto_aead_xchacha20poly1305_IETF_MESSAGEBYTES_MAX", "crypto_aead_xchacha20poly1305_IETF_NPUBBYTES", "crypto_aead_xchacha20poly1305_IETF_NSECBYTES", "crypto_aead_xchacha20poly1305_ietf_ABYTES", "crypto_aead_xchacha20poly1305_ietf_KEYBYTES", "crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_xchacha20poly1305_ietf_NPUBBYTES", "crypto_aead_xchacha20poly1305_ietf_NSECBYTES", "crypto_auth_BYTES", "crypto_auth_KEYBYTES", "crypto_auth_hmacsha256_BYTES", "crypto_auth_hmacsha256_KEYBYTES", "crypto_auth_hmacsha512256_BYTES", "crypto_auth_hmacsha512256_KEYBYTES", "crypto_auth_hmacsha512_BYTES", "crypto_auth_hmacsha512_KEYBYTES", "crypto_box_BEFORENMBYTES", "crypto_box_MACBYTES", "crypto_box_MESSAGEBYTES_MAX", "crypto_box_NONCEBYTES", "crypto_box_PUBLICKEYBYTES", "crypto_box_SEALBYTES", "crypto_box_SECRETKEYBYTES", "crypto_box_SEEDBYTES", "crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES", "crypto_box_curve25519xchacha20poly1305_MACBYTES", "crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_box_curve25519xchacha20poly1305_NONCEBYTES", "crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES", "crypto_box_curve25519xchacha20poly1305_SEALBYTES", "crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES", "crypto_box_curve25519xchacha20poly1305_SEEDBYTES", "crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES", "crypto_box_curve25519xsalsa20poly1305_MACBYTES", "crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX", "crypto_box_curve25519xsalsa20poly1305_NONCEBYTES", "crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES", "crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES", "crypto_box_curve25519xsalsa20poly1305_SEEDBYTES", "crypto_core_ed25519_BYTES", "crypto_core_ed25519_HASHBYTES", "crypto_core_ed25519_NONREDUCEDSCALARBYTES", "crypto_core_ed25519_SCALARBYTES", "crypto_core_ed25519_UNIFORMBYTES", "crypto_core_hchacha20_CONSTBYTES", "crypto_core_hchacha20_INPUTBYTES", "crypto_core_hchacha20_KEYBYTES", "crypto_core_hchacha20_OUTPUTBYTES", "crypto_core_hsalsa20_CONSTBYTES", "crypto_core_hsalsa20_INPUTBYTES", "crypto_core_hsalsa20_KEYBYTES", "crypto_core_hsalsa20_OUTPUTBYTES", "crypto_core_ristretto255_BYTES", "crypto_core_ristretto255_HASHBYTES", "crypto_core_ristretto255_NONREDUCEDSCALARBYTES", "crypto_core_ristretto255_SCALARBYTES", "crypto_core_salsa2012_CONSTBYTES", "crypto_core_salsa2012_INPUTBYTES", "crypto_core_salsa2012_KEYBYTES", "crypto_core_salsa2012_OUTPUTBYTES", "crypto_core_salsa208_CONSTBYTES", "crypto_core_salsa208_INPUTBYTES", "crypto_core_salsa208_KEYBYTES", "crypto_core_salsa208_OUTPUTBYTES", "crypto_core_salsa20_CONSTBYTES", "crypto_core_salsa20_INPUTBYTES", "crypto_core_salsa20_KEYBYTES", "crypto_core_salsa20_OUTPUTBYTES", "crypto_generichash_BYTES", "crypto_generichash_BYTES_MAX", "crypto_generichash_BYTES_MIN", "crypto_generichash_KEYBYTES", "crypto_generichash_KEYBYTES_MAX", "crypto_generichash_KEYBYTES_MIN", "crypto_generichash_blake2b_BYTES", "crypto_generichash_blake2b_BYTES_MAX", "crypto_generichash_blake2b_BYTES_MIN", "crypto_generichash_blake2b_KEYBYTES", "crypto_generichash_blake2b_KEYBYTES_MAX", "crypto_generichash_blake2b_KEYBYTES_MIN", "crypto_generichash_blake2b_PERSONALBYTES", "crypto_generichash_blake2b_SALTBYTES", "crypto_hash_BYTES", "crypto_hash_sha256_BYTES", "crypto_hash_sha512_BYTES", "crypto_kdf_BYTES_MAX", "crypto_kdf_BYTES_MIN", "crypto_kdf_CONTEXTBYTES", "crypto_kdf_KEYBYTES", "crypto_kdf_blake2b_BYTES_MAX", "crypto_kdf_blake2b_BYTES_MIN", "crypto_kdf_blake2b_CONTEXTBYTES", "crypto_kdf_blake2b_KEYBYTES", "crypto_kdf_hkdf_sha256_BYTES_MAX", "crypto_kdf_hkdf_sha256_BYTES_MIN", "crypto_kdf_hkdf_sha256_KEYBYTES", "crypto_kdf_hkdf_sha512_BYTES_MAX", "crypto_kdf_hkdf_sha512_BYTES_MIN", "crypto_kdf_hkdf_sha512_KEYBYTES", "crypto_kx_PUBLICKEYBYTES", "crypto_kx_SECRETKEYBYTES", "crypto_kx_SEEDBYTES", "crypto_kx_SESSIONKEYBYTES", "crypto_onetimeauth_BYTES", "crypto_onetimeauth_KEYBYTES", "crypto_onetimeauth_poly1305_BYTES", "crypto_onetimeauth_poly1305_KEYBYTES", "crypto_pwhash_ALG_ARGON2I13", "crypto_pwhash_ALG_ARGON2ID13", "crypto_pwhash_ALG_DEFAULT", "crypto_pwhash_BYTES_MAX", "crypto_pwhash_BYTES_MIN", "crypto_pwhash_MEMLIMIT_INTERACTIVE", "crypto_pwhash_MEMLIMIT_MAX", "crypto_pwhash_MEMLIMIT_MIN", "crypto_pwhash_MEMLIMIT_MODERATE", "crypto_pwhash_MEMLIMIT_SENSITIVE", "crypto_pwhash_OPSLIMIT_INTERACTIVE", "crypto_pwhash_OPSLIMIT_MAX", "crypto_pwhash_OPSLIMIT_MIN", "crypto_pwhash_OPSLIMIT_MODERATE", "crypto_pwhash_OPSLIMIT_SENSITIVE", "crypto_pwhash_PASSWD_MAX", "crypto_pwhash_PASSWD_MIN", "crypto_pwhash_SALTBYTES", "crypto_pwhash_STRBYTES", "crypto_pwhash_argon2i_BYTES_MAX", "crypto_pwhash_argon2i_BYTES_MIN", "crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE", "crypto_pwhash_argon2i_MEMLIMIT_MAX", "crypto_pwhash_argon2i_MEMLIMIT_MIN", "crypto_pwhash_argon2i_MEMLIMIT_MODERATE", "crypto_pwhash_argon2i_MEMLIMIT_SENSITIVE", "crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE", "crypto_pwhash_argon2i_OPSLIMIT_MAX", "crypto_pwhash_argon2i_OPSLIMIT_MIN", "crypto_pwhash_argon2i_OPSLIMIT_MODERATE", "crypto_pwhash_argon2i_OPSLIMIT_SENSITIVE", "crypto_pwhash_argon2i_PASSWD_MAX", "crypto_pwhash_argon2i_PASSWD_MIN", "crypto_pwhash_argon2i_SALTBYTES", "crypto_pwhash_argon2i_STRBYTES", "crypto_pwhash_argon2id_BYTES_MAX", "crypto_pwhash_argon2id_BYTES_MIN", "crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE", "crypto_pwhash_argon2id_MEMLIMIT_MAX", "crypto_pwhash_argon2id_MEMLIMIT_MIN", "crypto_pwhash_argon2id_MEMLIMIT_MODERATE", "crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE", "crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE", "crypto_pwhash_argon2id_OPSLIMIT_MAX", "crypto_pwhash_argon2id_OPSLIMIT_MIN", "crypto_pwhash_argon2id_OPSLIMIT_MODERATE", "crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE", "crypto_pwhash_argon2id_PASSWD_MAX", "crypto_pwhash_argon2id_PASSWD_MIN", "crypto_pwhash_argon2id_SALTBYTES", "crypto_pwhash_argon2id_STRBYTES", "crypto_pwhash_scryptsalsa208sha256_BYTES_MAX", "crypto_pwhash_scryptsalsa208sha256_BYTES_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX", "crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN", "crypto_pwhash_scryptsalsa208sha256_SALTBYTES", "crypto_pwhash_scryptsalsa208sha256_STRBYTES", "crypto_scalarmult_BYTES", "crypto_scalarmult_SCALARBYTES", "crypto_scalarmult_curve25519_BYTES", "crypto_scalarmult_curve25519_SCALARBYTES", "crypto_scalarmult_ed25519_BYTES", "crypto_scalarmult_ed25519_SCALARBYTES", "crypto_scalarmult_ristretto255_BYTES", "crypto_scalarmult_ristretto255_SCALARBYTES", "crypto_secretbox_KEYBYTES", "crypto_secretbox_MACBYTES", "crypto_secretbox_MESSAGEBYTES_MAX", "crypto_secretbox_NONCEBYTES", "crypto_secretbox_xchacha20poly1305_KEYBYTES", "crypto_secretbox_xchacha20poly1305_MACBYTES", "crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_secretbox_xchacha20poly1305_NONCEBYTES", "crypto_secretbox_xsalsa20poly1305_KEYBYTES", "crypto_secretbox_xsalsa20poly1305_MACBYTES", "crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX", "crypto_secretbox_xsalsa20poly1305_NONCEBYTES", "crypto_secretstream_xchacha20poly1305_ABYTES", "crypto_secretstream_xchacha20poly1305_HEADERBYTES", "crypto_secretstream_xchacha20poly1305_KEYBYTES", "crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_secretstream_xchacha20poly1305_TAG_FINAL", "crypto_secretstream_xchacha20poly1305_TAG_MESSAGE", "crypto_secretstream_xchacha20poly1305_TAG_PUSH", "crypto_secretstream_xchacha20poly1305_TAG_REKEY", "crypto_shorthash_BYTES", "crypto_shorthash_KEYBYTES", "crypto_shorthash_siphash24_BYTES", "crypto_shorthash_siphash24_KEYBYTES", "crypto_shorthash_siphashx24_BYTES", "crypto_shorthash_siphashx24_KEYBYTES", "crypto_sign_BYTES", "crypto_sign_MESSAGEBYTES_MAX", "crypto_sign_PUBLICKEYBYTES", "crypto_sign_SECRETKEYBYTES", "crypto_sign_SEEDBYTES", "crypto_sign_ed25519_BYTES", "crypto_sign_ed25519_MESSAGEBYTES_MAX", "crypto_sign_ed25519_PUBLICKEYBYTES", "crypto_sign_ed25519_SECRETKEYBYTES", "crypto_sign_ed25519_SEEDBYTES", "crypto_stream_KEYBYTES", "crypto_stream_MESSAGEBYTES_MAX", "crypto_stream_NONCEBYTES", "crypto_stream_chacha20_IETF_KEYBYTES", "crypto_stream_chacha20_IETF_MESSAGEBYTES_MAX", "crypto_stream_chacha20_IETF_NONCEBYTES", "crypto_stream_chacha20_KEYBYTES", "crypto_stream_chacha20_MESSAGEBYTES_MAX", "crypto_stream_chacha20_NONCEBYTES", "crypto_stream_chacha20_ietf_KEYBYTES", "crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX", "crypto_stream_chacha20_ietf_NONCEBYTES", "crypto_stream_salsa2012_KEYBYTES", "crypto_stream_salsa2012_MESSAGEBYTES_MAX", "crypto_stream_salsa2012_NONCEBYTES", "crypto_stream_salsa208_KEYBYTES", "crypto_stream_salsa208_MESSAGEBYTES_MAX", "crypto_stream_salsa208_NONCEBYTES", "crypto_stream_salsa20_KEYBYTES", "crypto_stream_salsa20_MESSAGEBYTES_MAX", "crypto_stream_salsa20_NONCEBYTES", "crypto_stream_xchacha20_KEYBYTES", "crypto_stream_xchacha20_MESSAGEBYTES_MAX", "crypto_stream_xchacha20_NONCEBYTES", "crypto_stream_xsalsa20_KEYBYTES", "crypto_stream_xsalsa20_MESSAGEBYTES_MAX", "crypto_stream_xsalsa20_NONCEBYTES", "crypto_verify_16_BYTES", "crypto_verify_32_BYTES", "crypto_verify_64_BYTES"]; + for (_3 = 0; _3 < n3.length; _3++) "function" == typeof (c3 = r2["_" + n3[_3].toLowerCase()]) && (e2[n3[_3]] = c3()); + var s3 = ["SODIUM_VERSION_STRING", "crypto_pwhash_STRPREFIX", "crypto_pwhash_argon2i_STRPREFIX", "crypto_pwhash_argon2id_STRPREFIX", "crypto_pwhash_scryptsalsa208sha256_STRPREFIX"]; + for (_3 = 0; _3 < s3.length; _3++) { + var c3; + "function" == typeof (c3 = r2["_" + s3[_3].toLowerCase()]) && (e2[s3[_3]] = r2.UTF8ToString(c3())); + } + } + r2 = a2; + try { + t2(); + var _2 = new Uint8Array([98, 97, 108, 108, 115]), n2 = e2.randombytes_buf(e2.crypto_secretbox_NONCEBYTES), s2 = e2.randombytes_buf(e2.crypto_secretbox_KEYBYTES), c2 = e2.crypto_secretbox_easy(_2, n2, s2), h2 = e2.crypto_secretbox_open_easy(c2, n2, s2); + if (e2.memcmp(_2, h2)) return; + } catch (e3) { + if (null == r2.useBackupModule) throw new Error("Both wasm and asm failed to load" + e3); + } + r2.useBackupModule(), t2(); + }); + function n(e3) { + if ("function" == typeof TextEncoder) return new TextEncoder().encode(e3); + e3 = unescape(encodeURIComponent(e3)); + for (var a3 = new Uint8Array(e3.length), r3 = 0, t2 = e3.length; r3 < t2; r3++) a3[r3] = e3.charCodeAt(r3); + return a3; + } + function s(e3) { + if ("function" == typeof TextDecoder) return new TextDecoder("utf-8", { fatal: true }).decode(e3); + var a3 = 8192, r3 = Math.ceil(e3.length / a3); + if (r3 <= 1) try { + return decodeURIComponent(escape(String.fromCharCode.apply(null, e3))); + } catch (e4) { + throw new TypeError("The encoded data was not valid."); + } + for (var t2 = "", _2 = 0, n2 = 0; n2 < r3; n2++) { + var c2 = Array.prototype.slice.call(e3, n2 * a3 + _2, (n2 + 1) * a3 + _2); + if (0 != c2.length) { + var h2, o2 = c2.length, p2 = 0; + do { + var y2 = c2[--o2]; + y2 >= 240 ? (p2 = 4, h2 = true) : y2 >= 224 ? (p2 = 3, h2 = true) : y2 >= 192 ? (p2 = 2, h2 = true) : y2 < 128 && (p2 = 1, h2 = true); + } while (!h2); + for (var i2 = p2 - (c2.length - o2), l2 = 0; l2 < i2; l2++) _2--, c2.pop(); + t2 += s(c2); + } + } + return t2; + } + function c(e3) { + e3 = E(null, e3, "input"); + for (var a3, r3, t2, _2 = "", n2 = 0; n2 < e3.length; n2++) t2 = 87 + (r3 = 15 & e3[n2]) + (r3 - 10 >> 8 & -39) << 8 | 87 + (a3 = e3[n2] >>> 4) + (a3 - 10 >> 8 & -39), _2 += String.fromCharCode(255 & t2) + String.fromCharCode(t2 >>> 8); + return _2; + } + var h = { ORIGINAL: 1, ORIGINAL_NO_PADDING: 3, URLSAFE: 5, URLSAFE_NO_PADDING: 7 }; + function o(e3) { + if (null == e3) return h.URLSAFE_NO_PADDING; + if (e3 !== h.ORIGINAL && e3 !== h.ORIGINAL_NO_PADDING && e3 !== h.URLSAFE && e3 != h.URLSAFE_NO_PADDING) throw new Error("unsupported base64 variant"); + return e3; + } + function p(e3, a3) { + a3 = o(a3), e3 = E(_2, e3, "input"); + var t2, _2 = [], n2 = 0 | Math.floor(e3.length / 3), c2 = e3.length - 3 * n2, h2 = 4 * n2 + (0 !== c2 ? 2 & a3 ? 2 + (c2 >>> 1) : 4 : 0), p2 = new u(h2 + 1), y2 = d(e3); + return _2.push(y2), _2.push(p2.address), 0 === r2._sodium_bin2base64(p2.address, p2.length, y2, e3.length, a3) && b(_2, "conversion failed"), p2.length = h2, t2 = s(p2.to_Uint8Array()), g(_2), t2; + } + function y(e3, a3) { + var r3 = a3 || t; + if (!i(r3)) throw new Error(r3 + " output format is not available"); + if (e3 instanceof u) { + if ("uint8array" === r3) return e3.to_Uint8Array(); + if ("text" === r3) return s(e3.to_Uint8Array()); + if ("hex" === r3) return c(e3.to_Uint8Array()); + if ("base64" === r3) return p(e3.to_Uint8Array(), h.URLSAFE_NO_PADDING); + throw new Error('What is output format "' + r3 + '"?'); + } + if ("object" == typeof e3) { + for (var _2 = Object.keys(e3), n2 = {}, o2 = 0; o2 < _2.length; o2++) n2[_2[o2]] = y(e3[_2[o2]], r3); + return n2; + } + if ("string" == typeof e3) return e3; + throw new TypeError("Cannot format output"); + } + function i(e3) { + for (var a3 = ["uint8array", "text", "hex", "base64"], r3 = 0; r3 < a3.length; r3++) if (a3[r3] === e3) return true; + return false; + } + function l(e3) { + if (e3) { + if ("string" != typeof e3) throw new TypeError("When defined, the output format must be a string"); + if (!i(e3)) throw new Error(e3 + " is not a supported output format"); + } + } + function u(e3) { + this.length = e3, this.address = v(e3); + } + function d(e3) { + var a3 = v(e3.length); + return r2.HEAPU8.set(e3, a3), a3; + } + function v(e3) { + var a3 = r2._malloc(e3); + if (0 === a3) throw { message: "_malloc() failed", length: e3 }; + return a3; + } + function g(e3) { + if (e3) for (var a3 = 0; a3 < e3.length; a3++) t2 = e3[a3], r2._free(t2); + var t2; + } + function b(e3, a3) { + throw g(e3), new Error(a3); + } + function f(e3, a3) { + throw g(e3), new TypeError(a3); + } + function m(e3, a3, r3) { + null == a3 && f(e3, r3 + " cannot be null or undefined"); + } + function E(e3, a3, r3) { + return m(e3, a3, r3), a3 instanceof Uint8Array ? a3 : "string" == typeof a3 ? n(a3) : void f(e3, "unsupported input type for " + r3); + } + function x(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_aegis128l_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_aegis128l_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_aegis128l_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function k(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_aegis128l_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function S(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_aegis128l_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_aegis128l_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function T(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_aegis128l_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_aegis128l_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function w(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_aegis128l_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_aegis128l_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Y(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_aegis256_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_aegis256_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_aegis256_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_aegis256_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function B(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_aegis256_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_aegis256_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function A(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis256_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_aegis256_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_aegis256_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function M(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis256_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_aegis256_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_aegis256_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function I(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_aegis256_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_aegis256_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function K(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_chacha20poly1305_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_chacha20poly1305_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_chacha20poly1305_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function N(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_chacha20poly1305_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function L(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_chacha20poly1305_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_chacha20poly1305_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function O(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_chacha20poly1305_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_chacha20poly1305_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function U(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_chacha20poly1305_ietf_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_chacha20poly1305_ietf_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_chacha20poly1305_ietf_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function C(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_chacha20poly1305_ietf_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function P(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_chacha20poly1305_ietf_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_chacha20poly1305_ietf_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function R(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_chacha20poly1305_ietf_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_chacha20poly1305_ietf_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function X(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_chacha20poly1305_ietf_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function G(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_chacha20poly1305_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_chacha20poly1305_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function D(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_xchacha20poly1305_ietf_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_xchacha20poly1305_ietf_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function F(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function V(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_xchacha20poly1305_ietf_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function H(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_xchacha20poly1305_ietf_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function W(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_xchacha20poly1305_ietf_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function q(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function j(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_hmacsha256_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_hmacsha256_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth_hmacsha256(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function z(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_auth_hmacsha256_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_auth_hmacsha256_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function J(e3, a3) { + var t2 = []; + l(a3); + var _2 = null, n2 = 0; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), n2 = e3.length, t2.push(_2)); + var s2 = new u(208).address; + if (!(0 | r2._crypto_auth_hmacsha256_init(s2, _2, n2))) { + var c2 = s2; + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function Q(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_hmacsha256_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_hmacsha256_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Z(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_auth_hmacsha256_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function $(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_hmacsha256_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_hmacsha256_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_hmacsha256_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ee(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_hmacsha512_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_hmacsha512_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth_hmacsha512(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function ae(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_hmacsha512256_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_hmacsha512256_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth_hmacsha512256(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function re(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_auth_hmacsha512256_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_auth_hmacsha512256_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function te(e3, a3) { + var t2 = []; + l(a3); + var _2 = null, n2 = 0; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), n2 = e3.length, t2.push(_2)); + var s2 = new u(416).address; + if (!(0 | r2._crypto_auth_hmacsha512256_init(s2, _2, n2))) { + var c2 = s2; + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function _e(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_hmacsha512256_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_hmacsha512256_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function ne(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_auth_hmacsha512256_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function se(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_hmacsha512256_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_hmacsha512256_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_hmacsha512256_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ce(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_auth_hmacsha512_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_auth_hmacsha512_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function he(e3, a3) { + var t2 = []; + l(a3); + var _2 = null, n2 = 0; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), n2 = e3.length, t2.push(_2)); + var s2 = new u(416).address; + if (!(0 | r2._crypto_auth_hmacsha512_init(s2, _2, n2))) { + var c2 = s2; + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function oe(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_hmacsha512_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_hmacsha512_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function pe(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_auth_hmacsha512_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function ye(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_hmacsha512_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_hmacsha512_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_hmacsha512_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ie(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function le(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ue(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "publicKey"); + var n2, s2 = 0 | r2._crypto_box_publickeybytes(); + e3.length !== s2 && f(_2, "invalid publicKey length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_box_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_box_beforenmbytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_box_beforenm(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function de(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "publicKey"); + var n2, s2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + e3.length !== s2 && f(_2, "invalid publicKey length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_beforenm(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function ve(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + s2.push(S2); + var T2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes()), w2 = T2.address; + if (s2.push(w2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_detached(S2, w2, c2, h2, 0, o2, i2, m2))) { + var Y2 = y({ ciphertext: k2, mac: T2 }, n2); + return g(s2), Y2; + } + b(s2, "invalid usage"); + } + function ge(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_detached_afternm(m2, k2, s2, c2, 0, h2, p2))) { + var S2 = y({ ciphertext: v2, mac: x2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function be(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(h2 + r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_easy(S2, c2, h2, 0, o2, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "invalid usage"); + } + function fe(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 + r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function me(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes()), s2 = n2.address; + a3.push(s2), r2._crypto_box_curve25519xchacha20poly1305_keypair(_2, s2); + var c2 = y({ publicKey: t2, privateKey: n2, keyType: "curve25519" }, e3); + return g(a3), c2; + } + function Ee(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "ciphertext")), o2 = e3.length; + c2.push(h2), a3 = E(c2, a3, "mac"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes(); + a3.length !== i2 && f(c2, "invalid mac length"), p2 = d(a3), c2.push(p2), t2 = E(c2, t2, "nonce"); + var v2, m2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + t2.length !== m2 && f(c2, "invalid nonce length"), v2 = d(t2), c2.push(v2), _2 = E(c2, _2, "publicKey"); + var x2, k2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + _2.length !== k2 && f(c2, "invalid publicKey length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "privateKey"); + var S2, T2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + n2.length !== T2 && f(c2, "invalid privateKey length"), S2 = d(n2), c2.push(S2); + var w2 = new u(0 | o2), Y2 = w2.address; + if (c2.push(Y2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_detached(Y2, h2, p2, o2, 0, v2, x2, S2))) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "incorrect key pair for the given ciphertext"); + } + function xe(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "ciphertext")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "mac"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes(); + a3.length !== p2 && f(s2, "invalid mac length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "nonce"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + t2.length !== v2 && f(s2, "invalid nonce length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "sharedKey"); + var m2, x2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + _2.length !== x2 && f(s2, "invalid sharedKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_detached_afternm(S2, c2, o2, h2, 0, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "incorrect secret key for the given ciphertext"); + } + function ke(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), e3 = E(s2, e3, "ciphertext"); + var c2, h2 = r2._crypto_box_curve25519xchacha20poly1305_macbytes(), o2 = e3.length; + o2 < h2 && f(s2, "ciphertext is too short"), c2 = d(e3), s2.push(c2), a3 = E(s2, a3, "nonce"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== i2 && f(s2, "invalid nonce length"), p2 = d(a3), s2.push(p2), t2 = E(s2, t2, "publicKey"); + var v2, m2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + t2.length !== m2 && f(s2, "invalid publicKey length"), v2 = d(t2), s2.push(v2), _2 = E(s2, _2, "privateKey"); + var x2, k2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + _2.length !== k2 && f(s2, "invalid privateKey length"), x2 = d(_2), s2.push(x2); + var S2 = new u(o2 - r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), T2 = S2.address; + if (s2.push(T2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_easy(T2, c2, o2, 0, p2, v2, x2))) { + var w2 = y(S2, n2); + return g(s2), w2; + } + b(s2, "incorrect key pair for the given ciphertext"); + } + function Se(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "ciphertext")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 - r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "incorrect secret key for the given ciphertext"); + } + function Te(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "publicKey"); + var c2, h2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + a3.length !== h2 && f(_2, "invalid publicKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(s2 + r2._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0), p2 = o2.address; + _2.push(p2), r2._crypto_box_curve25519xchacha20poly1305_seal(p2, n2, s2, 0, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function we(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "ciphertext"); + var s2, c2 = r2._crypto_box_curve25519xchacha20poly1305_sealbytes(), h2 = e3.length; + h2 < c2 && f(n2, "ciphertext is too short"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "publicKey"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + a3.length !== p2 && f(n2, "invalid publicKey length"), o2 = d(a3), n2.push(o2), t2 = E(n2, t2, "secretKey"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + t2.length !== v2 && f(n2, "invalid secretKey length"), i2 = d(t2), n2.push(i2); + var b2 = new u(h2 - r2._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0), m2 = b2.address; + n2.push(m2), r2._crypto_box_curve25519xchacha20poly1305_seal_open(m2, s2, h2, 0, o2, i2); + var x2 = y(b2, _2); + return g(n2), x2; + } + function Ye(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "x25519" }; + return g(t2), p2; + } + b(t2, "invalid usage"); + } + function Be(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + s2.push(S2); + var T2 = new u(0 | r2._crypto_box_macbytes()), w2 = T2.address; + if (s2.push(w2), !(0 | r2._crypto_box_detached(S2, w2, c2, h2, 0, o2, i2, m2))) { + var Y2 = y({ ciphertext: k2, mac: T2 }, n2); + return g(s2), Y2; + } + b(s2, "invalid usage"); + } + function Ae(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(h2 + r2._crypto_box_macbytes() | 0), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_box_easy(S2, c2, h2, 0, o2, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "invalid usage"); + } + function Me(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 + r2._crypto_box_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Ie(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_box_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_box_secretkeybytes()), s2 = n2.address; + if (a3.push(s2), !(0 | r2._crypto_box_keypair(_2, s2))) { + var c2 = { publicKey: y(t2, e3), privateKey: y(n2, e3), keyType: "x25519" }; + return g(a3), c2; + } + b(a3, "internal error"); + } + function Ke(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "ciphertext")), o2 = e3.length; + c2.push(h2), a3 = E(c2, a3, "mac"); + var p2, i2 = 0 | r2._crypto_box_macbytes(); + a3.length !== i2 && f(c2, "invalid mac length"), p2 = d(a3), c2.push(p2), t2 = E(c2, t2, "nonce"); + var v2, m2 = 0 | r2._crypto_box_noncebytes(); + t2.length !== m2 && f(c2, "invalid nonce length"), v2 = d(t2), c2.push(v2), _2 = E(c2, _2, "publicKey"); + var x2, k2 = 0 | r2._crypto_box_publickeybytes(); + _2.length !== k2 && f(c2, "invalid publicKey length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "privateKey"); + var S2, T2 = 0 | r2._crypto_box_secretkeybytes(); + n2.length !== T2 && f(c2, "invalid privateKey length"), S2 = d(n2), c2.push(S2); + var w2 = new u(0 | o2), Y2 = w2.address; + if (c2.push(Y2), !(0 | r2._crypto_box_open_detached(Y2, h2, p2, o2, 0, v2, x2, S2))) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "incorrect key pair for the given ciphertext"); + } + function Ne(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), e3 = E(s2, e3, "ciphertext"); + var c2, h2 = r2._crypto_box_macbytes(), o2 = e3.length; + o2 < h2 && f(s2, "ciphertext is too short"), c2 = d(e3), s2.push(c2), a3 = E(s2, a3, "nonce"); + var p2, i2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== i2 && f(s2, "invalid nonce length"), p2 = d(a3), s2.push(p2), t2 = E(s2, t2, "publicKey"); + var v2, m2 = 0 | r2._crypto_box_publickeybytes(); + t2.length !== m2 && f(s2, "invalid publicKey length"), v2 = d(t2), s2.push(v2), _2 = E(s2, _2, "privateKey"); + var x2, k2 = 0 | r2._crypto_box_secretkeybytes(); + _2.length !== k2 && f(s2, "invalid privateKey length"), x2 = d(_2), s2.push(x2); + var S2 = new u(o2 - r2._crypto_box_macbytes() | 0), T2 = S2.address; + if (s2.push(T2), !(0 | r2._crypto_box_open_easy(T2, c2, o2, 0, p2, v2, x2))) { + var w2 = y(S2, n2); + return g(s2), w2; + } + b(s2, "incorrect key pair for the given ciphertext"); + } + function Le(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "ciphertext")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 - r2._crypto_box_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_open_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "incorrect secret key for the given ciphertext"); + } + function Oe(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "publicKey"); + var c2, h2 = 0 | r2._crypto_box_publickeybytes(); + a3.length !== h2 && f(_2, "invalid publicKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(s2 + r2._crypto_box_sealbytes() | 0), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_box_seal(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function Ue(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "ciphertext"); + var s2, c2 = r2._crypto_box_sealbytes(), h2 = e3.length; + h2 < c2 && f(n2, "ciphertext is too short"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "publicKey"); + var o2, p2 = 0 | r2._crypto_box_publickeybytes(); + a3.length !== p2 && f(n2, "invalid publicKey length"), o2 = d(a3), n2.push(o2), t2 = E(n2, t2, "privateKey"); + var i2, v2 = 0 | r2._crypto_box_secretkeybytes(); + t2.length !== v2 && f(n2, "invalid privateKey length"), i2 = d(t2), n2.push(i2); + var m2 = new u(h2 - r2._crypto_box_sealbytes() | 0), x2 = m2.address; + if (n2.push(x2), !(0 | r2._crypto_box_seal_open(x2, s2, h2, 0, o2, i2))) { + var k2 = y(m2, _2); + return g(n2), k2; + } + b(n2, "incorrect key pair for the given ciphertext"); + } + function Ce(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_box_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_box_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_box_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_box_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "x25519" }; + return g(t2), p2; + } + b(t2, "invalid usage"); + } + function Pe(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ed25519_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ed25519_add(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function Re(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "r")); + e3.length, t2.push(_2); + var n2 = new u(0 | r2._crypto_core_ed25519_bytes()), s2 = n2.address; + if (t2.push(s2), !(0 | r2._crypto_core_ed25519_from_hash(s2, _2))) { + var c2 = y(n2, a3); + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function Xe(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "r")); + e3.length, t2.push(_2); + var n2 = new u(0 | r2._crypto_core_ed25519_bytes()), s2 = n2.address; + if (t2.push(s2), !(0 | r2._crypto_core_ed25519_from_uniform(s2, _2))) { + var c2 = y(n2, a3); + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function Ge(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "repr"); + var _2, n2 = 0 | r2._crypto_core_ed25519_bytes(); + e3.length !== n2 && f(t2, "invalid repr length"), _2 = d(e3), t2.push(_2); + var s2 = 1 == (0 | r2._crypto_core_ed25519_is_valid_point(_2)); + return g(t2), s2; + } + function De(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ed25519_bytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ed25519_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Fe(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ed25519_scalar_add(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function Ve(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ed25519_scalar_complement(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function He(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_core_ed25519_scalar_invert(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid reciprocate"); + } + function We(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ed25519_scalar_mul(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function qe(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ed25519_scalar_negate(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function je(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ed25519_scalar_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function ze(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "sample"); + var _2, n2 = 0 | r2._crypto_core_ed25519_nonreducedscalarbytes(); + e3.length !== n2 && f(t2, "invalid sample length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ed25519_scalar_reduce(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function Je(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ed25519_scalar_sub(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function Qe(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ed25519_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ed25519_sub(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function Ze(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "input"); + var s2, c2 = 0 | r2._crypto_core_hchacha20_inputbytes(); + e3.length !== c2 && f(n2, "invalid input length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "privateKey"); + var h2, o2 = 0 | r2._crypto_core_hchacha20_keybytes(); + a3.length !== o2 && f(n2, "invalid privateKey length"), h2 = d(a3), n2.push(h2); + var p2 = null; + null != t2 && (p2 = d(t2 = E(n2, t2, "constant")), t2.length, n2.push(p2)); + var i2 = new u(0 | r2._crypto_core_hchacha20_outputbytes()), v2 = i2.address; + if (n2.push(v2), !(0 | r2._crypto_core_hchacha20(v2, s2, h2, p2))) { + var m2 = y(i2, _2); + return g(n2), m2; + } + b(n2, "invalid usage"); + } + function $e(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "input"); + var s2, c2 = 0 | r2._crypto_core_hsalsa20_inputbytes(); + e3.length !== c2 && f(n2, "invalid input length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "privateKey"); + var h2, o2 = 0 | r2._crypto_core_hsalsa20_keybytes(); + a3.length !== o2 && f(n2, "invalid privateKey length"), h2 = d(a3), n2.push(h2); + var p2 = null; + null != t2 && (p2 = d(t2 = E(n2, t2, "constant")), t2.length, n2.push(p2)); + var i2 = new u(0 | r2._crypto_core_hsalsa20_outputbytes()), v2 = i2.address; + if (n2.push(v2), !(0 | r2._crypto_core_hsalsa20(v2, s2, h2, p2))) { + var m2 = y(i2, _2); + return g(n2), m2; + } + b(n2, "invalid usage"); + } + function ea(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ristretto255_add(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function aa(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "r")); + e3.length, t2.push(_2); + var n2 = new u(0 | r2._crypto_core_ristretto255_bytes()), s2 = n2.address; + if (t2.push(s2), !(0 | r2._crypto_core_ristretto255_from_hash(s2, _2))) { + var c2 = y(n2, a3); + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function ra(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "repr"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_bytes(); + e3.length !== n2 && f(t2, "invalid repr length"), _2 = d(e3), t2.push(_2); + var s2 = 1 == (0 | r2._crypto_core_ristretto255_is_valid_point(_2)); + return g(t2), s2; + } + function ta(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ristretto255_bytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ristretto255_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function _a2(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ristretto255_scalar_add(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function na(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ristretto255_scalar_complement(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function sa(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_core_ristretto255_scalar_invert(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid reciprocate"); + } + function ca(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ristretto255_scalar_mul(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function ha(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ristretto255_scalar_negate(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function oa(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ristretto255_scalar_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function pa(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "sample"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_nonreducedscalarbytes(); + e3.length !== n2 && f(t2, "invalid sample length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ristretto255_scalar_reduce(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function ya(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ristretto255_scalar_sub(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function ia(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ristretto255_sub(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function la(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "hash_length"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(n2, "hash_length must be an unsigned integer"); + var s2 = d(a3 = E(n2, a3, "message")), c2 = a3.length; + n2.push(s2); + var h2 = null, o2 = 0; + null != t2 && (h2 = d(t2 = E(n2, t2, "key")), o2 = t2.length, n2.push(h2)); + var p2 = new u(e3 |= 0), i2 = p2.address; + if (n2.push(i2), !(0 | r2._crypto_generichash(i2, e3, s2, c2, 0, h2, o2))) { + var v2 = y(p2, _2); + return g(n2), v2; + } + b(n2, "invalid usage"); + } + function ua(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), m(s2, e3, "subkey_len"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(s2, "subkey_len must be an unsigned integer"); + var c2 = null, h2 = 0; + null != a3 && (c2 = d(a3 = E(s2, a3, "key")), h2 = a3.length, s2.push(c2)); + var o2 = null, p2 = 0; + null != t2 && (t2 = E(s2, t2, "id"), p2 = 0 | r2._crypto_generichash_blake2b_saltbytes(), t2.length !== p2 && f(s2, "invalid id length"), o2 = d(t2), s2.push(o2)); + var i2 = null, v2 = 0; + null != _2 && (_2 = E(s2, _2, "ctx"), v2 = 0 | r2._crypto_generichash_blake2b_personalbytes(), _2.length !== v2 && f(s2, "invalid ctx length"), i2 = d(_2), s2.push(i2)); + var x2 = new u(0 | e3), k2 = x2.address; + if (s2.push(k2), !(0 | r2._crypto_generichash_blake2b_salt_personal(k2, e3, null, 0, 0, c2, h2, o2, i2))) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function da(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"), m(_2, a3, "hash_length"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(_2, "hash_length must be an unsigned integer"); + var n2 = new u(a3 |= 0), s2 = n2.address; + if (_2.push(s2), !(0 | r2._crypto_generichash_final(e3, s2, a3))) { + var c2 = (r2._free(e3), y(n2, t2)); + return g(_2), c2; + } + b(_2, "invalid usage"); + } + function va(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = null, s2 = 0; + null != e3 && (n2 = d(e3 = E(_2, e3, "key")), s2 = e3.length, _2.push(n2)), m(_2, a3, "hash_length"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(_2, "hash_length must be an unsigned integer"); + var c2 = new u(357).address; + if (!(0 | r2._crypto_generichash_init(c2, n2, s2, a3))) { + var h2 = c2; + return g(_2), h2; + } + b(_2, "invalid usage"); + } + function ga(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_generichash_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_generichash_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function ba(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_generichash_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function fa(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "message")), n2 = e3.length; + t2.push(_2); + var s2 = new u(0 | r2._crypto_hash_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_hash(c2, _2, n2, 0))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid usage"); + } + function ma(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "message")), n2 = e3.length; + t2.push(_2); + var s2 = new u(0 | r2._crypto_hash_sha256_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_hash_sha256(c2, _2, n2, 0))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid usage"); + } + function Ea(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_hash_sha256_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_hash_sha256_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function xa(e3) { + var a3 = []; + l(e3); + var t2 = new u(104).address; + if (!(0 | r2._crypto_hash_sha256_init(t2))) { + var _2 = t2; + return g(a3), _2; + } + b(a3, "invalid usage"); + } + function ka(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_hash_sha256_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function Sa(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "message")), n2 = e3.length; + t2.push(_2); + var s2 = new u(0 | r2._crypto_hash_sha512_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_hash_sha512(c2, _2, n2, 0))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid usage"); + } + function Ta(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_hash_sha512_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_hash_sha512_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function wa(e3) { + var a3 = []; + l(e3); + var t2 = new u(208).address; + if (!(0 | r2._crypto_hash_sha512_init(t2))) { + var _2 = t2; + return g(a3), _2; + } + b(a3, "invalid usage"); + } + function Ya(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_hash_sha512_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function Ba(e3, a3, t2, _2, s2) { + var c2 = []; + l(s2), m(c2, e3, "subkey_len"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(c2, "subkey_len must be an unsigned integer"), m(c2, a3, "subkey_id"); + var h2, o2 = 0; + if ("bigint" == typeof a3 && a3 >= BigInt(0)) { + const e4 = a3 >> BigInt(32); + e4 > BigInt(4294967295) && f(c2, "subkey_id cannot be more than 64 bits"), o2 = Number(e4), h2 = Number(a3 & BigInt(4294967295)); + } else "number" == typeof a3 && (0 | a3) === a3 && a3 >= 0 ? h2 = a3 : f(c2, "subkey_id must be an unsigned integer or bigint"); + "string" != typeof t2 && f(c2, "ctx must be a string"), t2 = n(t2 + "\0"), null != i2 && t2.length - 1 !== i2 && f(c2, "invalid ctx length"); + var p2 = d(t2), i2 = t2.length - 1; + c2.push(p2), _2 = E(c2, _2, "key"); + var v2, b2 = 0 | r2._crypto_kdf_keybytes(); + _2.length !== b2 && f(c2, "invalid key length"), v2 = d(_2), c2.push(v2); + var x2 = new u(0 | e3), k2 = x2.address; + c2.push(k2), r2._crypto_kdf_derive_from_key(k2, e3, h2, o2, p2, v2); + var S2 = y(x2, s2); + return g(c2), S2; + } + function Aa(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_kdf_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_kdf_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Ma(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "clientPublicKey"); + var s2, c2 = 0 | r2._crypto_kx_publickeybytes(); + e3.length !== c2 && f(n2, "invalid clientPublicKey length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "clientSecretKey"); + var h2, o2 = 0 | r2._crypto_kx_secretkeybytes(); + a3.length !== o2 && f(n2, "invalid clientSecretKey length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "serverPublicKey"); + var p2, i2 = 0 | r2._crypto_kx_publickeybytes(); + t2.length !== i2 && f(n2, "invalid serverPublicKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | r2._crypto_kx_sessionkeybytes()), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_kx_sessionkeybytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_kx_client_session_keys(m2, k2, s2, h2, p2))) { + var S2 = y({ sharedRx: v2, sharedTx: x2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function Ia(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_kx_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_kx_secretkeybytes()), s2 = n2.address; + if (a3.push(s2), !(0 | r2._crypto_kx_keypair(_2, s2))) { + var c2 = { publicKey: y(t2, e3), privateKey: y(n2, e3), keyType: "x25519" }; + return g(a3), c2; + } + b(a3, "internal error"); + } + function Ka(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_kx_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_kx_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_kx_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_kx_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "x25519" }; + return g(t2), p2; + } + b(t2, "internal error"); + } + function Na(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "serverPublicKey"); + var s2, c2 = 0 | r2._crypto_kx_publickeybytes(); + e3.length !== c2 && f(n2, "invalid serverPublicKey length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "serverSecretKey"); + var h2, o2 = 0 | r2._crypto_kx_secretkeybytes(); + a3.length !== o2 && f(n2, "invalid serverSecretKey length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "clientPublicKey"); + var p2, i2 = 0 | r2._crypto_kx_publickeybytes(); + t2.length !== i2 && f(n2, "invalid clientPublicKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | r2._crypto_kx_sessionkeybytes()), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_kx_sessionkeybytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_kx_server_session_keys(m2, k2, s2, h2, p2))) { + var S2 = y({ sharedRx: v2, sharedTx: x2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function La(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_onetimeauth_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_onetimeauth_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_onetimeauth(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function Oa(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_onetimeauth_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_onetimeauth_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function Ua(e3, a3) { + var t2 = []; + l(a3); + var _2 = null; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), e3.length, t2.push(_2)); + var n2 = new u(144).address; + if (!(0 | r2._crypto_onetimeauth_init(n2, _2))) { + var s2 = n2; + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function Ca(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_onetimeauth_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_onetimeauth_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Pa(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_onetimeauth_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function Ra(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "hash"); + var n2, s2 = 0 | r2._crypto_onetimeauth_bytes(); + e3.length !== s2 && f(_2, "invalid hash length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_onetimeauth_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_onetimeauth_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function Xa(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2), m(h2, e3, "keyLength"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(h2, "keyLength must be an unsigned integer"); + var o2 = d(a3 = E(h2, a3, "password")), p2 = a3.length; + h2.push(o2), t2 = E(h2, t2, "salt"); + var i2, v2 = 0 | r2._crypto_pwhash_saltbytes(); + t2.length !== v2 && f(h2, "invalid salt length"), i2 = d(t2), h2.push(i2), m(h2, _2, "opsLimit"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(h2, "opsLimit must be an unsigned integer"), m(h2, n2, "memLimit"), ("number" != typeof n2 || (0 | n2) !== n2 || n2 < 0) && f(h2, "memLimit must be an unsigned integer"), m(h2, s2, "algorithm"), ("number" != typeof s2 || (0 | s2) !== s2 || s2 < 0) && f(h2, "algorithm must be an unsigned integer"); + var x2 = new u(0 | e3), k2 = x2.address; + if (h2.push(k2), !(0 | r2._crypto_pwhash(k2, e3, 0, o2, p2, 0, i2, _2, 0, n2, s2))) { + var S2 = y(x2, c2); + return g(h2), S2; + } + b(h2, "invalid usage"); + } + function Ga(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2), m(c2, e3, "keyLength"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(c2, "keyLength must be an unsigned integer"); + var h2 = d(a3 = E(c2, a3, "password")), o2 = a3.length; + c2.push(h2), t2 = E(c2, t2, "salt"); + var p2, i2 = 0 | r2._crypto_pwhash_scryptsalsa208sha256_saltbytes(); + t2.length !== i2 && f(c2, "invalid salt length"), p2 = d(t2), c2.push(p2), m(c2, _2, "opsLimit"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(c2, "opsLimit must be an unsigned integer"), m(c2, n2, "memLimit"), ("number" != typeof n2 || (0 | n2) !== n2 || n2 < 0) && f(c2, "memLimit must be an unsigned integer"); + var v2 = new u(0 | e3), x2 = v2.address; + if (c2.push(x2), !(0 | r2._crypto_pwhash_scryptsalsa208sha256(x2, e3, 0, h2, o2, 0, p2, _2, 0, n2))) { + var k2 = y(v2, s2); + return g(c2), k2; + } + b(c2, "invalid usage"); + } + function Da(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = d(e3 = E(h2, e3, "password")), p2 = e3.length; + h2.push(o2); + var i2 = d(a3 = E(h2, a3, "salt")), v2 = a3.length; + h2.push(i2), m(h2, t2, "opsLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(h2, "opsLimit must be an unsigned integer"), m(h2, _2, "r"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(h2, "r must be an unsigned integer"), m(h2, n2, "p"), ("number" != typeof n2 || (0 | n2) !== n2 || n2 < 0) && f(h2, "p must be an unsigned integer"), m(h2, s2, "keyLength"), ("number" != typeof s2 || (0 | s2) !== s2 || s2 < 0) && f(h2, "keyLength must be an unsigned integer"); + var x2 = new u(0 | s2), k2 = x2.address; + if (h2.push(k2), !(0 | r2._crypto_pwhash_scryptsalsa208sha256_ll(o2, p2, i2, v2, t2, 0, _2, n2, k2, s2))) { + var S2 = y(x2, c2); + return g(h2), S2; + } + b(h2, "invalid usage"); + } + function Fa(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "password")), c2 = e3.length; + n2.push(s2), m(n2, a3, "opsLimit"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(n2, "opsLimit must be an unsigned integer"), m(n2, t2, "memLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(n2, "memLimit must be an unsigned integer"); + var h2 = new u(0 | r2._crypto_pwhash_scryptsalsa208sha256_strbytes()).address; + if (n2.push(h2), !(0 | r2._crypto_pwhash_scryptsalsa208sha256_str(h2, s2, c2, 0, a3, 0, t2))) { + var o2 = r2.UTF8ToString(h2); + return g(n2), o2; + } + b(n2, "invalid usage"); + } + function Va(e3, a3, t2) { + var _2 = []; + l(t2), "string" != typeof e3 && f(_2, "hashed_password must be a string"), e3 = n(e3 + "\0"), null != c2 && e3.length - 1 !== c2 && f(_2, "invalid hashed_password length"); + var s2 = d(e3), c2 = e3.length - 1; + _2.push(s2); + var h2 = d(a3 = E(_2, a3, "password")), o2 = a3.length; + _2.push(h2); + var p2 = !(0 | r2._crypto_pwhash_scryptsalsa208sha256_str_verify(s2, h2, o2, 0)); + return g(_2), p2; + } + function Ha(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "password")), c2 = e3.length; + n2.push(s2), m(n2, a3, "opsLimit"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(n2, "opsLimit must be an unsigned integer"), m(n2, t2, "memLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(n2, "memLimit must be an unsigned integer"); + var h2 = new u(0 | r2._crypto_pwhash_strbytes()).address; + if (n2.push(h2), !(0 | r2._crypto_pwhash_str(h2, s2, c2, 0, a3, 0, t2))) { + var o2 = r2.UTF8ToString(h2); + return g(n2), o2; + } + b(n2, "invalid usage"); + } + function Wa(e3, a3, t2, _2) { + var s2 = []; + l(_2), "string" != typeof e3 && f(s2, "hashed_password must be a string"), e3 = n(e3 + "\0"), null != h2 && e3.length - 1 !== h2 && f(s2, "invalid hashed_password length"); + var c2 = d(e3), h2 = e3.length - 1; + s2.push(c2), m(s2, a3, "opsLimit"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(s2, "opsLimit must be an unsigned integer"), m(s2, t2, "memLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "memLimit must be an unsigned integer"); + var o2 = !!(0 | r2._crypto_pwhash_str_needs_rehash(c2, a3, 0, t2)); + return g(s2), o2; + } + function qa(e3, a3, t2) { + var _2 = []; + l(t2), "string" != typeof e3 && f(_2, "hashed_password must be a string"), e3 = n(e3 + "\0"), null != c2 && e3.length - 1 !== c2 && f(_2, "invalid hashed_password length"); + var s2 = d(e3), c2 = e3.length - 1; + _2.push(s2); + var h2 = d(a3 = E(_2, a3, "password")), o2 = a3.length; + _2.push(h2); + var p2 = !(0 | r2._crypto_pwhash_str_verify(s2, h2, o2, 0)); + return g(_2), p2; + } + function ja(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "privateKey"); + var n2, s2 = 0 | r2._crypto_scalarmult_scalarbytes(); + e3.length !== s2 && f(_2, "invalid privateKey length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "publicKey"); + var c2, h2 = 0 | r2._crypto_scalarmult_bytes(); + a3.length !== h2 && f(_2, "invalid publicKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "weak public key"); + } + function za(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "privateKey"); + var _2, n2 = 0 | r2._crypto_scalarmult_scalarbytes(); + e3.length !== n2 && f(t2, "invalid privateKey length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_base(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "unknown error"); + } + function Ja(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "n"); + var n2, s2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid n length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "p"); + var c2, h2 = 0 | r2._crypto_scalarmult_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid p length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult_ed25519(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid point or scalar is 0"); + } + function Qa(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "scalar"); + var _2, n2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid scalar length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_ed25519_base(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "scalar is 0"); + } + function Za(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "scalar"); + var _2, n2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid scalar length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_ed25519_base_noclamp(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "scalar is 0"); + } + function $a(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "n"); + var n2, s2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid n length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "p"); + var c2, h2 = 0 | r2._crypto_scalarmult_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid p length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult_ed25519_noclamp(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid point or scalar is 0"); + } + function er(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "scalar"); + var n2, s2 = 0 | r2._crypto_scalarmult_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid scalar length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "element"); + var c2, h2 = 0 | r2._crypto_scalarmult_ristretto255_bytes(); + a3.length !== h2 && f(_2, "invalid element length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_ristretto255_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult_ristretto255(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "result is identity element"); + } + function ar(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "scalar"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid scalar length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_ristretto255_base(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "scalar is 0"); + } + function rr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_secretbox_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_secretbox_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_secretbox_macbytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_secretbox_detached(m2, k2, s2, c2, 0, h2, p2))) { + var S2 = y({ mac: x2, cipher: v2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function tr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_secretbox_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_secretbox_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 + r2._crypto_secretbox_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_secretbox_easy(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function _r(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_secretbox_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_secretbox_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function nr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "ciphertext")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "mac"); + var o2, p2 = 0 | r2._crypto_secretbox_macbytes(); + a3.length !== p2 && f(s2, "invalid mac length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "nonce"); + var i2, v2 = 0 | r2._crypto_secretbox_noncebytes(); + t2.length !== v2 && f(s2, "invalid nonce length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "key"); + var m2, x2 = 0 | r2._crypto_secretbox_keybytes(); + _2.length !== x2 && f(s2, "invalid key length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_secretbox_open_detached(S2, c2, o2, h2, 0, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "wrong secret key for the given ciphertext"); + } + function sr(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "ciphertext"); + var s2, c2 = r2._crypto_secretbox_macbytes(), h2 = e3.length; + h2 < c2 && f(n2, "ciphertext is too short"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_secretbox_noncebytes(); + a3.length !== p2 && f(n2, "invalid nonce length"), o2 = d(a3), n2.push(o2), t2 = E(n2, t2, "key"); + var i2, v2 = 0 | r2._crypto_secretbox_keybytes(); + t2.length !== v2 && f(n2, "invalid key length"), i2 = d(t2), n2.push(i2); + var m2 = new u(h2 - r2._crypto_secretbox_macbytes() | 0), x2 = m2.address; + if (n2.push(x2), !(0 | r2._crypto_secretbox_open_easy(x2, s2, h2, 0, o2, i2))) { + var k2 = y(m2, _2); + return g(n2), k2; + } + b(n2, "wrong secret key for the given ciphertext"); + } + function cr(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "header"); + var n2, s2 = 0 | r2._crypto_secretstream_xchacha20poly1305_headerbytes(); + e3.length !== s2 && f(_2, "invalid header length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_secretstream_xchacha20poly1305_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(52).address; + if (!(0 | r2._crypto_secretstream_xchacha20poly1305_init_pull(o2, n2, c2))) { + var p2 = o2; + return g(_2), p2; + } + b(_2, "invalid usage"); + } + function hr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "key"); + var _2, n2 = 0 | r2._crypto_secretstream_xchacha20poly1305_keybytes(); + e3.length !== n2 && f(t2, "invalid key length"), _2 = d(e3), t2.push(_2); + var s2 = new u(52).address, c2 = new u(0 | r2._crypto_secretstream_xchacha20poly1305_headerbytes()), h2 = c2.address; + if (t2.push(h2), !(0 | r2._crypto_secretstream_xchacha20poly1305_init_push(s2, h2, _2))) { + var o2 = { state: s2, header: y(c2, a3) }; + return g(t2), o2; + } + b(t2, "invalid usage"); + } + function or(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_secretstream_xchacha20poly1305_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_secretstream_xchacha20poly1305_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function pr(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "state_address"), a3 = E(n2, a3, "cipher"); + var s2, c2 = r2._crypto_secretstream_xchacha20poly1305_abytes(), h2 = a3.length; + h2 < c2 && f(n2, "cipher is too short"), s2 = d(a3), n2.push(s2); + var o2 = null, p2 = 0; + null != t2 && (o2 = d(t2 = E(n2, t2, "ad")), p2 = t2.length, n2.push(o2)); + var i2 = new u(h2 - r2._crypto_secretstream_xchacha20poly1305_abytes() | 0), b2 = i2.address; + n2.push(b2); + var x2, k2 = (x2 = v(1), n2.push(x2), (k2 = 0 === r2._crypto_secretstream_xchacha20poly1305_pull(e3, b2, 0, x2, s2, h2, 0, o2, p2) && { tag: r2.HEAPU8[x2], message: i2 }) && { message: y(k2.message, _2), tag: k2.tag }); + return g(n2), k2; + } + function yr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), m(s2, e3, "state_address"); + var c2 = d(a3 = E(s2, a3, "message_chunk")), h2 = a3.length; + s2.push(c2); + var o2 = null, p2 = 0; + null != t2 && (o2 = d(t2 = E(s2, t2, "ad")), p2 = t2.length, s2.push(o2)), m(s2, _2, "tag"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(s2, "tag must be an unsigned integer"); + var i2 = new u(h2 + r2._crypto_secretstream_xchacha20poly1305_abytes() | 0), v2 = i2.address; + if (s2.push(v2), !(0 | r2._crypto_secretstream_xchacha20poly1305_push(e3, v2, 0, c2, h2, 0, o2, p2, 0, _2))) { + var x2 = y(i2, n2); + return g(s2), x2; + } + b(s2, "invalid usage"); + } + function ir(e3, a3) { + var t2 = []; + return l(a3), m(t2, e3, "state_address"), r2._crypto_secretstream_xchacha20poly1305_rekey(e3), g(t2), true; + } + function lr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_shorthash_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_shorthash_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_shorthash(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function ur(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_shorthash_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_shorthash_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function dr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_shorthash_siphashx24_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_shorthash_siphashx24_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_shorthash_siphashx24(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function vr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_sign_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(e3.length + r2._crypto_sign_bytes() | 0), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_sign(p2, null, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function gr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_sign_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_sign_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_sign_detached(p2, null, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function br(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "edPk"); + var _2, n2 = 0 | r2._crypto_sign_publickeybytes(); + e3.length !== n2 && f(t2, "invalid edPk length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_pk_to_curve25519(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function fr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "edSk"); + var _2, n2 = 0 | r2._crypto_sign_secretkeybytes(); + e3.length !== n2 && f(t2, "invalid edSk length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_sk_to_curve25519(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function mr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "privateKey"); + var _2, n2 = 0 | r2._crypto_sign_secretkeybytes(); + e3.length !== n2 && f(t2, "invalid privateKey length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_sign_publickeybytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_sk_to_pk(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function Er(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "privateKey"); + var _2, n2 = 0 | r2._crypto_sign_secretkeybytes(); + e3.length !== n2 && f(t2, "invalid privateKey length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_sign_seedbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_sk_to_seed(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function xr(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"), a3 = E(_2, a3, "privateKey"); + var n2, s2 = 0 | r2._crypto_sign_secretkeybytes(); + a3.length !== s2 && f(_2, "invalid privateKey length"), n2 = d(a3), _2.push(n2); + var c2 = new u(0 | r2._crypto_sign_bytes()), h2 = c2.address; + if (_2.push(h2), !(0 | r2._crypto_sign_final_create(e3, h2, null, n2))) { + var o2 = (r2._free(e3), y(c2, t2)); + return g(_2), o2; + } + b(_2, "invalid usage"); + } + function kr(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "state_address"), a3 = E(n2, a3, "signature"); + var s2, c2 = 0 | r2._crypto_sign_bytes(); + a3.length !== c2 && f(n2, "invalid signature length"), s2 = d(a3), n2.push(s2), t2 = E(n2, t2, "publicKey"); + var h2, o2 = 0 | r2._crypto_sign_publickeybytes(); + t2.length !== o2 && f(n2, "invalid publicKey length"), h2 = d(t2), n2.push(h2); + var p2 = !(0 | r2._crypto_sign_final_verify(e3, s2, h2)); + return g(n2), p2; + } + function Sr(e3) { + var a3 = []; + l(e3); + var t2 = new u(208).address; + if (!(0 | r2._crypto_sign_init(t2))) { + var _2 = t2; + return g(a3), _2; + } + b(a3, "internal error"); + } + function Tr(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_sign_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_sign_secretkeybytes()), s2 = n2.address; + if (a3.push(s2), !(0 | r2._crypto_sign_keypair(_2, s2))) { + var c2 = { publicKey: y(t2, e3), privateKey: y(n2, e3), keyType: "ed25519" }; + return g(a3), c2; + } + b(a3, "internal error"); + } + function wr(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "signedMessage"); + var n2, s2 = r2._crypto_sign_bytes(), c2 = e3.length; + c2 < s2 && f(_2, "signedMessage is too short"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "publicKey"); + var h2, o2 = 0 | r2._crypto_sign_publickeybytes(); + a3.length !== o2 && f(_2, "invalid publicKey length"), h2 = d(a3), _2.push(h2); + var p2 = new u(c2 - r2._crypto_sign_bytes() | 0), i2 = p2.address; + if (_2.push(i2), !(0 | r2._crypto_sign_open(i2, null, n2, c2, 0, h2))) { + var v2 = y(p2, t2); + return g(_2), v2; + } + b(_2, "incorrect signature for the given public key"); + } + function Yr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_sign_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_sign_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_sign_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_sign_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "ed25519" }; + return g(t2), p2; + } + b(t2, "invalid usage"); + } + function Br(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_sign_update(e3, n2, s2, 0) && b(_2, "invalid usage"), g(_2); + } + function Ar(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "signature"); + var n2, s2 = 0 | r2._crypto_sign_bytes(); + e3.length !== s2 && f(_2, "invalid signature length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "publicKey"); + var o2, p2 = 0 | r2._crypto_sign_publickeybytes(); + t2.length !== p2 && f(_2, "invalid publicKey length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_sign_verify_detached(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function Mr(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "outLength"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(n2, "outLength must be an unsigned integer"), a3 = E(n2, a3, "key"); + var s2, c2 = 0 | r2._crypto_stream_chacha20_keybytes(); + a3.length !== c2 && f(n2, "invalid key length"), s2 = d(a3), n2.push(s2), t2 = E(n2, t2, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_chacha20_noncebytes(); + t2.length !== o2 && f(n2, "invalid nonce length"), h2 = d(t2), n2.push(h2); + var p2 = new u(0 | e3), i2 = p2.address; + n2.push(i2), r2._crypto_stream_chacha20(i2, e3, 0, h2, s2); + var v2 = y(p2, _2); + return g(n2), v2; + } + function Ir(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "input_message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_chacha20_ietf_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_stream_chacha20_ietf_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + if (n2.push(m2), 0 === r2._crypto_stream_chacha20_ietf_xor(m2, s2, c2, 0, h2, p2)) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Kr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "input_message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_stream_chacha20_ietf_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), m(s2, t2, "nonce_increment"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "nonce_increment must be an unsigned integer"), _2 = E(s2, _2, "key"); + var i2, v2 = 0 | r2._crypto_stream_chacha20_ietf_keybytes(); + _2.length !== v2 && f(s2, "invalid key length"), i2 = d(_2), s2.push(i2); + var x2 = new u(0 | h2), k2 = x2.address; + if (s2.push(k2), 0 === r2._crypto_stream_chacha20_ietf_xor_ic(k2, c2, h2, 0, o2, t2, i2)) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function Nr(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_stream_chacha20_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_stream_chacha20_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Lr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "input_message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_chacha20_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_stream_chacha20_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + if (n2.push(m2), 0 === r2._crypto_stream_chacha20_xor(m2, s2, c2, 0, h2, p2)) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Or(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "input_message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_stream_chacha20_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), m(s2, t2, "nonce_increment"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "nonce_increment must be an unsigned integer"), _2 = E(s2, _2, "key"); + var i2, v2 = 0 | r2._crypto_stream_chacha20_keybytes(); + _2.length !== v2 && f(s2, "invalid key length"), i2 = d(_2), s2.push(i2); + var x2 = new u(0 | h2), k2 = x2.address; + if (s2.push(k2), 0 === r2._crypto_stream_chacha20_xor_ic(k2, c2, h2, 0, o2, t2, 0, i2)) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function Ur(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_stream_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_stream_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Cr(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_stream_xchacha20_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_stream_xchacha20_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Pr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "input_message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_xchacha20_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_stream_xchacha20_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + if (n2.push(m2), 0 === r2._crypto_stream_xchacha20_xor(m2, s2, c2, 0, h2, p2)) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Rr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "input_message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_stream_xchacha20_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), m(s2, t2, "nonce_increment"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "nonce_increment must be an unsigned integer"), _2 = E(s2, _2, "key"); + var i2, v2 = 0 | r2._crypto_stream_xchacha20_keybytes(); + _2.length !== v2 && f(s2, "invalid key length"), i2 = d(_2), s2.push(i2); + var x2 = new u(0 | h2), k2 = x2.address; + if (s2.push(k2), 0 === r2._crypto_stream_xchacha20_xor_ic(k2, c2, h2, 0, o2, t2, 0, i2)) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function Xr(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "length"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(t2, "length must be an unsigned integer"); + var _2 = new u(0 | e3), n2 = _2.address; + t2.push(n2), r2._randombytes_buf(n2, e3); + var s2 = y(_2, a3); + return g(t2), s2; + } + function Gr(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "length"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(_2, "length must be an unsigned integer"), a3 = E(_2, a3, "seed"); + var n2, s2 = 0 | r2._randombytes_seedbytes(); + a3.length !== s2 && f(_2, "invalid seed length"), n2 = d(a3), _2.push(n2); + var c2 = new u(0 | e3), h2 = c2.address; + _2.push(h2), r2._randombytes_buf_deterministic(h2, e3, n2); + var o2 = y(c2, t2); + return g(_2), o2; + } + function Dr(e3) { + l(e3), r2._randombytes_close(); + } + function Fr(e3) { + l(e3); + var a3 = r2._randombytes_random() >>> 0; + return g([]), a3; + } + function Vr(e3, a3) { + var t2 = []; + l(a3); + for (var _2 = r2._malloc(24), n2 = 0; n2 < 6; n2++) r2.setValue(_2 + 4 * n2, r2.Runtime.addFunction(e3[["implementation_name", "random", "stir", "uniform", "buf", "close"][n2]]), "i32"); + 0 | r2._randombytes_set_implementation(_2) && b(t2, "unsupported implementation"), g(t2); + } + function Hr(e3) { + l(e3), r2._randombytes_stir(); + } + function Wr(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "upper_bound"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(t2, "upper_bound must be an unsigned integer"); + var _2 = r2._randombytes_uniform(e3) >>> 0; + return g(t2), _2; + } + function qr() { + var e3 = r2._sodium_version_string(), a3 = r2.UTF8ToString(e3); + return g([]), a3; + } + return u.prototype.to_Uint8Array = function() { + var e3 = new Uint8Array(this.length); + return e3.set(r2.HEAPU8.subarray(this.address, this.address + this.length)), e3; + }, e2.add = function(e3, a3) { + if (!(e3 instanceof Uint8Array && a3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can added"); + var r3 = e3.length, t2 = 0, _2 = 0; + if (a3.length != e3.length) throw new TypeError("Arguments must have the same length"); + for (_2 = 0; _2 < r3; _2++) t2 >>= 8, t2 += e3[_2] + a3[_2], e3[_2] = 255 & t2; + }, e2.base64_variants = h, e2.compare = function(e3, a3) { + if (!(e3 instanceof Uint8Array && a3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be compared"); + if (e3.length !== a3.length) throw new TypeError("Only instances of identical length can be compared"); + for (var r3 = 0, t2 = 1, _2 = e3.length; _2-- > 0; ) r3 |= a3[_2] - e3[_2] >> 8 & t2, t2 &= (a3[_2] ^ e3[_2]) - 1 >> 8; + return r3 + r3 + t2 - 1; + }, e2.from_base64 = function(e3, a3) { + a3 = o(a3); + var t2, _2 = [], n2 = new u(3 * (e3 = E(_2, e3, "input")).length / 4), s2 = d(e3), c2 = v(4), h2 = v(4); + return _2.push(s2), _2.push(n2.address), _2.push(n2.result_bin_len_p), _2.push(n2.b64_end_p), 0 !== r2._sodium_base642bin(n2.address, n2.length, s2, e3.length, 0, c2, h2, a3) && b(_2, "invalid input"), r2.getValue(h2, "i32") - s2 !== e3.length && b(_2, "incomplete input"), n2.length = r2.getValue(c2, "i32"), t2 = n2.to_Uint8Array(), g(_2), t2; + }, e2.from_hex = function(e3) { + var a3, t2 = [], _2 = new u((e3 = E(t2, e3, "input")).length / 2), n2 = d(e3), s2 = v(4); + return t2.push(n2), t2.push(_2.address), t2.push(_2.hex_end_p), 0 !== r2._sodium_hex2bin(_2.address, _2.length, n2, e3.length, 0, 0, s2) && b(t2, "invalid input"), r2.getValue(s2, "i32") - n2 !== e3.length && b(t2, "incomplete input"), a3 = _2.to_Uint8Array(), g(t2), a3; + }, e2.from_string = n, e2.increment = function(e3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be incremented"); + for (var a3 = 256, r3 = 0, t2 = e3.length; r3 < t2; r3++) a3 >>= 8, a3 += e3[r3], e3[r3] = 255 & a3; + }, e2.is_zero = function(e3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be checked"); + for (var a3 = 0, r3 = 0, t2 = e3.length; r3 < t2; r3++) a3 |= e3[r3]; + return 0 === a3; + }, e2.libsodium = a2, e2.memcmp = function(e3, a3) { + if (!(e3 instanceof Uint8Array && a3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be compared"); + if (e3.length !== a3.length) throw new TypeError("Only instances of identical length can be compared"); + for (var r3 = 0, t2 = 0, _2 = e3.length; t2 < _2; t2++) r3 |= e3[t2] ^ a3[t2]; + return 0 === r3; + }, e2.memzero = function(e3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be wiped"); + for (var a3 = 0, r3 = e3.length; a3 < r3; a3++) e3[a3] = 0; + }, e2.output_formats = function() { + return ["uint8array", "text", "hex", "base64"]; + }, e2.pad = function(e3, a3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("buffer must be a Uint8Array"); + if ((a3 |= 0) <= 0) throw new Error("block size must be > 0"); + var t2, _2 = [], n2 = v(4), s2 = 1, c2 = 0, h2 = 0 | e3.length, o2 = new u(h2 + a3); + _2.push(n2), _2.push(o2.address); + for (var p2 = o2.address, y2 = o2.address + h2 + a3; p2 < y2; p2++) r2.HEAPU8[p2] = e3[c2], c2 += s2 = 1 & ~((65535 & ((h2 -= s2) >>> 48 | h2 >>> 32 | h2 >>> 16 | h2)) - 1 >> 16); + return 0 !== r2._sodium_pad(n2, o2.address, e3.length, a3, o2.length) && b(_2, "internal error"), o2.length = r2.getValue(n2, "i32"), t2 = o2.to_Uint8Array(), g(_2), t2; + }, e2.unpad = function(e3, a3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("buffer must be a Uint8Array"); + if ((a3 |= 0) <= 0) throw new Error("block size must be > 0"); + var t2 = [], _2 = d(e3), n2 = v(4); + return t2.push(_2), t2.push(n2), 0 !== r2._sodium_unpad(n2, _2, e3.length, a3) && b(t2, "unsupported/invalid padding"), e3 = (e3 = new Uint8Array(e3)).subarray(0, r2.getValue(n2, "i32")), g(t2), e3; + }, e2.ready = _, e2.symbols = function() { + return Object.keys(e2).sort(); + }, e2.to_base64 = p, e2.to_hex = c, e2.to_string = s, e2; + } + var r = "object" == typeof e.sodium && "function" == typeof e.sodium.onload ? e.sodium.onload : null; + "function" == typeof define && define.amd ? define(["exports", "libsodium"], a) : "object" == typeof exports2 && "string" != typeof exports2.nodeName ? a(exports2, require_libsodium()) : e.sodium = a(e.commonJsStrict = {}, e.libsodium), r && e.sodium.ready.then(function() { + r(e.sodium); + }); + }(exports2); + } +}); + +// node_modules/ts-dedent/dist/index.js +var require_dist = __commonJS({ + "node_modules/ts-dedent/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.dedent = void 0; + function dedent(templ) { + var values = []; + for (var _i = 1; _i < arguments.length; _i++) { + values[_i - 1] = arguments[_i]; + } + var strings = Array.from(typeof templ === "string" ? [templ] : templ); + strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, ""); + var indentLengths = strings.reduce(function(arr, str) { + var matches = str.match(/\n([\t ]+|(?!\s).)/g); + if (matches) { + return arr.concat(matches.map(function(match) { + var _a2, _b; + return (_b = (_a2 = match.match(/[\t ]/g)) === null || _a2 === void 0 ? void 0 : _a2.length) !== null && _b !== void 0 ? _b : 0; + })); + } + return arr; + }, []); + if (indentLengths.length) { + var pattern_1 = new RegExp("\n[ ]{" + Math.min.apply(Math, indentLengths) + "}", "g"); + strings = strings.map(function(str) { + return str.replace(pattern_1, "\n"); + }); + } + strings[0] = strings[0].replace(/^\r?\n/, ""); + var string = strings[0]; + values.forEach(function(value, i) { + var endentations = string.match(/(?:^|\n)( *)$/); + var endentation = endentations ? endentations[1] : ""; + var indentedValue = value; + if (typeof value === "string" && value.includes("\n")) { + indentedValue = String(value).split("\n").map(function(str, i2) { + return i2 === 0 ? str : "" + endentation + str; + }).join("\n"); + } + string += indentedValue + strings[i + 1]; + }); + return string; + } + exports2.dedent = dedent; + exports2.default = dedent; + } +}); + +// src/merge.ts +var import_core = __toESM(require_core()); + +// node_modules/@stainless-api/sdk/internal/tslib.mjs +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +// node_modules/@stainless-api/sdk/internal/utils/uuid.mjs +var uuid4 = function() { + const { crypto } = globalThis; + if (crypto?.randomUUID) { + uuid4 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16)); +}; + +// node_modules/@stainless-api/sdk/internal/errors.mjs +function isAbortError(err) { + return typeof err === "object" && err !== null && // Spec-compliant fetch implementations + ("name" in err && err.name === "AbortError" || // Expo fetch + "message" in err && String(err.message).includes("FetchRequestCanceledException")); +} +var castToError = (err) => { + if (err instanceof Error) + return err; + if (typeof err === "object" && err !== null) { + try { + if (Object.prototype.toString.call(err) === "[object Error]") { + const error = new Error(err.message, err.cause ? { cause: err.cause } : {}); + if (err.stack) + error.stack = err.stack; + if (err.cause && !error.cause) + error.cause = err.cause; + if (err.name) + error.name = err.name; + return error; + } + } catch { + } + try { + return new Error(JSON.stringify(err)); + } catch { + } + } + return new Error(err); +}; + +// node_modules/@stainless-api/sdk/core/error.mjs +var StainlessError = class extends Error { +}; +var APIError = class _APIError extends StainlessError { + constructor(status, error, message, headers) { + super(`${_APIError.makeMessage(status, error, message)}`); + this.status = status; + this.headers = headers; + this.error = error; + } + static makeMessage(status, error, message) { + const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message; + if (status && msg) { + return `${status} ${msg}`; + } + if (status) { + return `${status} status code (no body)`; + } + if (msg) { + return msg; + } + return "(no status code or body)"; + } + static generate(status, errorResponse, message, headers) { + if (!status || !headers) { + return new APIConnectionError({ message, cause: castToError(errorResponse) }); + } + const error = errorResponse; + if (status === 400) { + return new BadRequestError(status, error, message, headers); + } + if (status === 401) { + return new AuthenticationError(status, error, message, headers); + } + if (status === 403) { + return new PermissionDeniedError(status, error, message, headers); + } + if (status === 404) { + return new NotFoundError(status, error, message, headers); + } + if (status === 409) { + return new ConflictError(status, error, message, headers); + } + if (status === 422) { + return new UnprocessableEntityError(status, error, message, headers); + } + if (status === 429) { + return new RateLimitError(status, error, message, headers); + } + if (status >= 500) { + return new InternalServerError(status, error, message, headers); + } + return new _APIError(status, error, message, headers); + } +}; +var APIUserAbortError = class extends APIError { + constructor({ message } = {}) { + super(void 0, void 0, message || "Request was aborted.", void 0); + } +}; +var APIConnectionError = class extends APIError { + constructor({ message, cause }) { + super(void 0, void 0, message || "Connection error.", void 0); + if (cause) + this.cause = cause; + } +}; +var APIConnectionTimeoutError = class extends APIConnectionError { + constructor({ message } = {}) { + super({ message: message ?? "Request timed out." }); + } +}; +var BadRequestError = class extends APIError { +}; +var AuthenticationError = class extends APIError { +}; +var PermissionDeniedError = class extends APIError { +}; +var NotFoundError = class extends APIError { +}; +var ConflictError = class extends APIError { +}; +var UnprocessableEntityError = class extends APIError { +}; +var RateLimitError = class extends APIError { +}; +var InternalServerError = class extends APIError { +}; + +// node_modules/@stainless-api/sdk/internal/utils/values.mjs +var startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i; +var isAbsoluteURL = (url) => { + return startsWithSchemeRegexp.test(url); +}; +var isArray = (val) => (isArray = Array.isArray, isArray(val)); +var isReadonlyArray = isArray; +function maybeObj(x) { + if (typeof x !== "object") { + return {}; + } + return x ?? {}; +} +function isEmptyObj(obj) { + if (!obj) + return true; + for (const _k in obj) + return false; + return true; +} +function hasOwn(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} +var validatePositiveInteger = (name, n) => { + if (typeof n !== "number" || !Number.isInteger(n)) { + throw new StainlessError(`${name} must be an integer`); + } + if (n < 0) { + throw new StainlessError(`${name} must be a positive integer`); + } + return n; +}; +var safeJSON = (text) => { + try { + return JSON.parse(text); + } catch (err) { + return void 0; + } +}; + +// node_modules/@stainless-api/sdk/internal/utils/sleep.mjs +var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); + +// node_modules/@stainless-api/sdk/version.mjs +var VERSION = "0.1.0-alpha.11"; + +// node_modules/@stainless-api/sdk/internal/detect-platform.mjs +function getDetectedPlatform() { + if (typeof Deno !== "undefined" && Deno.build != null) { + return "deno"; + } + if (typeof EdgeRuntime !== "undefined") { + return "edge"; + } + if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") { + return "node"; + } + return "unknown"; +} +var getPlatformProperties = () => { + const detectedPlatform = getDetectedPlatform(); + if (detectedPlatform === "deno") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(Deno.build.os), + "X-Stainless-Arch": normalizeArch(Deno.build.arch), + "X-Stainless-Runtime": "deno", + "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown" + }; + } + if (typeof EdgeRuntime !== "undefined") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": `other:${EdgeRuntime}`, + "X-Stainless-Runtime": "edge", + "X-Stainless-Runtime-Version": globalThis.process.version + }; + } + if (detectedPlatform === "node") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"), + "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"), + "X-Stainless-Runtime": "node", + "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown" + }; + } + const browserInfo = getBrowserInfo(); + if (browserInfo) { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": `browser:${browserInfo.browser}`, + "X-Stainless-Runtime-Version": browserInfo.version + }; + } + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": "unknown", + "X-Stainless-Runtime-Version": "unknown" + }; +}; +function getBrowserInfo() { + if (typeof navigator === "undefined" || !navigator) { + return null; + } + const browserPatterns = [ + { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ } + ]; + for (const { key, pattern } of browserPatterns) { + const match = pattern.exec(navigator.userAgent); + if (match) { + const major = match[1] || 0; + const minor = match[2] || 0; + const patch = match[3] || 0; + return { browser: key, version: `${major}.${minor}.${patch}` }; + } + } + return null; +} +var normalizeArch = (arch) => { + if (arch === "x32") + return "x32"; + if (arch === "x86_64" || arch === "x64") + return "x64"; + if (arch === "arm") + return "arm"; + if (arch === "aarch64" || arch === "arm64") + return "arm64"; + if (arch) + return `other:${arch}`; + return "unknown"; +}; +var normalizePlatform = (platform) => { + platform = platform.toLowerCase(); + if (platform.includes("ios")) + return "iOS"; + if (platform === "android") + return "Android"; + if (platform === "darwin") + return "MacOS"; + if (platform === "win32") + return "Windows"; + if (platform === "freebsd") + return "FreeBSD"; + if (platform === "openbsd") + return "OpenBSD"; + if (platform === "linux") + return "Linux"; + if (platform) + return `Other:${platform}`; + return "Unknown"; +}; +var _platformHeaders; +var getPlatformHeaders = () => { + return _platformHeaders ?? (_platformHeaders = getPlatformProperties()); +}; + +// node_modules/@stainless-api/sdk/internal/shims.mjs +function getDefaultFetch() { + if (typeof fetch !== "undefined") { + return fetch; + } + throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Stainless({ fetch })` or polyfill the global, `globalThis.fetch = fetch`"); +} +function makeReadableStream(...args) { + const ReadableStream = globalThis.ReadableStream; + if (typeof ReadableStream === "undefined") { + throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`"); + } + return new ReadableStream(...args); +} +function ReadableStreamFrom(iterable) { + let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); + return makeReadableStream({ + start() { + }, + async pull(controller) { + const { done, value } = await iter.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel() { + await iter.return?.(); + } + }); +} +async function CancelReadableStream(stream) { + if (stream === null || typeof stream !== "object") + return; + if (stream[Symbol.asyncIterator]) { + await stream[Symbol.asyncIterator]().return?.(); + return; + } + const reader = stream.getReader(); + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; +} + +// node_modules/@stainless-api/sdk/internal/request-options.mjs +var FallbackEncoder = ({ headers, body }) => { + return { + bodyHeaders: { + "content-type": "application/json" + }, + body: JSON.stringify(body) + }; +}; + +// node_modules/@stainless-api/sdk/internal/qs/formats.mjs +var default_format = "RFC3986"; +var default_formatter = (v) => String(v); +var formatters = { + RFC1738: (v) => String(v).replace(/%20/g, "+"), + RFC3986: default_formatter +}; +var RFC1738 = "RFC1738"; + +// node_modules/@stainless-api/sdk/internal/qs/utils.mjs +var has = (obj, key) => (has = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), has(obj, key)); +var hex_table = /* @__PURE__ */ (() => { + const array = []; + for (let i = 0; i < 256; ++i) { + array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + } + return array; +})(); +var limit = 1024; +var encode = (str, _defaultEncoder, charset, _kind, format) => { + if (str.length === 0) { + return str; + } + let string = str; + if (typeof str === "symbol") { + string = Symbol.prototype.toString.call(str); + } else if (typeof str !== "string") { + string = String(str); + } + if (charset === "iso-8859-1") { + return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) { + return "%26%23" + parseInt($0.slice(2), 16) + "%3B"; + }); + } + let out = ""; + for (let j = 0; j < string.length; j += limit) { + const segment = string.length >= limit ? string.slice(j, j + limit) : string; + const arr = []; + for (let i = 0; i < segment.length; ++i) { + let c = segment.charCodeAt(i); + if (c === 45 || // - + c === 46 || // . + c === 95 || // _ + c === 126 || // ~ + c >= 48 && c <= 57 || // 0-9 + c >= 65 && c <= 90 || // a-z + c >= 97 && c <= 122 || // A-Z + format === RFC1738 && (c === 40 || c === 41)) { + arr[arr.length] = segment.charAt(i); + continue; + } + if (c < 128) { + arr[arr.length] = hex_table[c]; + continue; + } + if (c < 2048) { + arr[arr.length] = hex_table[192 | c >> 6] + hex_table[128 | c & 63]; + continue; + } + if (c < 55296 || c >= 57344) { + arr[arr.length] = hex_table[224 | c >> 12] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + continue; + } + i += 1; + c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023); + arr[arr.length] = hex_table[240 | c >> 18] + hex_table[128 | c >> 12 & 63] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + } + out += arr.join(""); + } + return out; +}; +function is_buffer(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); +} +function maybe_map(val, fn) { + if (isArray(val)) { + const mapped = []; + for (let i = 0; i < val.length; i += 1) { + mapped.push(fn(val[i])); + } + return mapped; + } + return fn(val); +} + +// node_modules/@stainless-api/sdk/internal/qs/stringify.mjs +var array_prefix_generators = { + brackets(prefix) { + return String(prefix) + "[]"; + }, + comma: "comma", + indices(prefix, key) { + return String(prefix) + "[" + key + "]"; + }, + repeat(prefix) { + return String(prefix); + } +}; +var push_to_array = function(arr, value_or_array) { + Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]); +}; +var toISOString; +var defaults = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: encode, + encodeValuesOnly: false, + format: default_format, + formatter: default_formatter, + /** @deprecated */ + indices: false, + serializeDate(date) { + return (toISOString ?? (toISOString = Function.prototype.call.bind(Date.prototype.toISOString)))(date); + }, + skipNulls: false, + strictNullHandling: false +}; +function is_non_nullish_primitive(v) { + return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint"; +} +var sentinel = {}; +function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { + let obj = object; + let tmp_sc = sideChannel; + let step = 0; + let find_flag = false; + while ((tmp_sc = tmp_sc.get(sentinel)) !== void 0 && !find_flag) { + const pos = tmp_sc.get(object); + step += 1; + if (typeof pos !== "undefined") { + if (pos === step) { + throw new RangeError("Cyclic object value"); + } else { + find_flag = true; + } + } + if (typeof tmp_sc.get(sentinel) === "undefined") { + step = 0; + } + } + if (typeof filter === "function") { + obj = filter(prefix, obj); + } else if (obj instanceof Date) { + obj = serializeDate?.(obj); + } else if (generateArrayPrefix === "comma" && isArray(obj)) { + obj = maybe_map(obj, function(value) { + if (value instanceof Date) { + return serializeDate?.(value); + } + return value; + }); + } + if (obj === null) { + if (strictNullHandling) { + return encoder && !encodeValuesOnly ? ( + // @ts-expect-error + encoder(prefix, defaults.encoder, charset, "key", format) + ) : prefix; + } + obj = ""; + } + if (is_non_nullish_primitive(obj) || is_buffer(obj)) { + if (encoder) { + const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format); + return [ + formatter?.(key_value) + "=" + // @ts-expect-error + formatter?.(encoder(obj, defaults.encoder, charset, "value", format)) + ]; + } + return [formatter?.(prefix) + "=" + formatter?.(String(obj))]; + } + const values = []; + if (typeof obj === "undefined") { + return values; + } + let obj_keys; + if (generateArrayPrefix === "comma" && isArray(obj)) { + if (encodeValuesOnly && encoder) { + obj = maybe_map(obj, encoder); + } + obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray(filter)) { + obj_keys = filter; + } else { + const keys = Object.keys(obj); + obj_keys = sort ? keys.sort(sort) : keys; + } + const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + const adjusted_prefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix; + if (allowEmptyArrays && isArray(obj) && obj.length === 0) { + return adjusted_prefix + "[]"; + } + for (let j = 0; j < obj_keys.length; ++j) { + const key = obj_keys[j]; + const value = ( + // @ts-ignore + typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key] + ); + if (skipNulls && value === null) { + continue; + } + const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key; + const key_prefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]"); + sideChannel.set(object, step); + const valueSideChannel = /* @__PURE__ */ new WeakMap(); + valueSideChannel.set(sentinel, sideChannel); + push_to_array(values, inner_stringify( + value, + key_prefix, + generateArrayPrefix, + commaRoundTrip, + allowEmptyArrays, + strictNullHandling, + skipNulls, + encodeDotInKeys, + // @ts-ignore + generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, + filter, + sort, + allowDots, + serializeDate, + format, + formatter, + encodeValuesOnly, + charset, + valueSideChannel + )); + } + return values; +} +function normalize_stringify_options(opts = defaults) { + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") { + throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") { + throw new TypeError("Encoder has to be a function."); + } + const charset = opts.charset || defaults.charset; + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + let format = default_format; + if (typeof opts.format !== "undefined") { + if (!has(formatters, opts.format)) { + throw new TypeError("Unknown format option provided."); + } + format = opts.format; + } + const formatter = formatters[format]; + let filter = defaults.filter; + if (typeof opts.filter === "function" || isArray(opts.filter)) { + filter = opts.filter; + } + let arrayFormat; + if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) { + arrayFormat = opts.arrayFormat; + } else if ("indices" in opts) { + arrayFormat = opts.indices ? "indices" : "repeat"; + } else { + arrayFormat = defaults.arrayFormat; + } + if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") { + throw new TypeError("`commaRoundTrip` must be a boolean, or absent"); + } + const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix, + // @ts-ignore + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays, + arrayFormat, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel, + commaRoundTrip: !!opts.commaRoundTrip, + delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter, + encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode, + encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys, + encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder, + encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly, + filter, + format, + formatter, + serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate, + skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls, + // @ts-ignore + sort: typeof opts.sort === "function" ? opts.sort : null, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling + }; +} +function stringify(object, opts = {}) { + let obj = object; + const options = normalize_stringify_options(opts); + let obj_keys; + let filter; + if (typeof options.filter === "function") { + filter = options.filter; + obj = filter("", obj); + } else if (isArray(options.filter)) { + filter = options.filter; + obj_keys = filter; + } + const keys = []; + if (typeof obj !== "object" || obj === null) { + return ""; + } + const generateArrayPrefix = array_prefix_generators[options.arrayFormat]; + const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip; + if (!obj_keys) { + obj_keys = Object.keys(obj); + } + if (options.sort) { + obj_keys.sort(options.sort); + } + const sideChannel = /* @__PURE__ */ new WeakMap(); + for (let i = 0; i < obj_keys.length; ++i) { + const key = obj_keys[i]; + if (options.skipNulls && obj[key] === null) { + continue; + } + push_to_array(keys, inner_stringify( + obj[key], + key, + // @ts-expect-error + generateArrayPrefix, + commaRoundTrip, + options.allowEmptyArrays, + options.strictNullHandling, + options.skipNulls, + options.encodeDotInKeys, + options.encode ? options.encoder : null, + options.filter, + options.sort, + options.allowDots, + options.serializeDate, + options.format, + options.formatter, + options.encodeValuesOnly, + options.charset, + sideChannel + )); + } + const joined = keys.join(options.delimiter); + let prefix = options.addQueryPrefix === true ? "?" : ""; + if (options.charsetSentinel) { + if (options.charset === "iso-8859-1") { + prefix += "utf8=%26%2310003%3B&"; + } else { + prefix += "utf8=%E2%9C%93&"; + } + } + return joined.length > 0 ? prefix + joined : ""; +} + +// node_modules/@stainless-api/sdk/internal/utils/log.mjs +var levelNumbers = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500 +}; +var parseLogLevel = (maybeLevel, sourceName, client) => { + if (!maybeLevel) { + return void 0; + } + if (hasOwn(levelNumbers, maybeLevel)) { + return maybeLevel; + } + loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`); + return void 0; +}; +function noop() { +} +function makeLogFn(fnLevel, logger, logLevel) { + if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) { + return noop; + } else { + return logger[fnLevel].bind(logger); + } +} +var noopLogger = { + error: noop, + warn: noop, + info: noop, + debug: noop +}; +var cachedLoggers = /* @__PURE__ */ new WeakMap(); +function loggerFor(client) { + const logger = client.logger; + const logLevel = client.logLevel ?? "off"; + if (!logger) { + return noopLogger; + } + const cachedLogger = cachedLoggers.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) { + return cachedLogger[1]; + } + const levelLogger = { + error: makeLogFn("error", logger, logLevel), + warn: makeLogFn("warn", logger, logLevel), + info: makeLogFn("info", logger, logLevel), + debug: makeLogFn("debug", logger, logLevel) + }; + cachedLoggers.set(logger, [logLevel, levelLogger]); + return levelLogger; +} +var formatRequestDetails = (details) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options["headers"]; + } + if (details.headers) { + details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [ + name, + name.toLowerCase() === "authorization" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value + ])); + } + if ("retryOfRequestLogID" in details) { + if (details.retryOfRequestLogID) { + details.retryOf = details.retryOfRequestLogID; + } + delete details.retryOfRequestLogID; + } + return details; +}; + +// node_modules/@stainless-api/sdk/internal/parse.mjs +async function defaultParseResponse(client, props) { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + const body = await (async () => { + if (response.status === 204) { + return null; + } + if (props.options.__binaryResponse) { + return response; + } + const contentType = response.headers.get("content-type"); + const mediaType = contentType?.split(";")[0]?.trim(); + const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json"); + if (isJSON) { + const json = await response.json(); + return json; + } + const text = await response.text(); + return text; + })(); + loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body, + durationMs: Date.now() - startTime + })); + return body; +} + +// node_modules/@stainless-api/sdk/core/api-promise.mjs +var _APIPromise_client; +var APIPromise = class _APIPromise extends Promise { + constructor(client, responsePromise, parseResponse = defaultParseResponse) { + super((resolve) => { + resolve(null); + }); + this.responsePromise = responsePromise; + this.parseResponse = parseResponse; + _APIPromise_client.set(this, void 0); + __classPrivateFieldSet(this, _APIPromise_client, client, "f"); + } + _thenUnwrap(transform) { + return new _APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props)); + } + /** + * Gets the raw `Response` instance instead of parsing the response + * data. + * + * If you want to parse the response body but still get the `Response` + * instance, you can use {@link withResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + asResponse() { + return this.responsePromise.then((p) => p.response); + } + /** + * Gets the parsed response data and the raw `Response` instance. + * + * If you just want to get the raw `Response` instance without parsing it, + * you can use {@link asResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + async withResponse() { + const [data, response] = await Promise.all([this.parse(), this.asResponse()]); + return { data, response }; + } + parse() { + if (!this.parsedPromise) { + this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet(this, _APIPromise_client, "f"), data)); + } + return this.parsedPromise; + } + then(onfulfilled, onrejected) { + return this.parse().then(onfulfilled, onrejected); + } + catch(onrejected) { + return this.parse().catch(onrejected); + } + finally(onfinally) { + return this.parse().finally(onfinally); + } +}; +_APIPromise_client = /* @__PURE__ */ new WeakMap(); + +// node_modules/@stainless-api/sdk/core/pagination.mjs +var _AbstractPage_client; +var AbstractPage = class { + constructor(client, response, body, options) { + _AbstractPage_client.set(this, void 0); + __classPrivateFieldSet(this, _AbstractPage_client, client, "f"); + this.options = options; + this.response = response; + this.body = body; + } + hasNextPage() { + const items = this.getPaginatedItems(); + if (!items.length) + return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + const nextOptions = this.nextPageRequestOptions(); + if (!nextOptions) { + throw new StainlessError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); + } + return await __classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions); + } + async *iterPages() { + let page = this; + yield page; + while (page.hasNextPage()) { + page = await page.getNextPage(); + yield page; + } + } + async *[(_AbstractPage_client = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (const page of this.iterPages()) { + for (const item of page.getPaginatedItems()) { + yield item; + } + } + } +}; +var PagePromise = class extends APIPromise { + constructor(client, request, Page2) { + super(client, request, async (client2, props) => new Page2(client2, props.response, await defaultParseResponse(client2, props), props.options)); + } + /** + * Allow auto-paginating iteration on an unawaited list call, eg: + * + * for await (const item of client.items.list()) { + * console.log(item) + * } + */ + async *[Symbol.asyncIterator]() { + const page = await this; + for await (const item of page) { + yield item; + } + } +}; +var Page = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.next_cursor = body.next_cursor || ""; + } + getPaginatedItems() { + return this.data ?? []; + } + nextPageRequestOptions() { + const cursor = this.next_cursor; + if (!cursor) { + return null; + } + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + cursor + } + }; + } +}; + +// node_modules/@stainless-api/sdk/internal/uploads.mjs +var checkFileSupport = () => { + if (typeof File === "undefined") { + const { process: process2 } = globalThis; + const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20; + throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : "")); + } +}; +function makeFile(fileBits, fileName, options) { + checkFileSupport(); + return new File(fileBits, fileName ?? "unknown_file", options); +} +function getName(value) { + return (typeof value === "object" && value !== null && ("name" in value && value.name && String(value.name) || "url" in value && value.url && String(value.url) || "filename" in value && value.filename && String(value.filename) || "path" in value && value.path && String(value.path)) || "").split(/[\\/]/).pop() || void 0; +} +var isAsyncIterable = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function"; + +// node_modules/@stainless-api/sdk/internal/to-file.mjs +var isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function"; +var isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value); +var isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function"; +async function toFile(value, name, options) { + checkFileSupport(); + value = await value; + if (isFileLike(value)) { + if (value instanceof File) { + return value; + } + return makeFile([await value.arrayBuffer()], value.name); + } + if (isResponseLike(value)) { + const blob = await value.blob(); + name || (name = new URL(value.url).pathname.split(/[\\/]/).pop()); + return makeFile(await getBytes(blob), name, options); + } + const parts = await getBytes(value); + name || (name = getName(value)); + if (!options?.type) { + const type = parts.find((part) => typeof part === "object" && "type" in part && part.type); + if (typeof type === "string") { + options = { ...options, type }; + } + } + return makeFile(parts, name, options); +} +async function getBytes(value) { + let parts = []; + if (typeof value === "string" || ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc. + value instanceof ArrayBuffer) { + parts.push(value); + } else if (isBlobLike(value)) { + parts.push(value instanceof Blob ? value : await value.arrayBuffer()); + } else if (isAsyncIterable(value)) { + for await (const chunk of value) { + parts.push(...await getBytes(chunk)); + } + } else { + const constructor = value?.constructor?.name; + throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ""}${propsForError(value)}`); + } + return parts; +} +function propsForError(value) { + if (typeof value !== "object" || value === null) + return ""; + const props = Object.getOwnPropertyNames(value); + return `; props: [${props.map((p) => `"${p}"`).join(", ")}]`; +} + +// node_modules/@stainless-api/sdk/core/resource.mjs +var APIResource = class { + constructor(client) { + this._client = client; + } +}; + +// node_modules/@stainless-api/sdk/internal/utils/path.mjs +function encodeURIPath(str) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); +var createPathTagFunction = (pathEncoder = encodeURIPath) => function path3(statics, ...params) { + if (statics.length === 1) + return statics[0]; + let postPath = false; + const invalidSegments = []; + const path4 = statics.reduce((previousValue, currentValue, index) => { + if (/[?#]/.test(currentValue)) { + postPath = true; + } + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value); + if (index !== params.length && (value == null || typeof value === "object" && // handle values from other realms + value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)?.toString)) { + encoded = value + ""; + invalidSegments.push({ + start: previousValue.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter` + }); + } + return previousValue + currentValue + (index === params.length ? "" : encoded); + }, ""); + const pathOnly = path4.split(/[?#]/, 1)[0]; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { + invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can't be safely passed as a path parameter` + }); + } + invalidSegments.sort((a, b) => a.start - b.start); + if (invalidSegments.length > 0) { + let lastEnd = 0; + const underline = invalidSegments.reduce((acc, segment) => { + const spaces = " ".repeat(segment.start - lastEnd); + const arrows = "^".repeat(segment.length); + lastEnd = segment.start + segment.length; + return acc + spaces + arrows; + }, ""); + throw new StainlessError(`Path parameters result in path with invalid segments: +${invalidSegments.map((e) => e.error).join("\n")} +${path4} +${underline}`); + } + return path4; +}; +var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath); + +// node_modules/@stainless-api/sdk/resources/builds/diagnostics.mjs +var Diagnostics = class extends APIResource { + /** + * Get diagnostics for a build + */ + list(buildID, query = {}, options) { + return this._client.getAPIList(path`/v0/builds/${buildID}/diagnostics`, Page, { + query, + ...options + }); + } +}; + +// node_modules/@stainless-api/sdk/resources/builds/target-outputs.mjs +var TargetOutputs = class extends APIResource { + /** + * Download the output of a build target + */ + retrieve(query, options) { + return this._client.get("/v0/build_target_outputs", { query, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/builds/builds.mjs +var Builds = class extends APIResource { + constructor() { + super(...arguments); + this.diagnostics = new Diagnostics(this._client); + this.targetOutputs = new TargetOutputs(this._client); + } + /** + * Create a new build + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds", { body: { project, ...body }, ...options }); + } + /** + * Retrieve a build by ID + */ + retrieve(buildID, options) { + return this._client.get(path`/v0/builds/${buildID}`, options); + } + /** + * List builds for a project + */ + list(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.getAPIList("/v0/builds", Page, { + query: { project, ...query }, + ...options + }); + } + /** + * Creates two builds whose outputs can be compared directly + */ + compare(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds/compare", { body: { project, ...body }, ...options }); + } +}; +Builds.Diagnostics = Diagnostics; +Builds.TargetOutputs = TargetOutputs; + +// node_modules/@stainless-api/sdk/resources/generate.mjs +var Generate = class extends APIResource { + createSpec(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/generate/spec", { body: { project, ...body }, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/orgs.mjs +var Orgs = class extends APIResource { + /** + * Retrieve an organization by name + */ + retrieve(org, options) { + return this._client.get(path`/v0/orgs/${org}`, options); + } + /** + * List organizations the user has access to + */ + list(options) { + return this._client.get("/v0/orgs", options); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/branches.mjs +var Branches = class extends APIResource { + /** + * Create a new branch for a project + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/branches`, { body, ...options }); + } + /** + * Retrieve a project branch + */ + retrieve(branch, params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/branches/${branch}`, options); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/configs.mjs +var Configs = class extends APIResource { + /** + * Retrieve configuration files for a project + */ + retrieve(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/configs`, { query, ...options }); + } + /** + * Generate configuration suggestions based on an OpenAPI spec + */ + guess(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/configs/guess`, { body, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/projects.mjs +var Projects = class extends APIResource { + constructor() { + super(...arguments); + this.branches = new Branches(this._client); + this.configs = new Configs(this._client); + } + /** + * Create a new project + */ + create(body, options) { + return this._client.post("/v0/projects", { body, ...options }); + } + /** + * Retrieve a project by name + */ + retrieve(params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}`, options); + } + /** + * Update a project's properties + */ + update(params = {}, options) { + const { project = this._client.project, ...body } = params ?? {}; + return this._client.patch(path`/v0/projects/${project}`, { body, ...options }); + } + /** + * List projects in an organization, from oldest to newest + */ + list(query = {}, options) { + return this._client.getAPIList("/v0/projects", Page, { query, ...options }); + } +}; +Projects.Branches = Branches; +Projects.Configs = Configs; + +// node_modules/@stainless-api/sdk/internal/headers.mjs +var brand_privateNullableHeaders = /* @__PURE__ */ Symbol("brand.privateNullableHeaders"); +function* iterateHeaders(headers) { + if (!headers) + return; + if (brand_privateNullableHeaders in headers) { + const { values, nulls } = headers; + yield* values.entries(); + for (const name of nulls) { + yield [name, null]; + } + return; + } + let shouldClear = false; + let iter; + if (headers instanceof Headers) { + iter = headers.entries(); + } else if (isReadonlyArray(headers)) { + iter = headers; + } else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== "string") + throw new TypeError("expected header name to be a string"); + const values = isReadonlyArray(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === void 0) + continue; + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} +var buildHeaders = (newHeaders) => { + const targetHeaders = new Headers(); + const nullHeaders = /* @__PURE__ */ new Set(); + for (const headers of newHeaders) { + const seenHeaders = /* @__PURE__ */ new Set(); + for (const [name, value] of iterateHeaders(headers)) { + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(name); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(name); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(name, value); + nullHeaders.delete(lowerName); + } + } + } + return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders }; +}; + +// node_modules/@stainless-api/sdk/internal/utils/env.mjs +var readEnv = (env) => { + if (typeof globalThis.process !== "undefined") { + return globalThis.process.env?.[env]?.trim() ?? void 0; + } + if (typeof globalThis.Deno !== "undefined") { + return globalThis.Deno.env?.get?.(env)?.trim(); + } + return void 0; +}; + +// node_modules/@stainless-api/sdk/lib/unwrap.mjs +async function unwrapFile(value) { + if (value === null) { + return null; + } + if (value.type === "content") { + return value.content; + } + const response = await fetch(value.url); + return response.text(); +} + +// node_modules/@stainless-api/sdk/client.mjs +var _Stainless_instances; +var _a; +var _Stainless_encoder; +var _Stainless_baseURLOverridden; +var Stainless = class { + /** + * API Client for interfacing with the Stainless API. + * + * @param {string | null | undefined} [opts.apiKey=process.env['STAINLESS_API_KEY'] ?? null] + * @param {string | null | undefined} [opts.project] + * @param {string} [opts.baseURL=process.env['STAINLESS_BASE_URL'] ?? https://api.stainless.com] - Override the default base URL for the API. + * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out. + * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls. + * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation. + * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request. + * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API. + * @param {Record} opts.defaultQuery - Default query parameters to include with every request to the API. + */ + constructor({ baseURL = readEnv("STAINLESS_BASE_URL"), apiKey = readEnv("STAINLESS_API_KEY") ?? null, project = null, ...opts } = {}) { + _Stainless_instances.add(this); + _Stainless_encoder.set(this, void 0); + this.projects = new Projects(this); + this.builds = new Builds(this); + this.orgs = new Orgs(this); + this.generate = new Generate(this); + const options = { + apiKey, + project, + ...opts, + baseURL: baseURL || `https://api.stainless.com` + }; + this.baseURL = options.baseURL; + this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT; + this.logger = options.logger ?? console; + const defaultLogLevel = "warn"; + this.logLevel = defaultLogLevel; + this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("STAINLESS_LOG"), "process.env['STAINLESS_LOG']", this) ?? defaultLogLevel; + this.fetchOptions = options.fetchOptions; + this.maxRetries = options.maxRetries ?? 2; + this.fetch = options.fetch ?? getDefaultFetch(); + __classPrivateFieldSet(this, _Stainless_encoder, FallbackEncoder, "f"); + this._options = options; + this.apiKey = apiKey; + this.project = project; + } + /** + * Create a new client instance re-using the same options given to the current client with optional overriding. + */ + withOptions(options) { + return new this.constructor({ + ...this._options, + baseURL: this.baseURL, + maxRetries: this.maxRetries, + timeout: this.timeout, + logger: this.logger, + logLevel: this.logLevel, + fetch: this.fetch, + fetchOptions: this.fetchOptions, + apiKey: this.apiKey, + project: this.project, + ...options + }); + } + defaultQuery() { + return this._options.defaultQuery; + } + validateHeaders({ values, nulls }) { + if (this.apiKey && values.get("authorization")) { + return; + } + if (nulls.has("authorization")) { + return; + } + throw new Error('Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted'); + } + authHeaders(opts) { + if (this.apiKey == null) { + return void 0; + } + return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]); + } + stringifyQuery(query) { + return stringify(query, { arrayFormat: "comma" }); + } + getUserAgent() { + return `${this.constructor.name}/JS ${VERSION}`; + } + defaultIdempotencyKey() { + return `stainless-node-retry-${uuid4()}`; + } + makeStatusError(status, error, message, headers) { + return APIError.generate(status, error, message, headers); + } + buildURL(path3, query, defaultBaseURL) { + const baseURL = !__classPrivateFieldGet(this, _Stainless_instances, "m", _Stainless_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL; + const url = isAbsoluteURL(path3) ? new URL(path3) : new URL(baseURL + (baseURL.endsWith("/") && path3.startsWith("/") ? path3.slice(1) : path3)); + const defaultQuery = this.defaultQuery(); + if (!isEmptyObj(defaultQuery)) { + query = { ...defaultQuery, ...query }; + } + if (typeof query === "object" && query && !Array.isArray(query)) { + url.search = this.stringifyQuery(query); + } + return url.toString(); + } + /** + * Used as a callback for mutating the given `FinalRequestOptions` object. + */ + async prepareOptions(options) { + } + /** + * Used as a callback for mutating the given `RequestInit` object. + * + * This is useful for cases where you want to add certain headers based off of + * the request properties, e.g. `method` or `url`. + */ + async prepareRequest(request, { url, options }) { + } + get(path3, opts) { + return this.methodRequest("get", path3, opts); + } + post(path3, opts) { + return this.methodRequest("post", path3, opts); + } + patch(path3, opts) { + return this.methodRequest("patch", path3, opts); + } + put(path3, opts) { + return this.methodRequest("put", path3, opts); + } + delete(path3, opts) { + return this.methodRequest("delete", path3, opts); + } + methodRequest(method, path3, opts) { + return this.request(Promise.resolve(opts).then((opts2) => { + return { method, path: path3, ...opts2 }; + })); + } + request(options, remainingRetries = null) { + return new APIPromise(this, this.makeRequest(options, remainingRetries, void 0)); + } + async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { + const options = await optionsInput; + const maxRetries = options.maxRetries ?? this.maxRetries; + if (retriesRemaining == null) { + retriesRemaining = maxRetries; + } + await this.prepareOptions(options); + const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); + await this.prepareRequest(req, { url, options }); + const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0"); + const retryLogStr = retryOfRequestLogID === void 0 ? "" : `, retryOf: ${retryOfRequestLogID}`; + const startTime = Date.now(); + loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({ + retryOfRequestLogID, + method: options.method, + url, + options, + headers: req.headers + })); + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const controller = new AbortController(); + const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError); + const headersTime = Date.now(); + if (response instanceof Error) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : "")); + if (retriesRemaining) { + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID); + } + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + if (isTimeout) { + throw new APIConnectionTimeoutError(); + } + throw new APIConnectionError({ cause: response }); + } + const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`; + if (!response.ok) { + const shouldRetry = this.shouldRetry(response); + if (retriesRemaining && shouldRetry) { + const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`; + await CancelReadableStream(response.body); + loggerFor(this).info(`${responseInfo} - ${retryMessage2}`); + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers); + } + const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`; + loggerFor(this).info(`${responseInfo} - ${retryMessage}`); + const errText = await response.text().catch((err2) => castToError(err2).message); + const errJSON = safeJSON(errText); + const errMessage = errJSON ? void 0 : errText; + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + message: errMessage, + durationMs: Date.now() - startTime + })); + const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers); + throw err; + } + loggerFor(this).info(responseInfo); + loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return { response, options, controller, requestLogID, retryOfRequestLogID, startTime }; + } + getAPIList(path3, Page2, opts) { + return this.requestAPIList(Page2, { method: "get", path: path3, ...opts }); + } + requestAPIList(Page2, options) { + const request = this.makeRequest(options, null, void 0); + return new PagePromise(this, request, Page2); + } + async fetchWithTimeout(url, init, ms, controller) { + const { signal, method, ...options } = init || {}; + if (signal) + signal.addEventListener("abort", () => controller.abort()); + const timeout = setTimeout(() => controller.abort(), ms); + const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body; + const fetchOptions = { + signal: controller.signal, + ...isReadableBody ? { duplex: "half" } : {}, + method: "GET", + ...options + }; + if (method) { + fetchOptions.method = method.toUpperCase(); + } + try { + return await this.fetch.call(void 0, url, fetchOptions); + } finally { + clearTimeout(timeout); + } + } + shouldRetry(response) { + const shouldRetryHeader = response.headers.get("x-should-retry"); + if (shouldRetryHeader === "true") + return true; + if (shouldRetryHeader === "false") + return false; + if (response.status === 408) + return true; + if (response.status === 409) + return true; + if (response.status === 429) + return true; + if (response.status >= 500) + return true; + return false; + } + async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) { + let timeoutMillis; + const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms"); + if (retryAfterMillisHeader) { + const timeoutMs = parseFloat(retryAfterMillisHeader); + if (!Number.isNaN(timeoutMs)) { + timeoutMillis = timeoutMs; + } + } + const retryAfterHeader = responseHeaders?.get("retry-after"); + if (retryAfterHeader && !timeoutMillis) { + const timeoutSeconds = parseFloat(retryAfterHeader); + if (!Number.isNaN(timeoutSeconds)) { + timeoutMillis = timeoutSeconds * 1e3; + } else { + timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + } + if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3)) { + const maxRetries = options.maxRetries ?? this.maxRetries; + timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); + } + await sleep(timeoutMillis); + return this.makeRequest(options, retriesRemaining - 1, requestLogID); + } + calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) { + const initialRetryDelay = 0.5; + const maxRetryDelay = 8; + const numRetries = maxRetries - retriesRemaining; + const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay); + const jitter = 1 - Math.random() * 0.25; + return sleepSeconds * jitter * 1e3; + } + buildRequest(inputOptions, { retryCount = 0 } = {}) { + const options = { ...inputOptions }; + const { method, path: path3, query, defaultBaseURL } = options; + const url = this.buildURL(path3, query, defaultBaseURL); + if ("timeout" in options) + validatePositiveInteger("timeout", options.timeout); + options.timeout = options.timeout ?? this.timeout; + const { bodyHeaders, body } = this.buildBody({ options }); + const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount }); + const req = { + method, + headers: reqHeaders, + ...options.signal && { signal: options.signal }, + ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" }, + ...body && { body }, + ...this.fetchOptions ?? {}, + ...options.fetchOptions ?? {} + }; + return { req, url, timeout: options.timeout }; + } + buildHeaders({ options, method, bodyHeaders, retryCount }) { + let idempotencyHeaders = {}; + if (this.idempotencyHeader && method !== "get") { + if (!options.idempotencyKey) + options.idempotencyKey = this.defaultIdempotencyKey(); + idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; + } + const headers = buildHeaders([ + idempotencyHeaders, + { + Accept: "application/json", + "User-Agent": this.getUserAgent(), + "X-Stainless-Retry-Count": String(retryCount), + ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1e3)) } : {}, + ...getPlatformHeaders() + }, + this.authHeaders(options), + this._options.defaultHeaders, + bodyHeaders, + options.headers + ]); + this.validateHeaders(headers); + return headers.values; + } + buildBody({ options: { body, headers: rawHeaders } }) { + if (!body) { + return { bodyHeaders: void 0, body: void 0 }; + } + const headers = buildHeaders([rawHeaders]); + if ( + // Pass raw type verbatim + ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && // Preserve legacy string encoding behavior for now + headers.values.has("content-type") || // `Blob` is superset of `File` + body instanceof Blob || // `FormData` -> `multipart/form-data` + body instanceof FormData || // `URLSearchParams` -> `application/x-www-form-urlencoded` + body instanceof URLSearchParams || // Send chunked stream (each chunk has own `length`) + globalThis.ReadableStream && body instanceof globalThis.ReadableStream + ) { + return { bodyHeaders: void 0, body }; + } else if (typeof body === "object" && (Symbol.asyncIterator in body || Symbol.iterator in body && "next" in body && typeof body.next === "function")) { + return { bodyHeaders: void 0, body: ReadableStreamFrom(body) }; + } else { + return __classPrivateFieldGet(this, _Stainless_encoder, "f").call(this, { body, headers }); + } + } +}; +_a = Stainless, _Stainless_encoder = /* @__PURE__ */ new WeakMap(), _Stainless_instances = /* @__PURE__ */ new WeakSet(), _Stainless_baseURLOverridden = function _Stainless_baseURLOverridden2() { + return this.baseURL !== "https://api.stainless.com"; +}; +Stainless.Stainless = _a; +Stainless.DEFAULT_TIMEOUT = 6e4; +Stainless.StainlessError = StainlessError; +Stainless.APIError = APIError; +Stainless.APIConnectionError = APIConnectionError; +Stainless.APIConnectionTimeoutError = APIConnectionTimeoutError; +Stainless.APIUserAbortError = APIUserAbortError; +Stainless.NotFoundError = NotFoundError; +Stainless.ConflictError = ConflictError; +Stainless.RateLimitError = RateLimitError; +Stainless.BadRequestError = BadRequestError; +Stainless.AuthenticationError = AuthenticationError; +Stainless.InternalServerError = InternalServerError; +Stainless.PermissionDeniedError = PermissionDeniedError; +Stainless.UnprocessableEntityError = UnprocessableEntityError; +Stainless.toFile = toFile; +Stainless.unwrapFile = unwrapFile; +Stainless.Projects = Projects; +Stainless.Builds = Builds; +Stainless.Orgs = Orgs; +Stainless.Generate = Generate; + +// src/runBuilds.ts +var fs = __toESM(require("fs")); +var CONVENTIONAL_COMMIT_REGEX = new RegExp( + /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?(!?): .*$/ +); +var isValidConventionalCommitMessage = (message) => { + return CONVENTIONAL_COMMIT_REGEX.test(message); +}; +var POLLING_INTERVAL_SECONDS = 5; +var MAX_POLLING_SECONDS = 10 * 60; +async function* runBuilds({ + stainless, + projectName, + baseRevision, + baseBranch, + mergeBranch, + branch, + oasPath, + configPath, + guessConfig = false, + commitMessage, + outputDir +}) { + if (mergeBranch && (oasPath || configPath)) { + throw new Error( + "Cannot specify both merge_branch and oas_path or config_path" + ); + } + if (guessConfig && (configPath || !oasPath)) { + throw new Error( + "If guess_config is true, must have oas_path and no config_path" + ); + } + if (baseRevision && mergeBranch) { + throw new Error("Cannot specify both base_revision and merge_branch"); + } + if (commitMessage && !isValidConventionalCommitMessage(commitMessage)) { + console.warn( + `Commit message: "${commitMessage}" is not in Conventional Commits format: https://www.conventionalcommits.org/en/v1.0.0/. Prepending "feat" and using anyway.` + ); + commitMessage = `feat: ${commitMessage}`; + } + const oasContent = oasPath ? fs.readFileSync(oasPath, "utf-8") : void 0; + let configContent = configPath ? fs.readFileSync(configPath, "utf-8") : void 0; + if (!baseRevision) { + const build = await stainless.builds.create( + { + project: projectName, + revision: mergeBranch ? `${branch}..${mergeBranch}` : { + ...oasContent && { + "openapi.yml": { + content: oasContent + } + }, + ...configContent && { + "openapi.stainless.yml": { + content: configContent + } + } + }, + branch, + commit_message: commitMessage, + allow_empty: true + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1e3 + } + ); + for (const waitFor of ["postgen", "completed"]) { + const { outcomes, documentedSpec } = await pollBuild({ + stainless, + build, + waitFor + }); + let documentedSpecPath = null; + if (outputDir && documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, documentedSpec); + } + yield { + baseOutcomes: null, + outcomes, + documentedSpecPath + }; + } + return; + } + if (!configContent) { + if (guessConfig) { + console.log("Guessing config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.guess({ + branch, + spec: oasContent + }) + )[0]?.content; + } else { + console.log("Saving config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.retrieve({ + branch + }) + )[0]?.content; + } + } + console.log(`Hard resetting ${branch} to ${baseRevision}`); + const { config_commit } = await stainless.projects.branches.create({ + branch_from: baseRevision, + branch, + force: true + }); + console.log(`Hard reset ${branch}, now at ${config_commit.sha}`); + const { base, head } = await stainless.builds.compare( + { + base: { + revision: baseRevision, + branch: baseBranch, + commit_message: commitMessage + }, + head: { + revision: { + ...oasContent && { + "openapi.yml": { + content: oasContent + } + }, + ...configContent && { + "openapi.stainless.yml": { + content: configContent + } + } + }, + branch, + commit_message: commitMessage + } + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1e3 + } + ); + for (const waitFor of ["postgen", "completed"]) { + const results = await Promise.all([ + pollBuild({ stainless, build: base, waitFor }), + pollBuild({ stainless, build: head, waitFor }) + ]); + let documentedSpecPath = null; + if (outputDir && results[1].documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, results[1].documentedSpec); + } + yield { + baseOutcomes: results[0].outcomes, + outcomes: results[1].outcomes, + documentedSpecPath + }; + } + return; +} +async function pollBuild({ + stainless, + build, + waitFor, + pollingIntervalSeconds = POLLING_INTERVAL_SECONDS, + maxPollingSeconds = MAX_POLLING_SECONDS +}) { + const outcomes = {}; + let documentedSpec = null; + const buildId = build.id; + const languages = Object.keys(build.targets); + if (buildId) { + console.log( + `[${buildId}] Created build against ${build.config_commit} for languages: ${languages.join(", ")}` + ); + } else { + console.log(`No new build was created; exiting.`); + return { outcomes, documentedSpec }; + } + const pollingStart = Date.now(); + while (Object.keys(outcomes).length < languages.length && Date.now() - pollingStart < maxPollingSeconds * 1e3) { + const build2 = await stainless.builds.retrieve(buildId); + for (const language of languages) { + if (!(language in outcomes)) { + const buildOutput = build2.targets[language]; + console.log( + `[${buildId}] Build for ${language} has status ${buildOutput.status}` + ); + if ([waitFor, "completed"].includes(buildOutput.status) && buildOutput.commit.status === "completed") { + console.log( + `[${buildId}] Build has output:`, + JSON.stringify(buildOutput) + ); + const diagnostics = []; + try { + for await (const diagnostic of stainless.builds.diagnostics.list( + buildId + )) { + diagnostics.push(diagnostic); + } + } catch (e) { + console.error( + `[${buildId}] Error getting diagnostics, continuing anyway`, + e + ); + } + outcomes[language] = { + ...buildOutput, + commit: buildOutput.commit, + diagnostics + }; + } + } + } + if (!documentedSpec && build2.documented_spec) { + documentedSpec = await Stainless.unwrapFile(build2.documented_spec); + } + await new Promise( + (resolve) => setTimeout(resolve, pollingIntervalSeconds * 1e3) + ); + } + const languagesWithoutOutcome = languages.filter( + (language) => !(language in outcomes) + ); + for (const language of languagesWithoutOutcome) { + console.log( + `[${buildId}] Build for ${language} timed out after ${maxPollingSeconds} seconds` + ); + outcomes[language] = { + object: "build_target", + status: "completed", + lint: { + status: "not_started" + }, + test: { + status: "not_started" + }, + commit: { + status: "completed", + completed: { + conclusion: "timed_out", + commit: null, + merge_conflict_pr: null, + url: null + } + }, + diagnostics: [] + }; + } + return { outcomes, documentedSpec }; +} +function checkResults({ + outcomes, + failRunOn +}) { + if (failRunOn === "never") { + return true; + } + const failedLanguages = Object.entries(outcomes).filter(([_, outcome]) => { + if (!outcome.commit || outcome.commit.completed.conclusion === "noop") { + return true; + } + if (failRunOn === "error" || failRunOn === "warning" || failRunOn === "note") { + if (outcome.commit.completed.conclusion === "error") return true; + } + if (failRunOn === "warning" || failRunOn === "note") { + if (outcome.commit.completed.conclusion === "warning") return true; + } + if (failRunOn === "note") { + if (outcome.commit.completed.conclusion === "note") return true; + } + return false; + }); + if (failedLanguages.length > 0) { + console.log( + `The following languages did not build successfully: ${failedLanguages.map(([lang]) => lang).join(", ")}` + ); + return false; + } + return true; +} + +// src/comment.ts +var github = __toESM(require_github()); + +// node_modules/@stainless-api/github-internal/core/resource.mjs +var APIResource2 = /* @__PURE__ */ (() => { + class APIResource3 { + constructor(client) { + this._client = client; + } + } + APIResource3._key = []; + return APIResource3; +})(); + +// node_modules/@stainless-api/github-internal/internal/tslib.mjs +function __classPrivateFieldSet2(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +function __classPrivateFieldGet2(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +// node_modules/@stainless-api/github-internal/internal/errors.mjs +function isAbortError2(err) { + return typeof err === "object" && err !== null && // Spec-compliant fetch implementations + ("name" in err && err.name === "AbortError" || // Expo fetch + "message" in err && String(err.message).includes("FetchRequestCanceledException")); +} +var castToError2 = (err) => { + if (err instanceof Error) + return err; + if (typeof err === "object" && err !== null) { + try { + if (Object.prototype.toString.call(err) === "[object Error]") { + const error = new Error(err.message, err.cause ? { cause: err.cause } : {}); + if (err.stack) + error.stack = err.stack; + if (err.cause && !error.cause) + error.cause = err.cause; + if (err.name) + error.name = err.name; + return error; + } + } catch { + } + try { + return new Error(JSON.stringify(err)); + } catch { + } + } + return new Error(err); +}; + +// node_modules/@stainless-api/github-internal/core/error.mjs +var GitHubError = /* @__PURE__ */ (() => { + class GitHubError2 extends Error { + } + return GitHubError2; +})(); +var APIError2 = class _APIError extends GitHubError { + constructor(status, error, message, headers) { + super(`${_APIError.makeMessage(status, error, message)}`); + this.status = status; + this.headers = headers; + this.error = error; + } + static makeMessage(status, error, message) { + const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message; + if (status && msg) { + return `${status} ${msg}`; + } + if (status) { + return `${status} status code (no body)`; + } + if (msg) { + return msg; + } + return "(no status code or body)"; + } + static generate(status, errorResponse, message, headers) { + if (!status || !headers) { + return new APIConnectionError2({ message, cause: castToError2(errorResponse) }); + } + const error = errorResponse; + if (status === 400) { + return new BadRequestError2(status, error, message, headers); + } + if (status === 401) { + return new AuthenticationError2(status, error, message, headers); + } + if (status === 403) { + return new PermissionDeniedError2(status, error, message, headers); + } + if (status === 404) { + return new NotFoundError2(status, error, message, headers); + } + if (status === 409) { + return new ConflictError2(status, error, message, headers); + } + if (status === 422) { + return new UnprocessableEntityError2(status, error, message, headers); + } + if (status === 429) { + return new RateLimitError2(status, error, message, headers); + } + if (status >= 500) { + return new InternalServerError2(status, error, message, headers); + } + return new _APIError(status, error, message, headers); + } +}; +var APIUserAbortError2 = class extends APIError2 { + constructor({ message } = {}) { + super(void 0, void 0, message || "Request was aborted.", void 0); + } +}; +var APIConnectionError2 = class extends APIError2 { + constructor({ message, cause }) { + super(void 0, void 0, message || "Connection error.", void 0); + if (cause) + this.cause = cause; + } +}; +var APIConnectionTimeoutError2 = class extends APIConnectionError2 { + constructor({ message } = {}) { + super({ message: message ?? "Request timed out." }); + } +}; +var BadRequestError2 = class extends APIError2 { +}; +var AuthenticationError2 = class extends APIError2 { +}; +var PermissionDeniedError2 = class extends APIError2 { +}; +var NotFoundError2 = class extends APIError2 { +}; +var ConflictError2 = class extends APIError2 { +}; +var UnprocessableEntityError2 = class extends APIError2 { +}; +var RateLimitError2 = class extends APIError2 { +}; +var InternalServerError2 = class extends APIError2 { +}; + +// node_modules/@stainless-api/github-internal/internal/utils/values.mjs +var startsWithSchemeRegexp2 = /^[a-z][a-z0-9+.-]*:/i; +var isAbsoluteURL2 = (url) => { + return startsWithSchemeRegexp2.test(url); +}; +var isArray2 = (val) => (isArray2 = Array.isArray, isArray2(val)); +var isReadonlyArray2 = isArray2; +function maybeObj2(x) { + if (typeof x !== "object") { + return {}; + } + return x ?? {}; +} +function isEmptyObj2(obj) { + if (!obj) + return true; + for (const _k in obj) + return false; + return true; +} +function hasOwn2(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} +var validatePositiveInteger2 = (name, n) => { + if (typeof n !== "number" || !Number.isInteger(n)) { + throw new GitHubError(`${name} must be an integer`); + } + if (n < 0) { + throw new GitHubError(`${name} must be a positive integer`); + } + return n; +}; +var safeJSON2 = (text) => { + try { + return JSON.parse(text); + } catch (err) { + return void 0; + } +}; + +// node_modules/@stainless-api/github-internal/internal/utils/log.mjs +var levelNumbers2 = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500 +}; +var parseLogLevel2 = (maybeLevel, sourceName, client) => { + if (!maybeLevel) { + return void 0; + } + if (hasOwn2(levelNumbers2, maybeLevel)) { + return maybeLevel; + } + loggerFor2(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers2))}`); + return void 0; +}; +function noop2() { +} +function makeLogFn2(fnLevel, logger, logLevel) { + if (!logger || levelNumbers2[fnLevel] > levelNumbers2[logLevel]) { + return noop2; + } else { + return logger[fnLevel].bind(logger); + } +} +var noopLogger2 = { + error: noop2, + warn: noop2, + info: noop2, + debug: noop2 +}; +var cachedLoggers2 = /* @__PURE__ */ new WeakMap(); +function loggerFor2(client) { + const logger = client.logger; + const logLevel = client.logLevel ?? "off"; + if (!logger) { + return noopLogger2; + } + const cachedLogger = cachedLoggers2.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) { + return cachedLogger[1]; + } + const levelLogger = { + error: makeLogFn2("error", logger, logLevel), + warn: makeLogFn2("warn", logger, logLevel), + info: makeLogFn2("info", logger, logLevel), + debug: makeLogFn2("debug", logger, logLevel) + }; + cachedLoggers2.set(logger, [logLevel, levelLogger]); + return levelLogger; +} +var formatRequestDetails2 = (details) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options["headers"]; + } + if (details.headers) { + details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [ + name, + name.toLowerCase() === "authorization" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value + ])); + } + if ("retryOfRequestLogID" in details) { + if (details.retryOfRequestLogID) { + details.retryOf = details.retryOfRequestLogID; + } + delete details.retryOfRequestLogID; + } + return details; +}; + +// node_modules/@stainless-api/github-internal/internal/parse.mjs +async function defaultParseResponse2(client, props) { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + const body = await (async () => { + if (response.status === 204) { + return null; + } + if (props.options.__binaryResponse) { + return response; + } + const contentType = response.headers.get("content-type"); + const mediaType = contentType?.split(";")[0]?.trim(); + const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json"); + if (isJSON) { + const json = await response.json(); + return json; + } + const text = await response.text(); + return text; + })(); + loggerFor2(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body, + durationMs: Date.now() - startTime + })); + return body; +} + +// node_modules/@stainless-api/github-internal/core/api-promise.mjs +var _APIPromise_client2; +var APIPromise2 = /* @__PURE__ */ (() => { + class APIPromise3 extends Promise { + constructor(client, responsePromise, parseResponse = defaultParseResponse2) { + super((resolve) => { + resolve(null); + }); + this.responsePromise = responsePromise; + this.parseResponse = parseResponse; + _APIPromise_client2.set(this, void 0); + __classPrivateFieldSet2(this, _APIPromise_client2, client, "f"); + } + _thenUnwrap(transform) { + return new APIPromise3(__classPrivateFieldGet2(this, _APIPromise_client2, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props)); + } + /** + * Gets the raw `Response` instance instead of parsing the response + * data. + * + * If you want to parse the response body but still get the `Response` + * instance, you can use {@link withResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + asResponse() { + return this.responsePromise.then((p) => p.response); + } + /** + * Gets the parsed response data and the raw `Response` instance. + * + * If you just want to get the raw `Response` instance without parsing it, + * you can use {@link asResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + async withResponse() { + const [data, response] = await Promise.all([this.parse(), this.asResponse()]); + return { data, response }; + } + parse() { + if (!this.parsedPromise) { + this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet2(this, _APIPromise_client2, "f"), data)); + } + return this.parsedPromise; + } + then(onfulfilled, onrejected) { + return this.parse().then(onfulfilled, onrejected); + } + catch(onrejected) { + return this.parse().catch(onrejected); + } + finally(onfinally) { + return this.parse().finally(onfinally); + } + } + _APIPromise_client2 = /* @__PURE__ */ new WeakMap(); + return APIPromise3; +})(); + +// node_modules/@stainless-api/github-internal/core/pagination.mjs +var _AbstractPage_client2; +var AbstractPage2 = /* @__PURE__ */ (() => { + class AbstractPage3 { + constructor(client, response, body, options) { + _AbstractPage_client2.set(this, void 0); + __classPrivateFieldSet2(this, _AbstractPage_client2, client, "f"); + this.options = options; + this.response = response; + this.body = body; + } + hasNextPage() { + const items = this.getPaginatedItems(); + if (!items.length) + return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + const nextOptions = this.nextPageRequestOptions(); + if (!nextOptions) { + throw new GitHubError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); + } + return await __classPrivateFieldGet2(this, _AbstractPage_client2, "f").requestAPIList(this.constructor, nextOptions); + } + async *iterPages() { + let page = this; + yield page; + while (page.hasNextPage()) { + page = await page.getNextPage(); + yield page; + } + } + async *[(_AbstractPage_client2 = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (const page of this.iterPages()) { + for (const item of page.getPaginatedItems()) { + yield item; + } + } + } + } + return AbstractPage3; +})(); +var PagePromise2 = /* @__PURE__ */ (() => { + class PagePromise3 extends APIPromise2 { + constructor(client, request, Page2) { + super(client, request, async (client2, props) => new Page2(client2, props.response, await defaultParseResponse2(client2, props), props.options)); + } + /** + * Allow auto-paginating iteration on an unawaited list call, eg: + * + * for await (const item of client.items.list()) { + * console.log(item) + * } + */ + async *[Symbol.asyncIterator]() { + const page = await this; + for await (const item of page) { + yield item; + } + } + } + return PagePromise3; +})(); +var NumberedPage = class extends AbstractPage2 { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body || []; + } + getPaginatedItems() { + return this.data ?? []; + } + nextPageRequestOptions() { + const query = this.options.query; + const currentPage = query?.page ?? 1; + return { + ...this.options, + query: { + ...maybeObj2(this.options.query), + page: currentPage + 1 + } + }; + } +}; + +// node_modules/@stainless-api/github-internal/internal/headers.mjs +var brand_privateNullableHeaders2 = /* @__PURE__ */ Symbol("brand.privateNullableHeaders"); +function* iterateHeaders2(headers) { + if (!headers) + return; + if (brand_privateNullableHeaders2 in headers) { + const { values, nulls } = headers; + yield* values.entries(); + for (const name of nulls) { + yield [name, null]; + } + return; + } + let shouldClear = false; + let iter; + if (headers instanceof Headers) { + iter = headers.entries(); + } else if (isReadonlyArray2(headers)) { + iter = headers; + } else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== "string") + throw new TypeError("expected header name to be a string"); + const values = isReadonlyArray2(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === void 0) + continue; + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} +var buildHeaders2 = (newHeaders) => { + const targetHeaders = new Headers(); + const nullHeaders = /* @__PURE__ */ new Set(); + for (const headers of newHeaders) { + const seenHeaders = /* @__PURE__ */ new Set(); + for (const [name, value] of iterateHeaders2(headers)) { + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(name); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(name); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(name, value); + nullHeaders.delete(lowerName); + } + } + } + return { [brand_privateNullableHeaders2]: true, values: targetHeaders, nulls: nullHeaders }; +}; + +// node_modules/@stainless-api/github-internal/internal/utils/path.mjs +function encodeURIPath2(str) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +var EMPTY2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); +var createPathTagFunction2 = (pathEncoder = encodeURIPath2) => function path3(statics, ...params) { + if (statics.length === 1) + return statics[0]; + let postPath = false; + const invalidSegments = []; + const path4 = statics.reduce((previousValue, currentValue, index) => { + if (/[?#]/.test(currentValue)) { + postPath = true; + } + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value); + if (index !== params.length && (value == null || typeof value === "object" && // handle values from other realms + value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY2) ?? EMPTY2)?.toString)) { + encoded = value + ""; + invalidSegments.push({ + start: previousValue.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter` + }); + } + return previousValue + currentValue + (index === params.length ? "" : encoded); + }, ""); + const pathOnly = path4.split(/[?#]/, 1)[0]; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { + invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can't be safely passed as a path parameter` + }); + } + invalidSegments.sort((a, b) => a.start - b.start); + if (invalidSegments.length > 0) { + let lastEnd = 0; + const underline = invalidSegments.reduce((acc, segment) => { + const spaces = " ".repeat(segment.start - lastEnd); + const arrows = "^".repeat(segment.length); + lastEnd = segment.start + segment.length; + return acc + spaces + arrows; + }, ""); + throw new GitHubError(`Path parameters result in path with invalid segments: +${invalidSegments.map((e) => e.error).join("\n")} +${path4} +${underline}`); + } + return path4; +}; +var path2 = /* @__PURE__ */ createPathTagFunction2(encodeURIPath2); + +// node_modules/@stainless-api/github-internal/resources/repos/issues/comments/reactions.mjs +var BaseReactions = /* @__PURE__ */ (() => { + class BaseReactions8 extends APIResource2 { + /** + * Create a reaction to an + * [issue comment](https://docs.github.com/rest/issues/comments#get-an-issue-comment). + * A response with an HTTP `200` status means that you already added the reaction + * type to this issue comment. + * + * @example + * ```ts + * const reaction = + * await client.repos.issues.comments.reactions.create(0, { + * owner: 'owner', + * repo: 'repo', + * content: 'heart', + * }); + * ``` + */ + create(commentID, params, options) { + const { owner = this._client.owner, repo = this._client.repo, ...body } = params; + return this._client.post(path2`/repos/${owner}/${repo}/issues/comments/${commentID}/reactions`, { + body, + ...options + }); + } + /** + * List the reactions to an + * [issue comment](https://docs.github.com/rest/issues/comments#get-an-issue-comment). + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const reactionListResponse of client.repos.issues.comments.reactions.list( + * 0, + * { owner: 'owner', repo: 'repo' }, + * )) { + * // ... + * } + * ``` + */ + list(commentID, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo, ...query } = params ?? {}; + return this._client.getAPIList(path2`/repos/${owner}/${repo}/issues/comments/${commentID}/reactions`, NumberedPage, { query, ...options }); + } + /** + * > [!NOTE] You can also specify a repository by `repository_id` using the route + * > `DELETE delete /repositories/:repository_id/issues/comments/:comment_id/reactions/:reaction_id`. + * + * Delete a reaction to an + * [issue comment](https://docs.github.com/rest/issues/comments#get-an-issue-comment). + * + * @example + * ```ts + * await client.repos.issues.comments.reactions.delete(0, { + * owner: 'owner', + * repo: 'repo', + * comment_id: 0, + * }); + * ``` + */ + delete(reactionID, params, options) { + const { owner = this._client.owner, repo = this._client.repo, comment_id } = params; + return this._client.delete(path2`/repos/${owner}/${repo}/issues/comments/${comment_id}/reactions/${reactionID}`, { ...options, headers: buildHeaders2([{ Accept: "*/*" }, options?.headers]) }); + } + } + BaseReactions8._key = Object.freeze(["repos", "issues", "comments", "reactions"]); + return BaseReactions8; +})(); +var Reactions = class extends BaseReactions { +}; + +// node_modules/@stainless-api/github-internal/resources/repos/issues/comments/comments.mjs +var BaseComments = /* @__PURE__ */ (() => { + class BaseComments7 extends APIResource2 { + /** + * You can use the REST API to create comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * This endpoint triggers + * [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). + * Creating content too quickly using this endpoint may result in secondary rate + * limiting. For more information, see + * "[Rate limits for the API](https://docs.github.com/rest/using-the-rest-api/rate-limits-for-the-rest-api#about-secondary-rate-limits)" + * and + * "[Best practices for using the REST API](https://docs.github.com/rest/guides/best-practices-for-using-the-rest-api)." + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * const issueComment = + * await client.repos.issues.comments.create(0, { + * owner: 'owner', + * repo: 'repo', + * body: 'Me too', + * }); + * ``` + */ + create(issueNumber, params, options) { + const { owner = this._client.owner, repo = this._client.repo, ...body } = params; + return this._client.post(path2`/repos/${owner}/${repo}/issues/${issueNumber}/comments`, { + body, + ...options + }); + } + /** + * You can use the REST API to get comments on issues and pull requests. Every pull + * request is an issue, but not every issue is a pull request. + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * const issueComment = + * await client.repos.issues.comments.retrieve(0, { + * owner: 'owner', + * repo: 'repo', + * }); + * ``` + */ + retrieve(commentID, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo } = params ?? {}; + return this._client.get(path2`/repos/${owner}/${repo}/issues/comments/${commentID}`, options); + } + /** + * You can use the REST API to update comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * const issueComment = + * await client.repos.issues.comments.update(0, { + * owner: 'owner', + * repo: 'repo', + * body: 'Me too', + * }); + * ``` + */ + update(commentID, params, options) { + const { owner = this._client.owner, repo = this._client.repo, ...body } = params; + return this._client.patch(path2`/repos/${owner}/${repo}/issues/comments/${commentID}`, { + body, + ...options + }); + } + async upsertBasedOnBodyMatch(issueNumber, { bodyIncludes, createParams, updateParams, options }) { + const comments = await this.list(issueNumber); + const match = comments.data.find((comment) => comment.body?.includes(bodyIncludes)); + if (match) { + return this.update(match.id, updateParams, options); + } else { + return this.create(issueNumber, createParams, options); + } + } + /** + * You can use the REST API to list comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * Issue comments are ordered by ascending ID. + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const issueComment of client.repos.issues.comments.list( + * 0, + * { owner: 'owner', repo: 'repo' }, + * )) { + * // ... + * } + * ``` + */ + list(issueNumber, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo, ...query } = params ?? {}; + return this._client.getAPIList(path2`/repos/${owner}/${repo}/issues/${issueNumber}/comments`, NumberedPage, { query, ...options }); + } + /** + * You can use the REST API to delete comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * @example + * ```ts + * await client.repos.issues.comments.delete(0, { + * owner: 'owner', + * repo: 'repo', + * }); + * ``` + */ + delete(commentID, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo } = params ?? {}; + return this._client.delete(path2`/repos/${owner}/${repo}/issues/comments/${commentID}`, { + ...options, + headers: buildHeaders2([{ Accept: "*/*" }, options?.headers]) + }); + } + } + BaseComments7._key = Object.freeze(["repos", "issues", "comments"]); + return BaseComments7; +})(); +var Comments = /* @__PURE__ */ (() => { + class Comments7 extends BaseComments { + constructor() { + super(...arguments); + this.reactions = new Reactions(this._client); + } + } + Comments7.Reactions = Reactions; + Comments7.BaseReactions = BaseReactions; + return Comments7; +})(); + +// node_modules/@stainless-api/github-internal/internal/utils/uuid.mjs +var uuid42 = function() { + const { crypto } = globalThis; + if (crypto?.randomUUID) { + uuid42 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16)); +}; + +// node_modules/@stainless-api/github-internal/internal/utils/sleep.mjs +var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); + +// node_modules/@stainless-api/github-internal/version.mjs +var VERSION2 = "0.12.1"; + +// node_modules/@stainless-api/github-internal/internal/detect-platform.mjs +function getDetectedPlatform2() { + if (typeof Deno !== "undefined" && Deno.build != null) { + return "deno"; + } + if (typeof EdgeRuntime !== "undefined") { + return "edge"; + } + if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") { + return "node"; + } + return "unknown"; +} +var getPlatformProperties2 = () => { + const detectedPlatform = getDetectedPlatform2(); + if (detectedPlatform === "deno") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": normalizePlatform2(Deno.build.os), + "X-Stainless-Arch": normalizeArch2(Deno.build.arch), + "X-Stainless-Runtime": "deno", + "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown" + }; + } + if (typeof EdgeRuntime !== "undefined") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": `other:${EdgeRuntime}`, + "X-Stainless-Runtime": "edge", + "X-Stainless-Runtime-Version": globalThis.process.version + }; + } + if (detectedPlatform === "node") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": normalizePlatform2(globalThis.process.platform ?? "unknown"), + "X-Stainless-Arch": normalizeArch2(globalThis.process.arch ?? "unknown"), + "X-Stainless-Runtime": "node", + "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown" + }; + } + const browserInfo = getBrowserInfo2(); + if (browserInfo) { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": `browser:${browserInfo.browser}`, + "X-Stainless-Runtime-Version": browserInfo.version + }; + } + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": "unknown", + "X-Stainless-Runtime-Version": "unknown" + }; +}; +function getBrowserInfo2() { + if (typeof navigator === "undefined" || !navigator) { + return null; + } + const browserPatterns = [ + { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ } + ]; + for (const { key, pattern } of browserPatterns) { + const match = pattern.exec(navigator.userAgent); + if (match) { + const major = match[1] || 0; + const minor = match[2] || 0; + const patch = match[3] || 0; + return { browser: key, version: `${major}.${minor}.${patch}` }; + } + } + return null; +} +var normalizeArch2 = (arch) => { + if (arch === "x32") + return "x32"; + if (arch === "x86_64" || arch === "x64") + return "x64"; + if (arch === "arm") + return "arm"; + if (arch === "aarch64" || arch === "arm64") + return "arm64"; + if (arch) + return `other:${arch}`; + return "unknown"; +}; +var normalizePlatform2 = (platform) => { + platform = platform.toLowerCase(); + if (platform.includes("ios")) + return "iOS"; + if (platform === "android") + return "Android"; + if (platform === "darwin") + return "MacOS"; + if (platform === "win32") + return "Windows"; + if (platform === "freebsd") + return "FreeBSD"; + if (platform === "openbsd") + return "OpenBSD"; + if (platform === "linux") + return "Linux"; + if (platform) + return `Other:${platform}`; + return "Unknown"; +}; +var _platformHeaders2; +var getPlatformHeaders2 = () => { + return _platformHeaders2 ?? (_platformHeaders2 = getPlatformProperties2()); +}; + +// node_modules/@stainless-api/github-internal/internal/shims.mjs +function getDefaultFetch2() { + if (typeof fetch !== "undefined") { + return fetch; + } + throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new GitHub({ fetch })` or polyfill the global, `globalThis.fetch = fetch`"); +} +function makeReadableStream2(...args) { + const ReadableStream = globalThis.ReadableStream; + if (typeof ReadableStream === "undefined") { + throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`"); + } + return new ReadableStream(...args); +} +function ReadableStreamFrom2(iterable) { + let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); + return makeReadableStream2({ + start() { + }, + async pull(controller) { + const { done, value } = await iter.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel() { + await iter.return?.(); + } + }); +} +async function CancelReadableStream2(stream) { + if (stream === null || typeof stream !== "object") + return; + if (stream[Symbol.asyncIterator]) { + await stream[Symbol.asyncIterator]().return?.(); + return; + } + const reader = stream.getReader(); + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; +} + +// node_modules/@stainless-api/github-internal/internal/request-options.mjs +var FallbackEncoder2 = ({ headers, body }) => { + return { + bodyHeaders: { + "content-type": "application/json" + }, + body: JSON.stringify(body) + }; +}; + +// node_modules/@stainless-api/github-internal/internal/qs/formats.mjs +var default_format2 = "RFC3986"; +var default_formatter2 = (v) => String(v); +var formatters2 = { + RFC1738: (v) => String(v).replace(/%20/g, "+"), + RFC3986: default_formatter2 +}; +var RFC17382 = "RFC1738"; + +// node_modules/@stainless-api/github-internal/internal/qs/utils.mjs +var has2 = (obj, key) => (has2 = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), has2(obj, key)); +var hex_table2 = /* @__PURE__ */ (() => { + const array = []; + for (let i = 0; i < 256; ++i) { + array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + } + return array; +})(); +var limit2 = 1024; +var encode2 = (str, _defaultEncoder, charset, _kind, format) => { + if (str.length === 0) { + return str; + } + let string = str; + if (typeof str === "symbol") { + string = Symbol.prototype.toString.call(str); + } else if (typeof str !== "string") { + string = String(str); + } + if (charset === "iso-8859-1") { + return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) { + return "%26%23" + parseInt($0.slice(2), 16) + "%3B"; + }); + } + let out = ""; + for (let j = 0; j < string.length; j += limit2) { + const segment = string.length >= limit2 ? string.slice(j, j + limit2) : string; + const arr = []; + for (let i = 0; i < segment.length; ++i) { + let c = segment.charCodeAt(i); + if (c === 45 || // - + c === 46 || // . + c === 95 || // _ + c === 126 || // ~ + c >= 48 && c <= 57 || // 0-9 + c >= 65 && c <= 90 || // a-z + c >= 97 && c <= 122 || // A-Z + format === RFC17382 && (c === 40 || c === 41)) { + arr[arr.length] = segment.charAt(i); + continue; + } + if (c < 128) { + arr[arr.length] = hex_table2[c]; + continue; + } + if (c < 2048) { + arr[arr.length] = hex_table2[192 | c >> 6] + hex_table2[128 | c & 63]; + continue; + } + if (c < 55296 || c >= 57344) { + arr[arr.length] = hex_table2[224 | c >> 12] + hex_table2[128 | c >> 6 & 63] + hex_table2[128 | c & 63]; + continue; + } + i += 1; + c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023); + arr[arr.length] = hex_table2[240 | c >> 18] + hex_table2[128 | c >> 12 & 63] + hex_table2[128 | c >> 6 & 63] + hex_table2[128 | c & 63]; + } + out += arr.join(""); + } + return out; +}; +function is_buffer2(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); +} +function maybe_map2(val, fn) { + if (isArray2(val)) { + const mapped = []; + for (let i = 0; i < val.length; i += 1) { + mapped.push(fn(val[i])); + } + return mapped; + } + return fn(val); +} + +// node_modules/@stainless-api/github-internal/internal/qs/stringify.mjs +var array_prefix_generators2 = { + brackets(prefix) { + return String(prefix) + "[]"; + }, + comma: "comma", + indices(prefix, key) { + return String(prefix) + "[" + key + "]"; + }, + repeat(prefix) { + return String(prefix); + } +}; +var push_to_array2 = function(arr, value_or_array) { + Array.prototype.push.apply(arr, isArray2(value_or_array) ? value_or_array : [value_or_array]); +}; +var toISOString2; +var defaults2 = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: encode2, + encodeValuesOnly: false, + format: default_format2, + formatter: default_formatter2, + /** @deprecated */ + indices: false, + serializeDate(date) { + return (toISOString2 ?? (toISOString2 = Function.prototype.call.bind(Date.prototype.toISOString)))(date); + }, + skipNulls: false, + strictNullHandling: false +}; +function is_non_nullish_primitive2(v) { + return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint"; +} +var sentinel2 = {}; +function inner_stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { + let obj = object; + let tmp_sc = sideChannel; + let step = 0; + let find_flag = false; + while ((tmp_sc = tmp_sc.get(sentinel2)) !== void 0 && !find_flag) { + const pos = tmp_sc.get(object); + step += 1; + if (typeof pos !== "undefined") { + if (pos === step) { + throw new RangeError("Cyclic object value"); + } else { + find_flag = true; + } + } + if (typeof tmp_sc.get(sentinel2) === "undefined") { + step = 0; + } + } + if (typeof filter === "function") { + obj = filter(prefix, obj); + } else if (obj instanceof Date) { + obj = serializeDate?.(obj); + } else if (generateArrayPrefix === "comma" && isArray2(obj)) { + obj = maybe_map2(obj, function(value) { + if (value instanceof Date) { + return serializeDate?.(value); + } + return value; + }); + } + if (obj === null) { + if (strictNullHandling) { + return encoder && !encodeValuesOnly ? ( + // @ts-expect-error + encoder(prefix, defaults2.encoder, charset, "key", format) + ) : prefix; + } + obj = ""; + } + if (is_non_nullish_primitive2(obj) || is_buffer2(obj)) { + if (encoder) { + const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults2.encoder, charset, "key", format); + return [ + formatter?.(key_value) + "=" + // @ts-expect-error + formatter?.(encoder(obj, defaults2.encoder, charset, "value", format)) + ]; + } + return [formatter?.(prefix) + "=" + formatter?.(String(obj))]; + } + const values = []; + if (typeof obj === "undefined") { + return values; + } + let obj_keys; + if (generateArrayPrefix === "comma" && isArray2(obj)) { + if (encodeValuesOnly && encoder) { + obj = maybe_map2(obj, encoder); + } + obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray2(filter)) { + obj_keys = filter; + } else { + const keys = Object.keys(obj); + obj_keys = sort ? keys.sort(sort) : keys; + } + const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + const adjusted_prefix = commaRoundTrip && isArray2(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix; + if (allowEmptyArrays && isArray2(obj) && obj.length === 0) { + return adjusted_prefix + "[]"; + } + for (let j = 0; j < obj_keys.length; ++j) { + const key = obj_keys[j]; + const value = ( + // @ts-ignore + typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key] + ); + if (skipNulls && value === null) { + continue; + } + const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key; + const key_prefix = isArray2(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]"); + sideChannel.set(object, step); + const valueSideChannel = /* @__PURE__ */ new WeakMap(); + valueSideChannel.set(sentinel2, sideChannel); + push_to_array2(values, inner_stringify2( + value, + key_prefix, + generateArrayPrefix, + commaRoundTrip, + allowEmptyArrays, + strictNullHandling, + skipNulls, + encodeDotInKeys, + // @ts-ignore + generateArrayPrefix === "comma" && encodeValuesOnly && isArray2(obj) ? null : encoder, + filter, + sort, + allowDots, + serializeDate, + format, + formatter, + encodeValuesOnly, + charset, + valueSideChannel + )); + } + return values; +} +function normalize_stringify_options2(opts = defaults2) { + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") { + throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") { + throw new TypeError("Encoder has to be a function."); + } + const charset = opts.charset || defaults2.charset; + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + let format = default_format2; + if (typeof opts.format !== "undefined") { + if (!has2(formatters2, opts.format)) { + throw new TypeError("Unknown format option provided."); + } + format = opts.format; + } + const formatter = formatters2[format]; + let filter = defaults2.filter; + if (typeof opts.filter === "function" || isArray2(opts.filter)) { + filter = opts.filter; + } + let arrayFormat; + if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators2) { + arrayFormat = opts.arrayFormat; + } else if ("indices" in opts) { + arrayFormat = opts.indices ? "indices" : "repeat"; + } else { + arrayFormat = defaults2.arrayFormat; + } + if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") { + throw new TypeError("`commaRoundTrip` must be a boolean, or absent"); + } + const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults2.addQueryPrefix, + // @ts-ignore + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays, + arrayFormat, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel, + commaRoundTrip: !!opts.commaRoundTrip, + delimiter: typeof opts.delimiter === "undefined" ? defaults2.delimiter : opts.delimiter, + encode: typeof opts.encode === "boolean" ? opts.encode : defaults2.encode, + encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults2.encodeDotInKeys, + encoder: typeof opts.encoder === "function" ? opts.encoder : defaults2.encoder, + encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults2.encodeValuesOnly, + filter, + format, + formatter, + serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults2.serializeDate, + skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults2.skipNulls, + // @ts-ignore + sort: typeof opts.sort === "function" ? opts.sort : null, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling + }; +} +function stringify2(object, opts = {}) { + let obj = object; + const options = normalize_stringify_options2(opts); + let obj_keys; + let filter; + if (typeof options.filter === "function") { + filter = options.filter; + obj = filter("", obj); + } else if (isArray2(options.filter)) { + filter = options.filter; + obj_keys = filter; + } + const keys = []; + if (typeof obj !== "object" || obj === null) { + return ""; + } + const generateArrayPrefix = array_prefix_generators2[options.arrayFormat]; + const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip; + if (!obj_keys) { + obj_keys = Object.keys(obj); + } + if (options.sort) { + obj_keys.sort(options.sort); + } + const sideChannel = /* @__PURE__ */ new WeakMap(); + for (let i = 0; i < obj_keys.length; ++i) { + const key = obj_keys[i]; + if (options.skipNulls && obj[key] === null) { + continue; + } + push_to_array2(keys, inner_stringify2( + obj[key], + key, + // @ts-expect-error + generateArrayPrefix, + commaRoundTrip, + options.allowEmptyArrays, + options.strictNullHandling, + options.skipNulls, + options.encodeDotInKeys, + options.encode ? options.encoder : null, + options.filter, + options.sort, + options.allowDots, + options.serializeDate, + options.format, + options.formatter, + options.encodeValuesOnly, + options.charset, + sideChannel + )); + } + const joined = keys.join(options.delimiter); + let prefix = options.addQueryPrefix === true ? "?" : ""; + if (options.charsetSentinel) { + if (options.charset === "iso-8859-1") { + prefix += "utf8=%26%2310003%3B&"; + } else { + prefix += "utf8=%E2%9C%93&"; + } + } + return joined.length > 0 ? prefix + joined : ""; +} + +// node_modules/@stainless-api/github-internal/lib/secrets.mjs +var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1); + +// node_modules/@stainless-api/github-internal/internal/utils/env.mjs +var readEnv2 = (env) => { + if (typeof globalThis.process !== "undefined") { + return globalThis.process.env?.[env]?.trim() ?? void 0; + } + if (typeof globalThis.Deno !== "undefined") { + return globalThis.Deno.env?.get?.(env)?.trim(); + } + return void 0; +}; + +// node_modules/@stainless-api/github-internal/client.mjs +var _BaseGitHub_instances; +var _BaseGitHub_encoder; +var _BaseGitHub_baseURLOverridden; +var BaseGitHub = /* @__PURE__ */ (() => { + class BaseGitHub2 { + /** + * API Client for interfacing with the GitHub API. + * + * @param {string | null | undefined} [opts.authToken=process.env['GITHUB_AUTH_TOKEN'] ?? null] + * @param {string | null | undefined} [opts.owner] + * @param {string | null | undefined} [opts.repo] + * @param {string} [opts.baseURL=process.env['GITHUB_BASE_URL'] ?? https://api.github.com] - Override the default base URL for the API. + * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out. + * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls. + * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation. + * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request. + * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API. + * @param {Record} opts.defaultQuery - Default query parameters to include with every request to the API. + */ + constructor({ baseURL = readEnv2("GITHUB_BASE_URL"), authToken = readEnv2("GITHUB_AUTH_TOKEN") ?? null, owner = null, repo = null, ...opts } = {}) { + _BaseGitHub_instances.add(this); + _BaseGitHub_encoder.set(this, void 0); + const options = { + authToken, + owner, + repo, + ...opts, + baseURL: baseURL || `https://api.github.com` + }; + this.baseURL = options.baseURL; + this.timeout = options.timeout ?? BaseGitHub2.DEFAULT_TIMEOUT; + this.logger = options.logger ?? console; + const defaultLogLevel = "warn"; + this.logLevel = defaultLogLevel; + this.logLevel = parseLogLevel2(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel2(readEnv2("GITHUB_LOG"), "process.env['GITHUB_LOG']", this) ?? defaultLogLevel; + this.fetchOptions = options.fetchOptions; + this.maxRetries = options.maxRetries ?? 2; + this.fetch = options.fetch ?? getDefaultFetch2(); + __classPrivateFieldSet2(this, _BaseGitHub_encoder, FallbackEncoder2, "f"); + this._options = options; + this.authToken = authToken; + this.owner = owner; + this.repo = repo; + } + /** + * Create a new client instance re-using the same options given to the current client with optional overriding. + */ + withOptions(options) { + return new this.constructor({ + ...this._options, + baseURL: this.baseURL, + maxRetries: this.maxRetries, + timeout: this.timeout, + logger: this.logger, + logLevel: this.logLevel, + fetch: this.fetch, + fetchOptions: this.fetchOptions, + authToken: this.authToken, + owner: this.owner, + repo: this.repo, + ...options + }); + } + /** + * Get Hypermedia links to resources accessible in GitHub's REST API + */ + retrieve(options) { + return this.get("/", options); + } + /** + * Get a random sentence from the Zen of GitHub + */ + zen(options) { + return this.get("/zen", { + ...options, + headers: buildHeaders2([{ Accept: "text/plain" }, options?.headers]) + }); + } + defaultQuery() { + return this._options.defaultQuery; + } + validateHeaders({ values, nulls }) { + return; + } + authHeaders(opts) { + if (this.authToken == null) { + return void 0; + } + return buildHeaders2([{ Authorization: `Bearer ${this.authToken}` }]); + } + stringifyQuery(query) { + return stringify2(query, { arrayFormat: "comma" }); + } + getUserAgent() { + return `${this.constructor.name}/JS ${VERSION2}`; + } + defaultIdempotencyKey() { + return `stainless-node-retry-${uuid42()}`; + } + makeStatusError(status, error, message, headers) { + return APIError2.generate(status, error, message, headers); + } + buildURL(path3, query, defaultBaseURL) { + const baseURL = !__classPrivateFieldGet2(this, _BaseGitHub_instances, "m", _BaseGitHub_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL; + const url = isAbsoluteURL2(path3) ? new URL(path3) : new URL(baseURL + (baseURL.endsWith("/") && path3.startsWith("/") ? path3.slice(1) : path3)); + const defaultQuery = this.defaultQuery(); + if (!isEmptyObj2(defaultQuery)) { + query = { ...defaultQuery, ...query }; + } + if (typeof query === "object" && query && !Array.isArray(query)) { + url.search = this.stringifyQuery(query); + } + return url.toString(); + } + /** + * Used as a callback for mutating the given `FinalRequestOptions` object. + */ + async prepareOptions(options) { + } + /** + * Used as a callback for mutating the given `RequestInit` object. + * + * This is useful for cases where you want to add certain headers based off of + * the request properties, e.g. `method` or `url`. + */ + async prepareRequest(request, { url, options }) { + } + get(path3, opts) { + return this.methodRequest("get", path3, opts); + } + post(path3, opts) { + return this.methodRequest("post", path3, opts); + } + patch(path3, opts) { + return this.methodRequest("patch", path3, opts); + } + put(path3, opts) { + return this.methodRequest("put", path3, opts); + } + delete(path3, opts) { + return this.methodRequest("delete", path3, opts); + } + methodRequest(method, path3, opts) { + return this.request(Promise.resolve(opts).then((opts2) => { + return { method, path: path3, ...opts2 }; + })); + } + request(options, remainingRetries = null) { + return new APIPromise2(this, this.makeRequest(options, remainingRetries, void 0)); + } + async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { + const options = await optionsInput; + const maxRetries = options.maxRetries ?? this.maxRetries; + if (retriesRemaining == null) { + retriesRemaining = maxRetries; + } + await this.prepareOptions(options); + const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); + await this.prepareRequest(req, { url, options }); + const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0"); + const retryLogStr = retryOfRequestLogID === void 0 ? "" : `, retryOf: ${retryOfRequestLogID}`; + const startTime = Date.now(); + loggerFor2(this).debug(`[${requestLogID}] sending request`, formatRequestDetails2({ + retryOfRequestLogID, + method: options.method, + url, + options, + headers: req.headers + })); + if (options.signal?.aborted) { + throw new APIUserAbortError2(); + } + const controller = new AbortController(); + const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError2); + const headersTime = Date.now(); + if (response instanceof Error) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (options.signal?.aborted) { + throw new APIUserAbortError2(); + } + const isTimeout = isAbortError2(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : "")); + if (retriesRemaining) { + loggerFor2(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`); + loggerFor2(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails2({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID); + } + loggerFor2(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`); + loggerFor2(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails2({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + if (isTimeout) { + throw new APIConnectionTimeoutError2(); + } + throw new APIConnectionError2({ cause: response }); + } + const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`; + if (!response.ok) { + const shouldRetry = this.shouldRetry(response); + if (retriesRemaining && shouldRetry) { + const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`; + await CancelReadableStream2(response.body); + loggerFor2(this).info(`${responseInfo} - ${retryMessage2}`); + loggerFor2(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers); + } + const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`; + loggerFor2(this).info(`${responseInfo} - ${retryMessage}`); + const errText = await response.text().catch((err2) => castToError2(err2).message); + const errJSON = safeJSON2(errText); + const errMessage = errJSON ? void 0 : errText; + loggerFor2(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + message: errMessage, + durationMs: Date.now() - startTime + })); + const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers); + throw err; + } + loggerFor2(this).info(responseInfo); + loggerFor2(this).debug(`[${requestLogID}] response start`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return { response, options, controller, requestLogID, retryOfRequestLogID, startTime }; + } + getAPIList(path3, Page2, opts) { + return this.requestAPIList(Page2, { method: "get", path: path3, ...opts }); + } + requestAPIList(Page2, options) { + const request = this.makeRequest(options, null, void 0); + return new PagePromise2(this, request, Page2); + } + async fetchWithTimeout(url, init, ms, controller) { + const { signal, method, ...options } = init || {}; + if (signal) + signal.addEventListener("abort", () => controller.abort()); + const timeout = setTimeout(() => controller.abort(), ms); + const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body; + const fetchOptions = { + signal: controller.signal, + ...isReadableBody ? { duplex: "half" } : {}, + method: "GET", + ...options + }; + if (method) { + fetchOptions.method = method.toUpperCase(); + } + try { + return await this.fetch.call(void 0, url, fetchOptions); + } finally { + clearTimeout(timeout); + } + } + shouldRetry(response) { + const shouldRetryHeader = response.headers.get("x-should-retry"); + if (shouldRetryHeader === "true") + return true; + if (shouldRetryHeader === "false") + return false; + if (response.status === 408) + return true; + if (response.status === 409) + return true; + if (response.status === 429) + return true; + if (response.status >= 500) + return true; + return false; + } + async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) { + let timeoutMillis; + const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms"); + if (retryAfterMillisHeader) { + const timeoutMs = parseFloat(retryAfterMillisHeader); + if (!Number.isNaN(timeoutMs)) { + timeoutMillis = timeoutMs; + } + } + const retryAfterHeader = responseHeaders?.get("retry-after"); + if (retryAfterHeader && !timeoutMillis) { + const timeoutSeconds = parseFloat(retryAfterHeader); + if (!Number.isNaN(timeoutSeconds)) { + timeoutMillis = timeoutSeconds * 1e3; + } else { + timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + } + if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3)) { + const maxRetries = options.maxRetries ?? this.maxRetries; + timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); + } + await sleep2(timeoutMillis); + return this.makeRequest(options, retriesRemaining - 1, requestLogID); + } + calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) { + const initialRetryDelay = 0.5; + const maxRetryDelay = 8; + const numRetries = maxRetries - retriesRemaining; + const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay); + const jitter = 1 - Math.random() * 0.25; + return sleepSeconds * jitter * 1e3; + } + buildRequest(inputOptions, { retryCount = 0 } = {}) { + const options = { ...inputOptions }; + const { method, path: path3, query, defaultBaseURL } = options; + const url = this.buildURL(path3, query, defaultBaseURL); + if ("timeout" in options) + validatePositiveInteger2("timeout", options.timeout); + options.timeout = options.timeout ?? this.timeout; + const { bodyHeaders, body } = this.buildBody({ options }); + const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount }); + const req = { + method, + headers: reqHeaders, + ...options.signal && { signal: options.signal }, + ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" }, + ...body && { body }, + ...this.fetchOptions ?? {}, + ...options.fetchOptions ?? {} + }; + return { req, url, timeout: options.timeout }; + } + buildHeaders({ options, method, bodyHeaders, retryCount }) { + let idempotencyHeaders = {}; + if (this.idempotencyHeader && method !== "get") { + if (!options.idempotencyKey) + options.idempotencyKey = this.defaultIdempotencyKey(); + idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; + } + const headers = buildHeaders2([ + idempotencyHeaders, + { + Accept: "application/json", + "User-Agent": this.getUserAgent(), + "X-Stainless-Retry-Count": String(retryCount), + ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1e3)) } : {}, + ...getPlatformHeaders2() + }, + this.authHeaders(options), + this._options.defaultHeaders, + bodyHeaders, + options.headers + ]); + this.validateHeaders(headers); + return headers.values; + } + buildBody({ options: { body, headers: rawHeaders } }) { + if (!body) { + return { bodyHeaders: void 0, body: void 0 }; + } + const headers = buildHeaders2([rawHeaders]); + if ( + // Pass raw type verbatim + ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && // Preserve legacy string encoding behavior for now + headers.values.has("content-type") || // `Blob` is superset of `File` + body instanceof Blob || // `FormData` -> `multipart/form-data` + body instanceof FormData || // `URLSearchParams` -> `application/x-www-form-urlencoded` + body instanceof URLSearchParams || // Send chunked stream (each chunk has own `length`) + globalThis.ReadableStream && body instanceof globalThis.ReadableStream + ) { + return { bodyHeaders: void 0, body }; + } else if (typeof body === "object" && (Symbol.asyncIterator in body || Symbol.iterator in body && "next" in body && typeof body.next === "function")) { + return { bodyHeaders: void 0, body: ReadableStreamFrom2(body) }; + } else { + return __classPrivateFieldGet2(this, _BaseGitHub_encoder, "f").call(this, { body, headers }); + } + } + } + _BaseGitHub_encoder = /* @__PURE__ */ new WeakMap(), _BaseGitHub_instances = /* @__PURE__ */ new WeakSet(), _BaseGitHub_baseURLOverridden = function _BaseGitHub_baseURLOverridden2() { + return this.baseURL !== "https://api.github.com"; + }; + BaseGitHub2.DEFAULT_TIMEOUT = 6e4; + return BaseGitHub2; +})(); + +// node_modules/@stainless-api/github-internal/tree-shakable.mjs +function createClient(options) { + const client = new BaseGitHub(options); + for (const ResourceClass of options.resources) { + const resourceInstance = new ResourceClass(client); + let object = client; + for (const part of ResourceClass._key.slice(0, -1)) { + if (hasOwn2(object, part)) { + object = object[part]; + } else { + Object.defineProperty(object, part, { + value: object = {}, + configurable: true, + enumerable: true, + writable: true + }); + } + } + const name = ResourceClass._key.at(-1); + if (!hasOwn2(object, name)) { + Object.defineProperty(object, name, { + value: resourceInstance, + configurable: true, + enumerable: true, + writable: true + }); + } else { + if (object[name] instanceof APIResource2) { + throw new TypeError(`Resource at ${ResourceClass._key.join(".")} already exists!`); + } else { + object[name] = Object.assign(resourceInstance, object[name]); + } + } + } + return client; +} + +// src/markdown.ts +var import_ts_dedent = __toESM(require_dist()); +var Symbol2 = { + Bulb: "\u{1F4A1}", + Exclamation: "\u2757", + GreenSquare: "\u{1F7E9}", + HeavyAsterisk: "\u2731", + HourglassFlowingSand: "\u23F3", + MiddleDot: "\xB7", + RedSquare: "\u{1F7E5}", + RightwardsArrow: "\u2192", + SpeechBalloon: "\u{1F4AC}", + Warning: "\u26A0\uFE0F", + WhiteCheckMark: "\u2705", + WhiteLargeSquare: "\u2B1C", + Zap: "\u26A1" +}; +var Bold = (content) => `${content}`; +var CodeInline = (content) => `${content}`; +var Comment = (content) => ``; +var Italic = (content) => `${content}`; +function Dedent(templ, ...args) { + return (0, import_ts_dedent.dedent)(templ, ...args).trim().replaceAll(/\n\s*\n/gi, "\n\n"); +} +var Blockquote = (content) => Dedent` +
+ + ${content} + +
+ `; +var CodeBlock = (props) => { + const delimiter = "```"; + const content = typeof props === "string" ? props : props.content; + const language = typeof props === "string" ? "" : props.language; + return Dedent` + ${delimiter}${language} + ${content} + ${delimiter} + `; +}; +var Details = ({ + summary, + body, + indent = true, + open = false +}) => { + return Dedent` + + ${summary} + + ${indent ? Blockquote(body) : body} + + + `; +}; +var Heading = (content) => `

${content}

`; +var Link = ({ text, href }) => `${text}`; +var List = (lines) => { + return Dedent` +
    + ${lines.map((line) => `
  • ${line}
    • `).join("\n")} +
+ `; +}; + +// src/comment.ts +var DiagnosticIcon = { + fatal: Symbol2.Exclamation, + error: Symbol2.Exclamation, + warning: Symbol2.Warning, + note: Symbol2.Bulb +}; +var COMMENT_TITLE = Heading( + `${Symbol2.HeavyAsterisk} Stainless SDK previews` +); +function printComment({ + noChanges, + orgName, + projectName, + branch, + commitMessage, + baseOutcomes, + outcomes +}) { + const blocks = (() => { + if (noChanges) { + return "No changes were made to the SDKs."; + } + const details = getDetails({ base: baseOutcomes, head: outcomes }); + return [ + printCommitMessage({ + commitMessage, + projectName, + // Can edit if this is a preview comment (and thus baseOutcomes exist). + // Otherwise, this is post-merge and editing it won't do anything. + canEdit: !!baseOutcomes + }), + printFailures({ orgName, projectName, branch, outcomes }), + printMergeConflicts({ projectName, outcomes }), + printRegressions({ orgName, projectName, branch, details }), + printSuccesses({ orgName, projectName, branch, details }), + printPending({ details }) + ].filter((f) => f !== null).join(` + +`); + })(); + return Dedent` + ${COMMENT_TITLE} + + ${Italic( + `Last updated: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}` + )} + + ${blocks} + `; +} +function printCommitMessage({ + commitMessage, + projectName, + canEdit +}) { + return Dedent` + ${Symbol2.SpeechBalloon} This PR updates ${CodeInline( + projectName + )} SDKs with this commit message.${canEdit ? " To change the commit message, edit this comment." : ""} + + ${canEdit ? Comment( + "Replace the contents of this code block with your commit message. Use a commit message in the conventional commits format: https://www.conventionalcommits.org/en/v1.0.0/" + ) : ""} + ${CodeBlock(commitMessage)} + `; +} +function printFailures({ + orgName, + projectName, + branch, + outcomes +}) { + const failures = Object.entries(outcomes).map(([lang, outcome]) => { + switch (outcome.commit.completed.conclusion) { + case "noop": + case "error": + case "warning": + case "note": + case "success": + case "merge_conflict": + case "upstream_merge_conflict": { + return null; + } + case "fatal": { + return [lang, `Fatal error.`]; + } + case "timed_out": { + return [lang, `Timed out.`]; + } + default: { + return [ + lang, + `Unknown conclusion (${CodeInline( + outcome.commit.completed.conclusion + )}).` + ]; + } + } + }).filter((f) => f !== null); + if (!failures.length) { + return null; + } + const studioURL = getStudioURL({ orgName, projectName, branch }); + const studioLink = Link({ text: "Stainless Studio", href: studioURL }); + return Dedent` + ${Symbol2.Exclamation} ${Bold( + "Failures." + )} See the ${studioLink} for details. + + ${List( + failures.map(([lang, message]) => `${projectName}-${lang}: ${message}`) + )} + `; +} +function printMergeConflicts({ + projectName, + outcomes +}) { + const mergeConflicts = Object.entries(outcomes).map(([lang, outcome]) => { + if (!outcome.commit.completed.merge_conflict_pr) { + return null; + } + const { + number, + repo: { owner, name } + } = outcome.commit.completed.merge_conflict_pr; + const url = `https://github.com/${owner}/${name}/pull/${number}`; + if (outcome.commit.completed.conclusion === "upstream_merge_conflict") { + return [ + lang, + `The base branch has a conflict. ${Link({ + text: "Link to conflict.", + href: url + })}` + ]; + } + return [lang, `${Link({ text: "Link to conflict.", href: url })}`]; + }).filter((f) => f !== null); + if (!mergeConflicts.length) { + return null; + } + const runURL = `https://github.com/${github.context.repo.owner}/${github.context.repo.repo}/actions/runs/${github.context.runId}`; + return Dedent` + ${Symbol2.Zap} ${Bold( + "Merge conflicts." + )} You can resolve conflicts now; if you do, ${Link({ + text: "re-run this GitHub action", + href: runURL + })} to get diffs. If you merge before resolving conflicts, new conflict PRs will be created after merging. + + ${List( + mergeConflicts.map( + ([lang, message]) => `${projectName}-${lang}: ${message}` + ) + )} + `; +} +function getDetails({ + base, + head +}) { + const result = {}; + for (const [lang, outcome] of Object.entries(head)) { + if (!["error", "warning", "note", "success"].includes( + outcome.commit.completed.conclusion + )) { + continue; + } + const details = []; + const baseOutcome = base?.[lang]; + let githubLink = null; + let compareLink = null; + let isPending = false; + let isRegression = false; + if (outcome.commit.completed.commit) { + const { + repo: { owner, name, branch } + } = outcome.commit.completed.commit; + const githubURL = `https://github.com/${owner}/${name}/tree/${branch}`; + githubLink = Link({ text: "code", href: githubURL }); + } + if (baseOutcome?.commit.completed.commit && outcome.commit.completed.commit) { + const { + repo: { owner, name } + } = outcome.commit.completed.commit; + const base2 = baseOutcome.commit.completed.commit.repo.branch; + const head2 = outcome.commit.completed.commit.repo.branch; + const compareURL = `https://github.com/${owner}/${name}/compare/${base2}..${head2}`; + compareLink = Link({ text: "diff", href: compareURL }); + } + for (const check of ["build", "lint", "test"]) { + const checkName = check === "build" ? "Build" : check === "lint" ? "Lint" : "Test"; + if ((!baseOutcome?.[check] || baseOutcome[check].status === "completed" && baseOutcome[check].completed.conclusion === "success") && outcome[check] && outcome[check].status === "completed" && outcome[check].completed.conclusion === "failure") { + const baseURL = baseOutcome?.[check]?.status === "completed" ? baseOutcome[check].completed.url : null; + const baseText = `${Symbol2.WhiteCheckMark} success`; + const baseLink = baseURL ? Link({ text: baseText, href: baseURL }) : null; + const headURL = outcome[check].completed.url; + const headText = `${Symbol2.Exclamation} failure`; + const headLink = headURL ? Link({ text: headText, href: headURL }) : headText; + if (baseLink) { + details.push( + `${checkName}: ${baseLink} ${Symbol2.RightwardsArrow} ${headLink}` + ); + } else { + details.push(`${checkName}: ${headLink}`); + } + isRegression = true; + } + if (baseOutcome?.[check] && baseOutcome[check].status !== "completed" || outcome[check] && outcome[check].status !== "completed") { + details.push(`${checkName}: ${Symbol2.HourglassFlowingSand} pending`); + isPending = true; + } + } + if (baseOutcome?.diagnostics && outcome.diagnostics) { + const newDiagnostics = outcome.diagnostics.filter( + (d) => !baseOutcome.diagnostics.some( + (bd) => bd.code === d.code && bd.message === d.message && bd.config_ref === d.config_ref && bd.oas_ref === d.oas_ref + ) + ); + if (newDiagnostics.length > 0) { + const levelCounts = { + fatal: 0, + error: 0, + warning: 0, + note: 0 + }; + for (const d of newDiagnostics) { + levelCounts[d.level]++; + } + if (levelCounts.fatal > 0 || levelCounts.error > 0 || levelCounts.warning > 0) { + isRegression = true; + } + const diagnosticCounts = Object.entries(levelCounts).filter(([, count]) => count > 0).map(([level, count]) => `${count} ${level}`); + let hasOmittedDiagnostics = newDiagnostics.length > 10; + const diagnosticList = newDiagnostics.slice(0, 10).map((d) => { + if (d.level === "note") { + hasOmittedDiagnostics = true; + return null; + } + return `${DiagnosticIcon[d.level]} ${Bold(d.code)}: ${d.message}`; + }).filter(Boolean); + details.push( + Details({ + summary: `New diagnostics (${diagnosticCounts.join(", ")})`, + body: Dedent` + ${hasOmittedDiagnostics ? "Some diagnostics omitted. " : ""}See the Stainless Studio for more details. + + ${List(diagnosticList)} + ` + }) + ); + } + } + const installation = getInstallation(lang, outcome); + if (installation) { + details.push( + Details({ + summary: "Installation", + body: CodeBlock({ content: installation, language: "bash" }), + indent: false + }) + ); + } + result[lang] = { + githubLink, + compareLink, + details, + isPending, + isRegression + }; + } + return result; +} +function printRegressions({ + orgName, + projectName, + branch, + details +}) { + const regressions = Object.entries(details).filter( + ([, { isRegression }]) => isRegression + ); + if (regressions.length === 0) { + return null; + } + const formattedRegressions = regressions.map( + ([lang, { githubLink, compareLink, details: details2 }]) => { + const studioURL = getStudioURL({ + orgName, + projectName, + language: lang, + branch + }); + const studioLink = Link({ text: "studio", href: studioURL }); + const headingLinks = [studioLink, githubLink, compareLink].filter((link) => link !== null).join(` ${Symbol2.MiddleDot} `); + return Details({ + summary: `${projectName}-${lang}: ${headingLinks}`, + body: details2.join("\n\n"), + open: true + }); + } + ); + return Dedent` + ${Symbol2.Warning} ${Bold("Regressions.")} + + ${formattedRegressions.join("\n\n")} + `; +} +function printSuccesses({ + orgName, + projectName, + branch, + details +}) { + const successes = Object.entries(details).filter( + ([, { isPending, isRegression }]) => !isPending && !isRegression + ); + if (successes.length === 0) { + return null; + } + const formattedSuccesses = successes.map( + ([lang, { githubLink, compareLink, details: details2 }]) => { + const studioURL = getStudioURL({ + orgName, + projectName, + language: lang, + branch + }); + const studioLink = Link({ text: "studio", href: studioURL }); + const headingLinks = [studioLink, githubLink, compareLink].filter((link) => link !== null).join(` ${Symbol2.MiddleDot} `); + const summary = `${projectName}-${lang}: ${headingLinks}`; + return details2.length > 0 ? Details({ summary, body: details2.join("\n\n") }) : `- ${summary}`; + } + ); + return Dedent` + ${Symbol2.WhiteCheckMark} ${Bold("Successes.")} + + ${formattedSuccesses.join("\n\n")} + `; +} +function printPending({ details }) { + const hasPending = Object.values(details).some(({ isPending }) => isPending); + if (!hasPending) { + return null; + } + return Dedent` + ${Symbol2.HourglassFlowingSand} These are partial results; builds are still running. + `; +} +function getInstallation(lang, outcome) { + if (!outcome.commit.completed.commit) { + return null; + } + const { repo } = outcome.commit.completed.commit; + switch (lang) { + case "typescript": + case "node": { + return `npm install ${getGitHubURL({ repo })}`; + } + case "python": { + return `pip install git+${getGitHubURL({ repo })}`; + } + default: { + return null; + } + } +} +function getGitHubURL({ + repo +}) { + return `https://github.com/${repo.owner}/${repo.name}.git#${repo.branch}`; +} +function getStudioURL({ + orgName, + projectName, + language, + branch +}) { + if (language) { + return `https://app.stainless.com/${orgName}/${projectName}/studio?language=${language}&branch=${branch}`; + } + return `https://app.stainless.com/${orgName}/${projectName}/studio?branch=${branch}`; +} +function parseCommitMessage(body) { + return body?.match(/(? comment.body?.includes(COMMENT_TITLE)) ?? null; + return { + id: existingComment?.id, + commitMessage: parseCommitMessage(existingComment?.body) + }; +} +async function upsertComment({ + body, + token, + skipCreate = false +}) { + const client = createClient({ + authToken: token, + owner: github.context.repo.owner, + repo: github.context.repo.repo, + resources: [Comments] + }); + console.log("Upserting comment on PR:", github.context.issue.number); + const { data: comments } = await client.repos.issues.comments.list( + github.context.issue.number + ); + const firstLine = body.trim().split("\n")[0]; + const existingComment = comments.find( + (comment) => comment.body?.includes(firstLine) + ); + if (existingComment) { + console.log("Updating existing comment:", existingComment.id); + await client.repos.issues.comments.update(existingComment.id, { body }); + } else if (!skipCreate) { + console.log("Creating new comment"); + await client.repos.issues.comments.create(github.context.issue.number, { + body + }); + } +} + +// src/config.ts +var exec = __toESM(require_exec()); +async function isConfigChanged({ + before, + after, + oasPath, + configPath +}) { + await exec.exec("git", ["fetch", "--depth=1", "origin", before], { + silent: true + }); + await exec.exec("git", ["fetch", "--depth=1", "origin", after], { + silent: true + }); + const diffOutput = await exec.getExecOutput("git", [ + "diff", + "--name-only", + before, + after + ]); + const changedFiles = diffOutput.stdout.trim().split("\n"); + let changed = false; + if (oasPath && changedFiles.includes(oasPath)) { + console.log("OAS file changed"); + changed = true; + } + if (configPath && changedFiles.includes(configPath)) { + console.log("Config file changed"); + changed = true; + } + return changed; +} + +// src/merge.ts +async function main() { + try { + const apiKey = (0, import_core.getInput)("stainless_api_key", { required: true }); + const orgName = (0, import_core.getInput)("org", { required: false }); + const projectName = (0, import_core.getInput)("project", { required: true }); + const oasPath = (0, import_core.getInput)("oas_path", { required: false }); + const configPath = (0, import_core.getInput)("config_path", { required: false }) || void 0; + const defaultCommitMessage = (0, import_core.getInput)("commit_message", { required: true }); + const failRunOn = (0, import_core.getInput)("fail_on", { required: true }) || "error"; + const makeComment = (0, import_core.getBooleanInput)("make_comment", { required: true }); + const githubToken = (0, import_core.getInput)("github_token", { required: false }); + const baseSha = (0, import_core.getInput)("base_sha", { required: true }); + const baseRef = (0, import_core.getInput)("base_ref", { required: true }); + const defaultBranch = (0, import_core.getInput)("default_branch", { required: true }); + const headSha = (0, import_core.getInput)("head_sha", { required: true }); + const mergeBranch = (0, import_core.getInput)("merge_branch", { required: true }); + const outputDir = (0, import_core.getInput)("output_dir", { required: false }) || void 0; + if (makeComment && !githubToken) { + throw new Error("github_token is required to make a comment"); + } + if (baseRef !== defaultBranch) { + console.log("Not merging to default branch, skipping merge"); + return; + } + const stainless = new Stainless({ + project: projectName, + apiKey, + logLevel: "warn" + }); + const configChanged = await isConfigChanged({ + before: baseSha, + after: headSha, + oasPath, + configPath + }); + if (!configChanged) { + console.log("No config files changed, skipping merge"); + return; + } + let commitMessage = defaultCommitMessage; + if (makeComment && githubToken) { + const comment = await retrieveComment({ token: githubToken }); + if (comment.commitMessage) { + commitMessage = comment.commitMessage; + } + } + console.log("Using commit message:", commitMessage); + const generator = runBuilds({ + stainless, + projectName, + commitMessage, + // This action always merges to the Stainless `main` branch: + branch: "main", + mergeBranch, + guessConfig: false, + outputDir + }); + let latestRun; + while (true) { + (0, import_core.startGroup)("Running builds"); + const run = await generator.next(); + (0, import_core.endGroup)(); + if (run.done) { + const { outcomes, documentedSpecPath } = latestRun; + (0, import_core.setOutput)("outcomes", outcomes); + (0, import_core.setOutput)("documented_spec_path", documentedSpecPath); + if (!checkResults({ outcomes, failRunOn })) { + process.exit(1); + } + break; + } + latestRun = run.value; + if (makeComment) { + const { outcomes } = latestRun; + (0, import_core.startGroup)("Updating comment"); + const commentBody = printComment({ + orgName, + projectName, + branch: "main", + commitMessage, + outcomes + }); + await upsertComment({ body: commentBody, token: githubToken }); + (0, import_core.endGroup)(); + } + } + } catch (error) { + console.error("Error in merge action:", error); + process.exit(1); + } +} +main(); +/*! Bundled license information: + +undici/lib/fetch/body.js: + (*! formdata-polyfill. MIT License. Jimmy Wärting *) + +undici/lib/websocket/frame.js: + (*! ws. MIT License. Einar Otto Stangvik *) +*/ diff --git a/dist/preview.js b/dist/preview.js new file mode 100644 index 00000000..a795868e --- /dev/null +++ b/dist/preview.js @@ -0,0 +1,33784 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +// node_modules/@actions/core/lib/utils.js +var require_utils = __commonJS({ + "node_modules/@actions/core/lib/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.toCommandProperties = exports2.toCommandValue = void 0; + function toCommandValue(input) { + if (input === null || input === void 0) { + return ""; + } else if (typeof input === "string" || input instanceof String) { + return input; + } + return JSON.stringify(input); + } + exports2.toCommandValue = toCommandValue; + function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; + } + exports2.toCommandProperties = toCommandProperties; + } +}); + +// node_modules/@actions/core/lib/command.js +var require_command = __commonJS({ + "node_modules/@actions/core/lib/command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.issue = exports2.issueCommand = void 0; + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); + } + exports2.issueCommand = issueCommand; + function issue(name, message = "") { + issueCommand(name, {}, message); + } + exports2.issue = issue; + var CMD_STRING = "::"; + var Command = class { + constructor(command, properties, message) { + if (!command) { + command = "missing.command"; + } + this.command = command; + this.properties = properties; + this.message = message; + } + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += " "; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } else { + cmdStr += ","; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; + } + }; + function escapeData(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A"); + } + function escapeProperty(s) { + return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C"); + } + } +}); + +// node_modules/@actions/core/lib/file-command.js +var require_file_command = __commonJS({ + "node_modules/@actions/core/lib/file-command.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.prepareKeyValueMessage = exports2.issueFileCommand = void 0; + var crypto = __importStar(require("crypto")); + var fs2 = __importStar(require("fs")); + var os = __importStar(require("os")); + var utils_1 = require_utils(); + function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs2.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs2.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { + encoding: "utf8" + }); + } + exports2.issueFileCommand = issueFileCommand; + function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${crypto.randomUUID()}`; + const convertedValue = (0, utils_1.toCommandValue)(value); + if (key.includes(delimiter)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + } + if (convertedValue.includes(delimiter)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + } + return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; + } + exports2.prepareKeyValueMessage = prepareKeyValueMessage; + } +}); + +// node_modules/@actions/http-client/lib/proxy.js +var require_proxy = __commonJS({ + "node_modules/@actions/http-client/lib/proxy.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.checkBypass = exports2.getProxyUrl = void 0; + function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === "https:"; + if (checkBypass(reqUrl)) { + return void 0; + } + const proxyVar = (() => { + if (usingSsl) { + return process.env["https_proxy"] || process.env["HTTPS_PROXY"]; + } else { + return process.env["http_proxy"] || process.env["HTTP_PROXY"]; + } + })(); + if (proxyVar) { + try { + return new DecodedURL(proxyVar); + } catch (_a2) { + if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) + return new DecodedURL(`http://${proxyVar}`); + } + } else { + return void 0; + } + } + exports2.getProxyUrl = getProxyUrl; + function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) { + return true; + } + const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || ""; + if (!noProxy) { + return false; + } + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } else if (reqUrl.protocol === "http:") { + reqPort = 80; + } else if (reqUrl.protocol === "https:") { + reqPort = 443; + } + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === "number") { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) { + if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) { + return true; + } + } + return false; + } + exports2.checkBypass = checkBypass; + function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]"); + } + var DecodedURL = class extends URL { + constructor(url, base) { + super(url, base); + this._decodedUsername = decodeURIComponent(super.username); + this._decodedPassword = decodeURIComponent(super.password); + } + get username() { + return this._decodedUsername; + } + get password() { + return this._decodedPassword; + } + }; + } +}); + +// node_modules/tunnel/lib/tunnel.js +var require_tunnel = __commonJS({ + "node_modules/tunnel/lib/tunnel.js"(exports2) { + "use strict"; + var net = require("net"); + var tls = require("tls"); + var http = require("http"); + var https = require("https"); + var events = require("events"); + var assert = require("assert"); + var util = require("util"); + exports2.httpOverHttp = httpOverHttp; + exports2.httpsOverHttp = httpsOverHttp; + exports2.httpOverHttps = httpOverHttps; + exports2.httpsOverHttps = httpsOverHttps; + function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; + } + function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; + } + function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; + } + function TunnelingAgent(options) { + var self2 = this; + self2.options = options || {}; + self2.proxyOptions = self2.options.proxy || {}; + self2.maxSockets = self2.options.maxSockets || http.Agent.defaultMaxSockets; + self2.requests = []; + self2.sockets = []; + self2.on("free", function onFree(socket, host, port, localAddress) { + var options2 = toOptions(host, port, localAddress); + for (var i = 0, len = self2.requests.length; i < len; ++i) { + var pending = self2.requests[i]; + if (pending.host === options2.host && pending.port === options2.port) { + self2.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self2.removeSocket(socket); + }); + } + util.inherits(TunnelingAgent, events.EventEmitter); + TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self2 = this; + var options = mergeOptions({ request: req }, self2.options, toOptions(host, port, localAddress)); + if (self2.sockets.length >= this.maxSockets) { + self2.requests.push(options); + return; + } + self2.createSocket(options, function(socket) { + socket.on("free", onFree); + socket.on("close", onCloseOrRemove); + socket.on("agentRemove", onCloseOrRemove); + req.onSocket(socket); + function onFree() { + self2.emit("free", socket, options); + } + function onCloseOrRemove(err) { + self2.removeSocket(socket); + socket.removeListener("free", onFree); + socket.removeListener("close", onCloseOrRemove); + socket.removeListener("agentRemove", onCloseOrRemove); + } + }); + }; + TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self2 = this; + var placeholder = {}; + self2.sockets.push(placeholder); + var connectOptions = mergeOptions({}, self2.proxyOptions, { + method: "CONNECT", + path: options.host + ":" + options.port, + agent: false, + headers: { + host: options.host + ":" + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64"); + } + debug("making CONNECT request"); + var connectReq = self2.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; + connectReq.once("response", onResponse); + connectReq.once("upgrade", onUpgrade); + connectReq.once("connect", onConnect); + connectReq.once("error", onError); + connectReq.end(); + function onResponse(res) { + res.upgrade = true; + } + function onUpgrade(res, socket, head) { + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + if (res.statusCode !== 200) { + debug( + "tunneling socket could not be established, statusCode=%d", + res.statusCode + ); + socket.destroy(); + var error = new Error("tunneling socket could not be established, statusCode=" + res.statusCode); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self2.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug("got illegal response body from proxy"); + socket.destroy(); + var error = new Error("got illegal response body from proxy"); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self2.removeSocket(placeholder); + return; + } + debug("tunneling connection has established"); + self2.sockets[self2.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + function onError(cause) { + connectReq.removeAllListeners(); + debug( + "tunneling socket could not be established, cause=%s\n", + cause.message, + cause.stack + ); + var error = new Error("tunneling socket could not be established, cause=" + cause.message); + error.code = "ECONNRESET"; + options.request.emit("error", error); + self2.removeSocket(placeholder); + } + }; + TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket); + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + var pending = this.requests.shift(); + if (pending) { + this.createSocket(pending, function(socket2) { + pending.request.onSocket(socket2); + }); + } + }; + function createSecureSocket(options, cb) { + var self2 = this; + TunnelingAgent.prototype.createSocket.call(self2, options, function(socket) { + var hostHeader = options.request.getHeader("host"); + var tlsOptions = mergeOptions({}, self2.options, { + socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host + }); + var secureSocket = tls.connect(0, tlsOptions); + self2.sockets[self2.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); + } + function toOptions(host, port, localAddress) { + if (typeof host === "string") { + return { + host, + port, + localAddress + }; + } + return host; + } + function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === "object") { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== void 0) { + target[k] = overrides[k]; + } + } + } + } + return target; + } + var debug; + if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === "string") { + args[0] = "TUNNEL: " + args[0]; + } else { + args.unshift("TUNNEL:"); + } + console.error.apply(console, args); + }; + } else { + debug = function() { + }; + } + exports2.debug = debug; + } +}); + +// node_modules/tunnel/index.js +var require_tunnel2 = __commonJS({ + "node_modules/tunnel/index.js"(exports2, module2) { + module2.exports = require_tunnel(); + } +}); + +// node_modules/undici/lib/core/symbols.js +var require_symbols = __commonJS({ + "node_modules/undici/lib/core/symbols.js"(exports2, module2) { + module2.exports = { + kClose: Symbol("close"), + kDestroy: Symbol("destroy"), + kDispatch: Symbol("dispatch"), + kUrl: Symbol("url"), + kWriting: Symbol("writing"), + kResuming: Symbol("resuming"), + kQueue: Symbol("queue"), + kConnect: Symbol("connect"), + kConnecting: Symbol("connecting"), + kHeadersList: Symbol("headers list"), + kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"), + kKeepAliveMaxTimeout: Symbol("max keep alive timeout"), + kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"), + kKeepAliveTimeoutValue: Symbol("keep alive timeout"), + kKeepAlive: Symbol("keep alive"), + kHeadersTimeout: Symbol("headers timeout"), + kBodyTimeout: Symbol("body timeout"), + kServerName: Symbol("server name"), + kLocalAddress: Symbol("local address"), + kHost: Symbol("host"), + kNoRef: Symbol("no ref"), + kBodyUsed: Symbol("used"), + kRunning: Symbol("running"), + kBlocking: Symbol("blocking"), + kPending: Symbol("pending"), + kSize: Symbol("size"), + kBusy: Symbol("busy"), + kQueued: Symbol("queued"), + kFree: Symbol("free"), + kConnected: Symbol("connected"), + kClosed: Symbol("closed"), + kNeedDrain: Symbol("need drain"), + kReset: Symbol("reset"), + kDestroyed: Symbol.for("nodejs.stream.destroyed"), + kMaxHeadersSize: Symbol("max headers size"), + kRunningIdx: Symbol("running index"), + kPendingIdx: Symbol("pending index"), + kError: Symbol("error"), + kClients: Symbol("clients"), + kClient: Symbol("client"), + kParser: Symbol("parser"), + kOnDestroyed: Symbol("destroy callbacks"), + kPipelining: Symbol("pipelining"), + kSocket: Symbol("socket"), + kHostHeader: Symbol("host header"), + kConnector: Symbol("connector"), + kStrictContentLength: Symbol("strict content length"), + kMaxRedirections: Symbol("maxRedirections"), + kMaxRequests: Symbol("maxRequestsPerClient"), + kProxy: Symbol("proxy agent options"), + kCounter: Symbol("socket request counter"), + kInterceptors: Symbol("dispatch interceptors"), + kMaxResponseSize: Symbol("max response size"), + kHTTP2Session: Symbol("http2Session"), + kHTTP2SessionState: Symbol("http2Session state"), + kHTTP2BuildRequest: Symbol("http2 build request"), + kHTTP1BuildRequest: Symbol("http1 build request"), + kHTTP2CopyHeaders: Symbol("http2 copy headers"), + kHTTPConnVersion: Symbol("http connection version"), + kRetryHandlerDefaultRetry: Symbol("retry agent default retry"), + kConstruct: Symbol("constructable") + }; + } +}); + +// node_modules/undici/lib/core/errors.js +var require_errors = __commonJS({ + "node_modules/undici/lib/core/errors.js"(exports2, module2) { + "use strict"; + var UndiciError = class extends Error { + constructor(message) { + super(message); + this.name = "UndiciError"; + this.code = "UND_ERR"; + } + }; + var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ConnectTimeoutError); + this.name = "ConnectTimeoutError"; + this.message = message || "Connect Timeout Error"; + this.code = "UND_ERR_CONNECT_TIMEOUT"; + } + }; + var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersTimeoutError); + this.name = "HeadersTimeoutError"; + this.message = message || "Headers Timeout Error"; + this.code = "UND_ERR_HEADERS_TIMEOUT"; + } + }; + var HeadersOverflowError = class _HeadersOverflowError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _HeadersOverflowError); + this.name = "HeadersOverflowError"; + this.message = message || "Headers Overflow Error"; + this.code = "UND_ERR_HEADERS_OVERFLOW"; + } + }; + var BodyTimeoutError = class _BodyTimeoutError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _BodyTimeoutError); + this.name = "BodyTimeoutError"; + this.message = message || "Body Timeout Error"; + this.code = "UND_ERR_BODY_TIMEOUT"; + } + }; + var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError { + constructor(message, statusCode, headers, body) { + super(message); + Error.captureStackTrace(this, _ResponseStatusCodeError); + this.name = "ResponseStatusCodeError"; + this.message = message || "Response Status Code Error"; + this.code = "UND_ERR_RESPONSE_STATUS_CODE"; + this.body = body; + this.status = statusCode; + this.statusCode = statusCode; + this.headers = headers; + } + }; + var InvalidArgumentError = class _InvalidArgumentError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidArgumentError); + this.name = "InvalidArgumentError"; + this.message = message || "Invalid Argument Error"; + this.code = "UND_ERR_INVALID_ARG"; + } + }; + var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InvalidReturnValueError); + this.name = "InvalidReturnValueError"; + this.message = message || "Invalid Return Value Error"; + this.code = "UND_ERR_INVALID_RETURN_VALUE"; + } + }; + var RequestAbortedError = class _RequestAbortedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestAbortedError); + this.name = "AbortError"; + this.message = message || "Request aborted"; + this.code = "UND_ERR_ABORTED"; + } + }; + var InformationalError = class _InformationalError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _InformationalError); + this.name = "InformationalError"; + this.message = message || "Request information"; + this.code = "UND_ERR_INFO"; + } + }; + var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _RequestContentLengthMismatchError); + this.name = "RequestContentLengthMismatchError"; + this.message = message || "Request body length does not match content-length header"; + this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"; + } + }; + var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseContentLengthMismatchError); + this.name = "ResponseContentLengthMismatchError"; + this.message = message || "Response body length does not match content-length header"; + this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"; + } + }; + var ClientDestroyedError = class _ClientDestroyedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientDestroyedError); + this.name = "ClientDestroyedError"; + this.message = message || "The client is destroyed"; + this.code = "UND_ERR_DESTROYED"; + } + }; + var ClientClosedError = class _ClientClosedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ClientClosedError); + this.name = "ClientClosedError"; + this.message = message || "The client is closed"; + this.code = "UND_ERR_CLOSED"; + } + }; + var SocketError = class _SocketError extends UndiciError { + constructor(message, socket) { + super(message); + Error.captureStackTrace(this, _SocketError); + this.name = "SocketError"; + this.message = message || "Socket error"; + this.code = "UND_ERR_SOCKET"; + this.socket = socket; + } + }; + var NotSupportedError = class _NotSupportedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _NotSupportedError); + this.name = "NotSupportedError"; + this.message = message || "Not supported error"; + this.code = "UND_ERR_NOT_SUPPORTED"; + } + }; + var BalancedPoolMissingUpstreamError = class extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, NotSupportedError); + this.name = "MissingUpstreamError"; + this.message = message || "No upstream has been added to the BalancedPool"; + this.code = "UND_ERR_BPL_MISSING_UPSTREAM"; + } + }; + var HTTPParserError = class _HTTPParserError extends Error { + constructor(message, code, data) { + super(message); + Error.captureStackTrace(this, _HTTPParserError); + this.name = "HTTPParserError"; + this.code = code ? `HPE_${code}` : void 0; + this.data = data ? data.toString() : void 0; + } + }; + var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _ResponseExceededMaxSizeError); + this.name = "ResponseExceededMaxSizeError"; + this.message = message || "Response content exceeded max size"; + this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE"; + } + }; + var RequestRetryError = class _RequestRetryError extends UndiciError { + constructor(message, code, { headers, data }) { + super(message); + Error.captureStackTrace(this, _RequestRetryError); + this.name = "RequestRetryError"; + this.message = message || "Request retry error"; + this.code = "UND_ERR_REQ_RETRY"; + this.statusCode = code; + this.data = data; + this.headers = headers; + } + }; + module2.exports = { + HTTPParserError, + UndiciError, + HeadersTimeoutError, + HeadersOverflowError, + BodyTimeoutError, + RequestContentLengthMismatchError, + ConnectTimeoutError, + ResponseStatusCodeError, + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError, + ClientDestroyedError, + ClientClosedError, + InformationalError, + SocketError, + NotSupportedError, + ResponseContentLengthMismatchError, + BalancedPoolMissingUpstreamError, + ResponseExceededMaxSizeError, + RequestRetryError + }; + } +}); + +// node_modules/undici/lib/core/constants.js +var require_constants = __commonJS({ + "node_modules/undici/lib/core/constants.js"(exports2, module2) { + "use strict"; + var headerNameLowerCasedRecord = {}; + var wellknownHeaderNames = [ + "Accept", + "Accept-Encoding", + "Accept-Language", + "Accept-Ranges", + "Access-Control-Allow-Credentials", + "Access-Control-Allow-Headers", + "Access-Control-Allow-Methods", + "Access-Control-Allow-Origin", + "Access-Control-Expose-Headers", + "Access-Control-Max-Age", + "Access-Control-Request-Headers", + "Access-Control-Request-Method", + "Age", + "Allow", + "Alt-Svc", + "Alt-Used", + "Authorization", + "Cache-Control", + "Clear-Site-Data", + "Connection", + "Content-Disposition", + "Content-Encoding", + "Content-Language", + "Content-Length", + "Content-Location", + "Content-Range", + "Content-Security-Policy", + "Content-Security-Policy-Report-Only", + "Content-Type", + "Cookie", + "Cross-Origin-Embedder-Policy", + "Cross-Origin-Opener-Policy", + "Cross-Origin-Resource-Policy", + "Date", + "Device-Memory", + "Downlink", + "ECT", + "ETag", + "Expect", + "Expect-CT", + "Expires", + "Forwarded", + "From", + "Host", + "If-Match", + "If-Modified-Since", + "If-None-Match", + "If-Range", + "If-Unmodified-Since", + "Keep-Alive", + "Last-Modified", + "Link", + "Location", + "Max-Forwards", + "Origin", + "Permissions-Policy", + "Pragma", + "Proxy-Authenticate", + "Proxy-Authorization", + "RTT", + "Range", + "Referer", + "Referrer-Policy", + "Refresh", + "Retry-After", + "Sec-WebSocket-Accept", + "Sec-WebSocket-Extensions", + "Sec-WebSocket-Key", + "Sec-WebSocket-Protocol", + "Sec-WebSocket-Version", + "Server", + "Server-Timing", + "Service-Worker-Allowed", + "Service-Worker-Navigation-Preload", + "Set-Cookie", + "SourceMap", + "Strict-Transport-Security", + "Supports-Loading-Mode", + "TE", + "Timing-Allow-Origin", + "Trailer", + "Transfer-Encoding", + "Upgrade", + "Upgrade-Insecure-Requests", + "User-Agent", + "Vary", + "Via", + "WWW-Authenticate", + "X-Content-Type-Options", + "X-DNS-Prefetch-Control", + "X-Frame-Options", + "X-Permitted-Cross-Domain-Policies", + "X-Powered-By", + "X-Requested-With", + "X-XSS-Protection" + ]; + for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = wellknownHeaderNames[i]; + const lowerCasedKey = key.toLowerCase(); + headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey; + } + Object.setPrototypeOf(headerNameLowerCasedRecord, null); + module2.exports = { + wellknownHeaderNames, + headerNameLowerCasedRecord + }; + } +}); + +// node_modules/undici/lib/core/util.js +var require_util = __commonJS({ + "node_modules/undici/lib/core/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { kDestroyed, kBodyUsed } = require_symbols(); + var { IncomingMessage } = require("http"); + var stream = require("stream"); + var net = require("net"); + var { InvalidArgumentError } = require_errors(); + var { Blob: Blob2 } = require("buffer"); + var nodeUtil = require("util"); + var { stringify: stringify3 } = require("querystring"); + var { headerNameLowerCasedRecord } = require_constants(); + var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v)); + function nop() { + } + function isStream(obj) { + return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; + } + function isBlobLike2(object) { + return Blob2 && object instanceof Blob2 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]); + } + function buildURL(url, queryParams) { + if (url.includes("?") || url.includes("#")) { + throw new Error('Query params cannot be passed when url already contains "?" or "#".'); + } + const stringified = stringify3(queryParams); + if (stringified) { + url += "?" + stringified; + } + return url; + } + function parseURL(url) { + if (typeof url === "string") { + url = new URL(url); + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + return url; + } + if (!url || typeof url !== "object") { + throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object."); + } + if (!/^https?:/.test(url.origin || url.protocol)) { + throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); + } + if (!(url instanceof URL)) { + if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) { + throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer."); + } + if (url.path != null && typeof url.path !== "string") { + throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined."); + } + if (url.pathname != null && typeof url.pathname !== "string") { + throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined."); + } + if (url.hostname != null && typeof url.hostname !== "string") { + throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined."); + } + if (url.origin != null && typeof url.origin !== "string") { + throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined."); + } + const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; + let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`; + let path3 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; + if (origin.endsWith("/")) { + origin = origin.substring(0, origin.length - 1); + } + if (path3 && !path3.startsWith("/")) { + path3 = `/${path3}`; + } + url = new URL(origin + path3); + } + return url; + } + function parseOrigin(url) { + url = parseURL(url); + if (url.pathname !== "/" || url.search || url.hash) { + throw new InvalidArgumentError("invalid url"); + } + return url; + } + function getHostname(host) { + if (host[0] === "[") { + const idx2 = host.indexOf("]"); + assert(idx2 !== -1); + return host.substring(1, idx2); + } + const idx = host.indexOf(":"); + if (idx === -1) return host; + return host.substring(0, idx); + } + function getServerName(host) { + if (!host) { + return null; + } + assert.strictEqual(typeof host, "string"); + const servername = getHostname(host); + if (net.isIP(servername)) { + return ""; + } + return servername; + } + function deepClone(obj) { + return JSON.parse(JSON.stringify(obj)); + } + function isAsyncIterable3(obj) { + return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function"); + } + function isIterable(obj) { + return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function")); + } + function bodyLength(body) { + if (body == null) { + return 0; + } else if (isStream(body)) { + const state = body._readableState; + return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; + } else if (isBlobLike2(body)) { + return body.size != null ? body.size : null; + } else if (isBuffer(body)) { + return body.byteLength; + } + return null; + } + function isDestroyed(stream2) { + return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]); + } + function isReadableAborted(stream2) { + const state = stream2 && stream2._readableState; + return isDestroyed(stream2) && state && !state.endEmitted; + } + function destroy(stream2, err) { + if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) { + return; + } + if (typeof stream2.destroy === "function") { + if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) { + stream2.socket = null; + } + stream2.destroy(err); + } else if (err) { + process.nextTick((stream3, err2) => { + stream3.emit("error", err2); + }, stream2, err); + } + if (stream2.destroyed !== true) { + stream2[kDestroyed] = true; + } + } + var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/; + function parseKeepAliveTimeout(val) { + const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR); + return m ? parseInt(m[1], 10) * 1e3 : null; + } + function headerNameToString(value) { + return headerNameLowerCasedRecord[value] || value.toLowerCase(); + } + function parseHeaders(headers, obj = {}) { + if (!Array.isArray(headers)) return headers; + for (let i = 0; i < headers.length; i += 2) { + const key = headers[i].toString().toLowerCase(); + let val = obj[key]; + if (!val) { + if (Array.isArray(headers[i + 1])) { + obj[key] = headers[i + 1].map((x) => x.toString("utf8")); + } else { + obj[key] = headers[i + 1].toString("utf8"); + } + } else { + if (!Array.isArray(val)) { + val = [val]; + obj[key] = val; + } + val.push(headers[i + 1].toString("utf8")); + } + } + if ("content-length" in obj && "content-disposition" in obj) { + obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1"); + } + return obj; + } + function parseRawHeaders(headers) { + const ret = []; + let hasContentLength = false; + let contentDispositionIdx = -1; + for (let n = 0; n < headers.length; n += 2) { + const key = headers[n + 0].toString(); + const val = headers[n + 1].toString("utf8"); + if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) { + ret.push(key, val); + hasContentLength = true; + } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) { + contentDispositionIdx = ret.push(key, val) - 1; + } else { + ret.push(key, val); + } + } + if (hasContentLength && contentDispositionIdx !== -1) { + ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1"); + } + return ret; + } + function isBuffer(buffer) { + return buffer instanceof Uint8Array || Buffer.isBuffer(buffer); + } + function validateHandler(handler, method, upgrade) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + if (typeof handler.onConnect !== "function") { + throw new InvalidArgumentError("invalid onConnect method"); + } + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + if (typeof handler.onBodySent !== "function" && handler.onBodySent !== void 0) { + throw new InvalidArgumentError("invalid onBodySent method"); + } + if (upgrade || method === "CONNECT") { + if (typeof handler.onUpgrade !== "function") { + throw new InvalidArgumentError("invalid onUpgrade method"); + } + } else { + if (typeof handler.onHeaders !== "function") { + throw new InvalidArgumentError("invalid onHeaders method"); + } + if (typeof handler.onData !== "function") { + throw new InvalidArgumentError("invalid onData method"); + } + if (typeof handler.onComplete !== "function") { + throw new InvalidArgumentError("invalid onComplete method"); + } + } + } + function isDisturbed(body) { + return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body))); + } + function isErrored(body) { + return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test( + nodeUtil.inspect(body) + ))); + } + function isReadable(body) { + return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test( + nodeUtil.inspect(body) + ))); + } + function getSocketInfo(socket) { + return { + localAddress: socket.localAddress, + localPort: socket.localPort, + remoteAddress: socket.remoteAddress, + remotePort: socket.remotePort, + remoteFamily: socket.remoteFamily, + timeout: socket.timeout, + bytesWritten: socket.bytesWritten, + bytesRead: socket.bytesRead + }; + } + async function* convertIterableToBuffer(iterable) { + for await (const chunk of iterable) { + yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk); + } + } + var ReadableStream; + function ReadableStreamFrom3(iterable) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (ReadableStream.from) { + return ReadableStream.from(convertIterableToBuffer(iterable)); + } + let iterator; + return new ReadableStream( + { + async start() { + iterator = iterable[Symbol.asyncIterator](); + }, + async pull(controller) { + const { done, value } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + const buf = Buffer.isBuffer(value) ? value : Buffer.from(value); + controller.enqueue(new Uint8Array(buf)); + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + } + }, + 0 + ); + } + function isFormDataLike(object) { + return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData"; + } + function throwIfAborted(signal) { + if (!signal) { + return; + } + if (typeof signal.throwIfAborted === "function") { + signal.throwIfAborted(); + } else { + if (signal.aborted) { + const err = new Error("The operation was aborted"); + err.name = "AbortError"; + throw err; + } + } + } + function addAbortListener(signal, listener) { + if ("addEventListener" in signal) { + signal.addEventListener("abort", listener, { once: true }); + return () => signal.removeEventListener("abort", listener); + } + signal.addListener("abort", listener); + return () => signal.removeListener("abort", listener); + } + var hasToWellFormed = !!String.prototype.toWellFormed; + function toUSVString(val) { + if (hasToWellFormed) { + return `${val}`.toWellFormed(); + } else if (nodeUtil.toUSVString) { + return nodeUtil.toUSVString(val); + } + return `${val}`; + } + function parseRangeHeader(range) { + if (range == null || range === "") return { start: 0, end: null, size: null }; + const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null; + return m ? { + start: parseInt(m[1]), + end: m[2] ? parseInt(m[2]) : null, + size: m[3] ? parseInt(m[3]) : null + } : null; + } + var kEnumerableProperty = /* @__PURE__ */ Object.create(null); + kEnumerableProperty.enumerable = true; + module2.exports = { + kEnumerableProperty, + nop, + isDisturbed, + isErrored, + isReadable, + toUSVString, + isReadableAborted, + isBlobLike: isBlobLike2, + parseOrigin, + parseURL, + getServerName, + isStream, + isIterable, + isAsyncIterable: isAsyncIterable3, + isDestroyed, + headerNameToString, + parseRawHeaders, + parseHeaders, + parseKeepAliveTimeout, + destroy, + bodyLength, + deepClone, + ReadableStreamFrom: ReadableStreamFrom3, + isBuffer, + validateHandler, + getSocketInfo, + isFormDataLike, + buildURL, + throwIfAborted, + addAbortListener, + parseRangeHeader, + nodeMajor, + nodeMinor, + nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13, + safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"] + }; + } +}); + +// node_modules/undici/lib/timers.js +var require_timers = __commonJS({ + "node_modules/undici/lib/timers.js"(exports2, module2) { + "use strict"; + var fastNow = Date.now(); + var fastNowTimeout; + var fastTimers = []; + function onTimeout() { + fastNow = Date.now(); + let len = fastTimers.length; + let idx = 0; + while (idx < len) { + const timer = fastTimers[idx]; + if (timer.state === 0) { + timer.state = fastNow + timer.delay; + } else if (timer.state > 0 && fastNow >= timer.state) { + timer.state = -1; + timer.callback(timer.opaque); + } + if (timer.state === -1) { + timer.state = -2; + if (idx !== len - 1) { + fastTimers[idx] = fastTimers.pop(); + } else { + fastTimers.pop(); + } + len -= 1; + } else { + idx += 1; + } + } + if (fastTimers.length > 0) { + refreshTimeout(); + } + } + function refreshTimeout() { + if (fastNowTimeout && fastNowTimeout.refresh) { + fastNowTimeout.refresh(); + } else { + clearTimeout(fastNowTimeout); + fastNowTimeout = setTimeout(onTimeout, 1e3); + if (fastNowTimeout.unref) { + fastNowTimeout.unref(); + } + } + } + var Timeout = class { + constructor(callback, delay, opaque) { + this.callback = callback; + this.delay = delay; + this.opaque = opaque; + this.state = -2; + this.refresh(); + } + refresh() { + if (this.state === -2) { + fastTimers.push(this); + if (!fastNowTimeout || fastTimers.length === 1) { + refreshTimeout(); + } + } + this.state = 0; + } + clear() { + this.state = -1; + } + }; + module2.exports = { + setTimeout(callback, delay, opaque) { + return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque); + }, + clearTimeout(timeout) { + if (timeout instanceof Timeout) { + timeout.clear(); + } else { + clearTimeout(timeout); + } + } + }; + } +}); + +// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js +var require_sbmh = __commonJS({ + "node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + function SBMH(needle) { + if (typeof needle === "string") { + needle = Buffer.from(needle); + } + if (!Buffer.isBuffer(needle)) { + throw new TypeError("The needle has to be a String or a Buffer."); + } + const needleLength = needle.length; + if (needleLength === 0) { + throw new Error("The needle cannot be an empty String/Buffer."); + } + if (needleLength > 256) { + throw new Error("The needle cannot have a length bigger than 256."); + } + this.maxMatches = Infinity; + this.matches = 0; + this._occ = new Array(256).fill(needleLength); + this._lookbehind_size = 0; + this._needle = needle; + this._bufpos = 0; + this._lookbehind = Buffer.alloc(needleLength); + for (var i = 0; i < needleLength - 1; ++i) { + this._occ[needle[i]] = needleLength - 1 - i; + } + } + inherits(SBMH, EventEmitter); + SBMH.prototype.reset = function() { + this._lookbehind_size = 0; + this.matches = 0; + this._bufpos = 0; + }; + SBMH.prototype.push = function(chunk, pos) { + if (!Buffer.isBuffer(chunk)) { + chunk = Buffer.from(chunk, "binary"); + } + const chlen = chunk.length; + this._bufpos = pos || 0; + let r; + while (r !== chlen && this.matches < this.maxMatches) { + r = this._sbmh_feed(chunk); + } + return r; + }; + SBMH.prototype._sbmh_feed = function(data) { + const len = data.length; + const needle = this._needle; + const needleLength = needle.length; + const lastNeedleChar = needle[needleLength - 1]; + let pos = -this._lookbehind_size; + let ch; + if (pos < 0) { + while (pos < 0 && pos <= len - needleLength) { + ch = this._sbmh_lookup_char(data, pos + needleLength - 1); + if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) { + this._lookbehind_size = 0; + ++this.matches; + this.emit("info", true); + return this._bufpos = pos + needleLength; + } + pos += this._occ[ch]; + } + if (pos < 0) { + while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { + ++pos; + } + } + if (pos >= 0) { + this.emit("info", false, this._lookbehind, 0, this._lookbehind_size); + this._lookbehind_size = 0; + } else { + const bytesToCutOff = this._lookbehind_size + pos; + if (bytesToCutOff > 0) { + this.emit("info", false, this._lookbehind, 0, bytesToCutOff); + } + this._lookbehind.copy( + this._lookbehind, + 0, + bytesToCutOff, + this._lookbehind_size - bytesToCutOff + ); + this._lookbehind_size -= bytesToCutOff; + data.copy(this._lookbehind, this._lookbehind_size); + this._lookbehind_size += len; + this._bufpos = len; + return len; + } + } + pos += (pos >= 0) * this._bufpos; + if (data.indexOf(needle, pos) !== -1) { + pos = data.indexOf(needle, pos); + ++this.matches; + if (pos > 0) { + this.emit("info", true, data, this._bufpos, pos); + } else { + this.emit("info", true); + } + return this._bufpos = pos + needleLength; + } else { + pos = len - needleLength; + } + while (pos < len && (data[pos] !== needle[0] || Buffer.compare( + data.subarray(pos, pos + len - pos), + needle.subarray(0, len - pos) + ) !== 0)) { + ++pos; + } + if (pos < len) { + data.copy(this._lookbehind, 0, pos, pos + (len - pos)); + this._lookbehind_size = len - pos; + } + if (pos > 0) { + this.emit("info", false, data, this._bufpos, pos < len ? pos : len); + } + this._bufpos = len; + return len; + }; + SBMH.prototype._sbmh_lookup_char = function(data, pos) { + return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos]; + }; + SBMH.prototype._sbmh_memcmp = function(data, pos, len) { + for (var i = 0; i < len; ++i) { + if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { + return false; + } + } + return true; + }; + module2.exports = SBMH; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js +var require_PartStream = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) { + "use strict"; + var inherits = require("node:util").inherits; + var ReadableStream = require("node:stream").Readable; + function PartStream(opts) { + ReadableStream.call(this, opts); + } + inherits(PartStream, ReadableStream); + PartStream.prototype._read = function(n) { + }; + module2.exports = PartStream; + } +}); + +// node_modules/@fastify/busboy/lib/utils/getLimit.js +var require_getLimit = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) { + "use strict"; + module2.exports = function getLimit(limits, name, defaultLimit) { + if (!limits || limits[name] === void 0 || limits[name] === null) { + return defaultLimit; + } + if (typeof limits[name] !== "number" || isNaN(limits[name])) { + throw new TypeError("Limit " + name + " is not a valid number"); + } + return limits[name]; + }; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js +var require_HeaderParser = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("node:events").EventEmitter; + var inherits = require("node:util").inherits; + var getLimit = require_getLimit(); + var StreamSearch = require_sbmh(); + var B_DCRLF = Buffer.from("\r\n\r\n"); + var RE_CRLF = /\r\n/g; + var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/; + function HeaderParser(cfg) { + EventEmitter.call(this); + cfg = cfg || {}; + const self2 = this; + this.nread = 0; + this.maxed = false; + this.npairs = 0; + this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3); + this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024); + this.buffer = ""; + this.header = {}; + this.finished = false; + this.ss = new StreamSearch(B_DCRLF); + this.ss.on("info", function(isMatch, data, start, end) { + if (data && !self2.maxed) { + if (self2.nread + end - start >= self2.maxHeaderSize) { + end = self2.maxHeaderSize - self2.nread + start; + self2.nread = self2.maxHeaderSize; + self2.maxed = true; + } else { + self2.nread += end - start; + } + self2.buffer += data.toString("binary", start, end); + } + if (isMatch) { + self2._finish(); + } + }); + } + inherits(HeaderParser, EventEmitter); + HeaderParser.prototype.push = function(data) { + const r = this.ss.push(data); + if (this.finished) { + return r; + } + }; + HeaderParser.prototype.reset = function() { + this.finished = false; + this.buffer = ""; + this.header = {}; + this.ss.reset(); + }; + HeaderParser.prototype._finish = function() { + if (this.buffer) { + this._parseHeader(); + } + this.ss.matches = this.ss.maxMatches; + const header = this.header; + this.header = {}; + this.buffer = ""; + this.finished = true; + this.nread = this.npairs = 0; + this.maxed = false; + this.emit("header", header); + }; + HeaderParser.prototype._parseHeader = function() { + if (this.npairs === this.maxHeaderPairs) { + return; + } + const lines = this.buffer.split(RE_CRLF); + const len = lines.length; + let m, h; + for (var i = 0; i < len; ++i) { + if (lines[i].length === 0) { + continue; + } + if (lines[i][0] === " " || lines[i][0] === " ") { + if (h) { + this.header[h][this.header[h].length - 1] += lines[i]; + continue; + } + } + const posColon = lines[i].indexOf(":"); + if (posColon === -1 || posColon === 0) { + return; + } + m = RE_HDR.exec(lines[i]); + h = m[1].toLowerCase(); + this.header[h] = this.header[h] || []; + this.header[h].push(m[2] || ""); + if (++this.npairs === this.maxHeaderPairs) { + break; + } + } + }; + module2.exports = HeaderParser; + } +}); + +// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js +var require_Dicer = __commonJS({ + "node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var inherits = require("node:util").inherits; + var StreamSearch = require_sbmh(); + var PartStream = require_PartStream(); + var HeaderParser = require_HeaderParser(); + var DASH = 45; + var B_ONEDASH = Buffer.from("-"); + var B_CRLF = Buffer.from("\r\n"); + var EMPTY_FN = function() { + }; + function Dicer(cfg) { + if (!(this instanceof Dicer)) { + return new Dicer(cfg); + } + WritableStream.call(this, cfg); + if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") { + throw new TypeError("Boundary required"); + } + if (typeof cfg.boundary === "string") { + this.setBoundary(cfg.boundary); + } else { + this._bparser = void 0; + } + this._headerFirst = cfg.headerFirst; + this._dashes = 0; + this._parts = 0; + this._finished = false; + this._realFinish = false; + this._isPreamble = true; + this._justMatched = false; + this._firstWrite = true; + this._inHeader = true; + this._part = void 0; + this._cb = void 0; + this._ignoreData = false; + this._partOpts = { highWaterMark: cfg.partHwm }; + this._pause = false; + const self2 = this; + this._hparser = new HeaderParser(cfg); + this._hparser.on("header", function(header) { + self2._inHeader = false; + self2._part.emit("header", header); + }); + } + inherits(Dicer, WritableStream); + Dicer.prototype.emit = function(ev) { + if (ev === "finish" && !this._realFinish) { + if (!this._finished) { + const self2 = this; + process.nextTick(function() { + self2.emit("error", new Error("Unexpected end of multipart data")); + if (self2._part && !self2._ignoreData) { + const type = self2._isPreamble ? "Preamble" : "Part"; + self2._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data")); + self2._part.push(null); + process.nextTick(function() { + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + }); + return; + } + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + }); + } + } else { + WritableStream.prototype.emit.apply(this, arguments); + } + }; + Dicer.prototype._write = function(data, encoding, cb) { + if (!this._hparser && !this._bparser) { + return cb(); + } + if (this._headerFirst && this._isPreamble) { + if (!this._part) { + this._part = new PartStream(this._partOpts); + if (this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else { + this._ignore(); + } + } + const r = this._hparser.push(data); + if (!this._inHeader && r !== void 0 && r < data.length) { + data = data.slice(r); + } else { + return cb(); + } + } + if (this._firstWrite) { + this._bparser.push(B_CRLF); + this._firstWrite = false; + } + this._bparser.push(data); + if (this._pause) { + this._cb = cb; + } else { + cb(); + } + }; + Dicer.prototype.reset = function() { + this._part = void 0; + this._bparser = void 0; + this._hparser = void 0; + }; + Dicer.prototype.setBoundary = function(boundary) { + const self2 = this; + this._bparser = new StreamSearch("\r\n--" + boundary); + this._bparser.on("info", function(isMatch, data, start, end) { + self2._oninfo(isMatch, data, start, end); + }); + }; + Dicer.prototype._ignore = function() { + if (this._part && !this._ignoreData) { + this._ignoreData = true; + this._part.on("error", EMPTY_FN); + this._part.resume(); + } + }; + Dicer.prototype._oninfo = function(isMatch, data, start, end) { + let buf; + const self2 = this; + let i = 0; + let r; + let shouldWriteMore = true; + if (!this._part && this._justMatched && data) { + while (this._dashes < 2 && start + i < end) { + if (data[start + i] === DASH) { + ++i; + ++this._dashes; + } else { + if (this._dashes) { + buf = B_ONEDASH; + } + this._dashes = 0; + break; + } + } + if (this._dashes === 2) { + if (start + i < end && this.listenerCount("trailer") !== 0) { + this.emit("trailer", data.slice(start + i, end)); + } + this.reset(); + this._finished = true; + if (self2._parts === 0) { + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + } + } + if (this._dashes) { + return; + } + } + if (this._justMatched) { + this._justMatched = false; + } + if (!this._part) { + this._part = new PartStream(this._partOpts); + this._part._read = function(n) { + self2._unpause(); + }; + if (this._isPreamble && this.listenerCount("preamble") !== 0) { + this.emit("preamble", this._part); + } else if (this._isPreamble !== true && this.listenerCount("part") !== 0) { + this.emit("part", this._part); + } else { + this._ignore(); + } + if (!this._isPreamble) { + this._inHeader = true; + } + } + if (data && start < end && !this._ignoreData) { + if (this._isPreamble || !this._inHeader) { + if (buf) { + shouldWriteMore = this._part.push(buf); + } + shouldWriteMore = this._part.push(data.slice(start, end)); + if (!shouldWriteMore) { + this._pause = true; + } + } else if (!this._isPreamble && this._inHeader) { + if (buf) { + this._hparser.push(buf); + } + r = this._hparser.push(data.slice(start, end)); + if (!this._inHeader && r !== void 0 && r < end) { + this._oninfo(false, data, start + r, end); + } + } + } + if (isMatch) { + this._hparser.reset(); + if (this._isPreamble) { + this._isPreamble = false; + } else { + if (start !== end) { + ++this._parts; + this._part.on("end", function() { + if (--self2._parts === 0) { + if (self2._finished) { + self2._realFinish = true; + self2.emit("finish"); + self2._realFinish = false; + } else { + self2._unpause(); + } + } + }); + } + } + this._part.push(null); + this._part = void 0; + this._ignoreData = false; + this._justMatched = true; + this._dashes = 0; + } + }; + Dicer.prototype._unpause = function() { + if (!this._pause) { + return; + } + this._pause = false; + if (this._cb) { + const cb = this._cb; + this._cb = void 0; + cb(); + } + }; + module2.exports = Dicer; + } +}); + +// node_modules/@fastify/busboy/lib/utils/decodeText.js +var require_decodeText = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) { + "use strict"; + var utf8Decoder = new TextDecoder("utf-8"); + var textDecoders = /* @__PURE__ */ new Map([ + ["utf-8", utf8Decoder], + ["utf8", utf8Decoder] + ]); + function getDecoder(charset) { + let lc; + while (true) { + switch (charset) { + case "utf-8": + case "utf8": + return decoders.utf8; + case "latin1": + case "ascii": + // TODO: Make these a separate, strict decoder? + case "us-ascii": + case "iso-8859-1": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "windows-1252": + case "iso_8859-1:1987": + case "cp1252": + case "x-cp1252": + return decoders.latin1; + case "utf16le": + case "utf-16le": + case "ucs2": + case "ucs-2": + return decoders.utf16le; + case "base64": + return decoders.base64; + default: + if (lc === void 0) { + lc = true; + charset = charset.toLowerCase(); + continue; + } + return decoders.other.bind(charset); + } + } + } + var decoders = { + utf8: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.utf8Slice(0, data.length); + }, + latin1: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + return data; + } + return data.latin1Slice(0, data.length); + }, + utf16le: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.ucs2Slice(0, data.length); + }, + base64: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + return data.base64Slice(0, data.length); + }, + other: (data, sourceEncoding) => { + if (data.length === 0) { + return ""; + } + if (typeof data === "string") { + data = Buffer.from(data, sourceEncoding); + } + if (textDecoders.has(exports2.toString())) { + try { + return textDecoders.get(exports2).decode(data); + } catch { + } + } + return typeof data === "string" ? data : data.toString(); + } + }; + function decodeText(text, sourceEncoding, destEncoding) { + if (text) { + return getDecoder(destEncoding)(text, sourceEncoding); + } + return text; + } + module2.exports = decodeText; + } +}); + +// node_modules/@fastify/busboy/lib/utils/parseParams.js +var require_parseParams = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) { + "use strict"; + var decodeText = require_decodeText(); + var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g; + var EncodedLookup = { + "%00": "\0", + "%01": "", + "%02": "", + "%03": "", + "%04": "", + "%05": "", + "%06": "", + "%07": "\x07", + "%08": "\b", + "%09": " ", + "%0a": "\n", + "%0A": "\n", + "%0b": "\v", + "%0B": "\v", + "%0c": "\f", + "%0C": "\f", + "%0d": "\r", + "%0D": "\r", + "%0e": "", + "%0E": "", + "%0f": "", + "%0F": "", + "%10": "", + "%11": "", + "%12": "", + "%13": "", + "%14": "", + "%15": "", + "%16": "", + "%17": "", + "%18": "", + "%19": "", + "%1a": "", + "%1A": "", + "%1b": "\x1B", + "%1B": "\x1B", + "%1c": "", + "%1C": "", + "%1d": "", + "%1D": "", + "%1e": "", + "%1E": "", + "%1f": "", + "%1F": "", + "%20": " ", + "%21": "!", + "%22": '"', + "%23": "#", + "%24": "$", + "%25": "%", + "%26": "&", + "%27": "'", + "%28": "(", + "%29": ")", + "%2a": "*", + "%2A": "*", + "%2b": "+", + "%2B": "+", + "%2c": ",", + "%2C": ",", + "%2d": "-", + "%2D": "-", + "%2e": ".", + "%2E": ".", + "%2f": "/", + "%2F": "/", + "%30": "0", + "%31": "1", + "%32": "2", + "%33": "3", + "%34": "4", + "%35": "5", + "%36": "6", + "%37": "7", + "%38": "8", + "%39": "9", + "%3a": ":", + "%3A": ":", + "%3b": ";", + "%3B": ";", + "%3c": "<", + "%3C": "<", + "%3d": "=", + "%3D": "=", + "%3e": ">", + "%3E": ">", + "%3f": "?", + "%3F": "?", + "%40": "@", + "%41": "A", + "%42": "B", + "%43": "C", + "%44": "D", + "%45": "E", + "%46": "F", + "%47": "G", + "%48": "H", + "%49": "I", + "%4a": "J", + "%4A": "J", + "%4b": "K", + "%4B": "K", + "%4c": "L", + "%4C": "L", + "%4d": "M", + "%4D": "M", + "%4e": "N", + "%4E": "N", + "%4f": "O", + "%4F": "O", + "%50": "P", + "%51": "Q", + "%52": "R", + "%53": "S", + "%54": "T", + "%55": "U", + "%56": "V", + "%57": "W", + "%58": "X", + "%59": "Y", + "%5a": "Z", + "%5A": "Z", + "%5b": "[", + "%5B": "[", + "%5c": "\\", + "%5C": "\\", + "%5d": "]", + "%5D": "]", + "%5e": "^", + "%5E": "^", + "%5f": "_", + "%5F": "_", + "%60": "`", + "%61": "a", + "%62": "b", + "%63": "c", + "%64": "d", + "%65": "e", + "%66": "f", + "%67": "g", + "%68": "h", + "%69": "i", + "%6a": "j", + "%6A": "j", + "%6b": "k", + "%6B": "k", + "%6c": "l", + "%6C": "l", + "%6d": "m", + "%6D": "m", + "%6e": "n", + "%6E": "n", + "%6f": "o", + "%6F": "o", + "%70": "p", + "%71": "q", + "%72": "r", + "%73": "s", + "%74": "t", + "%75": "u", + "%76": "v", + "%77": "w", + "%78": "x", + "%79": "y", + "%7a": "z", + "%7A": "z", + "%7b": "{", + "%7B": "{", + "%7c": "|", + "%7C": "|", + "%7d": "}", + "%7D": "}", + "%7e": "~", + "%7E": "~", + "%7f": "\x7F", + "%7F": "\x7F", + "%80": "\x80", + "%81": "\x81", + "%82": "\x82", + "%83": "\x83", + "%84": "\x84", + "%85": "\x85", + "%86": "\x86", + "%87": "\x87", + "%88": "\x88", + "%89": "\x89", + "%8a": "\x8A", + "%8A": "\x8A", + "%8b": "\x8B", + "%8B": "\x8B", + "%8c": "\x8C", + "%8C": "\x8C", + "%8d": "\x8D", + "%8D": "\x8D", + "%8e": "\x8E", + "%8E": "\x8E", + "%8f": "\x8F", + "%8F": "\x8F", + "%90": "\x90", + "%91": "\x91", + "%92": "\x92", + "%93": "\x93", + "%94": "\x94", + "%95": "\x95", + "%96": "\x96", + "%97": "\x97", + "%98": "\x98", + "%99": "\x99", + "%9a": "\x9A", + "%9A": "\x9A", + "%9b": "\x9B", + "%9B": "\x9B", + "%9c": "\x9C", + "%9C": "\x9C", + "%9d": "\x9D", + "%9D": "\x9D", + "%9e": "\x9E", + "%9E": "\x9E", + "%9f": "\x9F", + "%9F": "\x9F", + "%a0": "\xA0", + "%A0": "\xA0", + "%a1": "\xA1", + "%A1": "\xA1", + "%a2": "\xA2", + "%A2": "\xA2", + "%a3": "\xA3", + "%A3": "\xA3", + "%a4": "\xA4", + "%A4": "\xA4", + "%a5": "\xA5", + "%A5": "\xA5", + "%a6": "\xA6", + "%A6": "\xA6", + "%a7": "\xA7", + "%A7": "\xA7", + "%a8": "\xA8", + "%A8": "\xA8", + "%a9": "\xA9", + "%A9": "\xA9", + "%aa": "\xAA", + "%Aa": "\xAA", + "%aA": "\xAA", + "%AA": "\xAA", + "%ab": "\xAB", + "%Ab": "\xAB", + "%aB": "\xAB", + "%AB": "\xAB", + "%ac": "\xAC", + "%Ac": "\xAC", + "%aC": "\xAC", + "%AC": "\xAC", + "%ad": "\xAD", + "%Ad": "\xAD", + "%aD": "\xAD", + "%AD": "\xAD", + "%ae": "\xAE", + "%Ae": "\xAE", + "%aE": "\xAE", + "%AE": "\xAE", + "%af": "\xAF", + "%Af": "\xAF", + "%aF": "\xAF", + "%AF": "\xAF", + "%b0": "\xB0", + "%B0": "\xB0", + "%b1": "\xB1", + "%B1": "\xB1", + "%b2": "\xB2", + "%B2": "\xB2", + "%b3": "\xB3", + "%B3": "\xB3", + "%b4": "\xB4", + "%B4": "\xB4", + "%b5": "\xB5", + "%B5": "\xB5", + "%b6": "\xB6", + "%B6": "\xB6", + "%b7": "\xB7", + "%B7": "\xB7", + "%b8": "\xB8", + "%B8": "\xB8", + "%b9": "\xB9", + "%B9": "\xB9", + "%ba": "\xBA", + "%Ba": "\xBA", + "%bA": "\xBA", + "%BA": "\xBA", + "%bb": "\xBB", + "%Bb": "\xBB", + "%bB": "\xBB", + "%BB": "\xBB", + "%bc": "\xBC", + "%Bc": "\xBC", + "%bC": "\xBC", + "%BC": "\xBC", + "%bd": "\xBD", + "%Bd": "\xBD", + "%bD": "\xBD", + "%BD": "\xBD", + "%be": "\xBE", + "%Be": "\xBE", + "%bE": "\xBE", + "%BE": "\xBE", + "%bf": "\xBF", + "%Bf": "\xBF", + "%bF": "\xBF", + "%BF": "\xBF", + "%c0": "\xC0", + "%C0": "\xC0", + "%c1": "\xC1", + "%C1": "\xC1", + "%c2": "\xC2", + "%C2": "\xC2", + "%c3": "\xC3", + "%C3": "\xC3", + "%c4": "\xC4", + "%C4": "\xC4", + "%c5": "\xC5", + "%C5": "\xC5", + "%c6": "\xC6", + "%C6": "\xC6", + "%c7": "\xC7", + "%C7": "\xC7", + "%c8": "\xC8", + "%C8": "\xC8", + "%c9": "\xC9", + "%C9": "\xC9", + "%ca": "\xCA", + "%Ca": "\xCA", + "%cA": "\xCA", + "%CA": "\xCA", + "%cb": "\xCB", + "%Cb": "\xCB", + "%cB": "\xCB", + "%CB": "\xCB", + "%cc": "\xCC", + "%Cc": "\xCC", + "%cC": "\xCC", + "%CC": "\xCC", + "%cd": "\xCD", + "%Cd": "\xCD", + "%cD": "\xCD", + "%CD": "\xCD", + "%ce": "\xCE", + "%Ce": "\xCE", + "%cE": "\xCE", + "%CE": "\xCE", + "%cf": "\xCF", + "%Cf": "\xCF", + "%cF": "\xCF", + "%CF": "\xCF", + "%d0": "\xD0", + "%D0": "\xD0", + "%d1": "\xD1", + "%D1": "\xD1", + "%d2": "\xD2", + "%D2": "\xD2", + "%d3": "\xD3", + "%D3": "\xD3", + "%d4": "\xD4", + "%D4": "\xD4", + "%d5": "\xD5", + "%D5": "\xD5", + "%d6": "\xD6", + "%D6": "\xD6", + "%d7": "\xD7", + "%D7": "\xD7", + "%d8": "\xD8", + "%D8": "\xD8", + "%d9": "\xD9", + "%D9": "\xD9", + "%da": "\xDA", + "%Da": "\xDA", + "%dA": "\xDA", + "%DA": "\xDA", + "%db": "\xDB", + "%Db": "\xDB", + "%dB": "\xDB", + "%DB": "\xDB", + "%dc": "\xDC", + "%Dc": "\xDC", + "%dC": "\xDC", + "%DC": "\xDC", + "%dd": "\xDD", + "%Dd": "\xDD", + "%dD": "\xDD", + "%DD": "\xDD", + "%de": "\xDE", + "%De": "\xDE", + "%dE": "\xDE", + "%DE": "\xDE", + "%df": "\xDF", + "%Df": "\xDF", + "%dF": "\xDF", + "%DF": "\xDF", + "%e0": "\xE0", + "%E0": "\xE0", + "%e1": "\xE1", + "%E1": "\xE1", + "%e2": "\xE2", + "%E2": "\xE2", + "%e3": "\xE3", + "%E3": "\xE3", + "%e4": "\xE4", + "%E4": "\xE4", + "%e5": "\xE5", + "%E5": "\xE5", + "%e6": "\xE6", + "%E6": "\xE6", + "%e7": "\xE7", + "%E7": "\xE7", + "%e8": "\xE8", + "%E8": "\xE8", + "%e9": "\xE9", + "%E9": "\xE9", + "%ea": "\xEA", + "%Ea": "\xEA", + "%eA": "\xEA", + "%EA": "\xEA", + "%eb": "\xEB", + "%Eb": "\xEB", + "%eB": "\xEB", + "%EB": "\xEB", + "%ec": "\xEC", + "%Ec": "\xEC", + "%eC": "\xEC", + "%EC": "\xEC", + "%ed": "\xED", + "%Ed": "\xED", + "%eD": "\xED", + "%ED": "\xED", + "%ee": "\xEE", + "%Ee": "\xEE", + "%eE": "\xEE", + "%EE": "\xEE", + "%ef": "\xEF", + "%Ef": "\xEF", + "%eF": "\xEF", + "%EF": "\xEF", + "%f0": "\xF0", + "%F0": "\xF0", + "%f1": "\xF1", + "%F1": "\xF1", + "%f2": "\xF2", + "%F2": "\xF2", + "%f3": "\xF3", + "%F3": "\xF3", + "%f4": "\xF4", + "%F4": "\xF4", + "%f5": "\xF5", + "%F5": "\xF5", + "%f6": "\xF6", + "%F6": "\xF6", + "%f7": "\xF7", + "%F7": "\xF7", + "%f8": "\xF8", + "%F8": "\xF8", + "%f9": "\xF9", + "%F9": "\xF9", + "%fa": "\xFA", + "%Fa": "\xFA", + "%fA": "\xFA", + "%FA": "\xFA", + "%fb": "\xFB", + "%Fb": "\xFB", + "%fB": "\xFB", + "%FB": "\xFB", + "%fc": "\xFC", + "%Fc": "\xFC", + "%fC": "\xFC", + "%FC": "\xFC", + "%fd": "\xFD", + "%Fd": "\xFD", + "%fD": "\xFD", + "%FD": "\xFD", + "%fe": "\xFE", + "%Fe": "\xFE", + "%fE": "\xFE", + "%FE": "\xFE", + "%ff": "\xFF", + "%Ff": "\xFF", + "%fF": "\xFF", + "%FF": "\xFF" + }; + function encodedReplacer(match) { + return EncodedLookup[match]; + } + var STATE_KEY = 0; + var STATE_VALUE = 1; + var STATE_CHARSET = 2; + var STATE_LANG = 3; + function parseParams(str) { + const res = []; + let state = STATE_KEY; + let charset = ""; + let inquote = false; + let escaping = false; + let p = 0; + let tmp = ""; + const len = str.length; + for (var i = 0; i < len; ++i) { + const char = str[i]; + if (char === "\\" && inquote) { + if (escaping) { + escaping = false; + } else { + escaping = true; + continue; + } + } else if (char === '"') { + if (!escaping) { + if (inquote) { + inquote = false; + state = STATE_KEY; + } else { + inquote = true; + } + continue; + } else { + escaping = false; + } + } else { + if (escaping && inquote) { + tmp += "\\"; + } + escaping = false; + if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") { + if (state === STATE_CHARSET) { + state = STATE_LANG; + charset = tmp.substring(1); + } else { + state = STATE_VALUE; + } + tmp = ""; + continue; + } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) { + state = char === "*" ? STATE_CHARSET : STATE_VALUE; + res[p] = [tmp, void 0]; + tmp = ""; + continue; + } else if (!inquote && char === ";") { + state = STATE_KEY; + if (charset) { + if (tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } + charset = ""; + } else if (tmp.length) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + res[p] = tmp; + } else { + res[p][1] = tmp; + } + tmp = ""; + ++p; + continue; + } else if (!inquote && (char === " " || char === " ")) { + continue; + } + } + tmp += char; + } + if (charset && tmp.length) { + tmp = decodeText( + tmp.replace(RE_ENCODED, encodedReplacer), + "binary", + charset + ); + } else if (tmp) { + tmp = decodeText(tmp, "binary", "utf8"); + } + if (res[p] === void 0) { + if (tmp) { + res[p] = tmp; + } + } else { + res[p][1] = tmp; + } + return res; + } + module2.exports = parseParams; + } +}); + +// node_modules/@fastify/busboy/lib/utils/basename.js +var require_basename = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) { + "use strict"; + module2.exports = function basename(path3) { + if (typeof path3 !== "string") { + return ""; + } + for (var i = path3.length - 1; i >= 0; --i) { + switch (path3.charCodeAt(i)) { + case 47: + // '/' + case 92: + path3 = path3.slice(i + 1); + return path3 === ".." || path3 === "." ? "" : path3; + } + } + return path3 === ".." || path3 === "." ? "" : path3; + }; + } +}); + +// node_modules/@fastify/busboy/lib/types/multipart.js +var require_multipart = __commonJS({ + "node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) { + "use strict"; + var { Readable } = require("node:stream"); + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var parseParams = require_parseParams(); + var decodeText = require_decodeText(); + var basename = require_basename(); + var getLimit = require_getLimit(); + var RE_BOUNDARY = /^boundary$/i; + var RE_FIELD = /^form-data$/i; + var RE_CHARSET = /^charset$/i; + var RE_FILENAME = /^filename$/i; + var RE_NAME = /^name$/i; + Multipart.detect = /^multipart\/form-data/i; + function Multipart(boy, cfg) { + let i; + let len; + const self2 = this; + let boundary; + const limits = cfg.limits; + const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0); + const parsedConType = cfg.parsedConType || []; + const defCharset = cfg.defCharset || "utf8"; + const preservePath = cfg.preservePath; + const fileOpts = { highWaterMark: cfg.fileHwm }; + for (i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) { + boundary = parsedConType[i][1]; + break; + } + } + function checkFinished() { + if (nends === 0 && finished && !boy._done) { + finished = false; + self2.end(); + } + } + if (typeof boundary !== "string") { + throw new Error("Multipart: Boundary not found"); + } + const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + const fileSizeLimit = getLimit(limits, "fileSize", Infinity); + const filesLimit = getLimit(limits, "files", Infinity); + const fieldsLimit = getLimit(limits, "fields", Infinity); + const partsLimit = getLimit(limits, "parts", Infinity); + const headerPairsLimit = getLimit(limits, "headerPairs", 2e3); + const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024); + let nfiles = 0; + let nfields = 0; + let nends = 0; + let curFile; + let curField; + let finished = false; + this._needDrain = false; + this._pause = false; + this._cb = void 0; + this._nparts = 0; + this._boy = boy; + const parserCfg = { + boundary, + maxHeaderPairs: headerPairsLimit, + maxHeaderSize: headerSizeLimit, + partHwm: fileOpts.highWaterMark, + highWaterMark: cfg.highWaterMark + }; + this.parser = new Dicer(parserCfg); + this.parser.on("drain", function() { + self2._needDrain = false; + if (self2._cb && !self2._pause) { + const cb = self2._cb; + self2._cb = void 0; + cb(); + } + }).on("part", function onPart(part) { + if (++self2._nparts > partsLimit) { + self2.parser.removeListener("part", onPart); + self2.parser.on("part", skipPart); + boy.hitPartsLimit = true; + boy.emit("partsLimit"); + return skipPart(part); + } + if (curField) { + const field = curField; + field.emit("end"); + field.removeAllListeners("end"); + } + part.on("header", function(header) { + let contype; + let fieldname; + let parsed; + let charset; + let encoding; + let filename; + let nsize = 0; + if (header["content-type"]) { + parsed = parseParams(header["content-type"][0]); + if (parsed[0]) { + contype = parsed[0].toLowerCase(); + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_CHARSET.test(parsed[i][0])) { + charset = parsed[i][1].toLowerCase(); + break; + } + } + } + } + if (contype === void 0) { + contype = "text/plain"; + } + if (charset === void 0) { + charset = defCharset; + } + if (header["content-disposition"]) { + parsed = parseParams(header["content-disposition"][0]); + if (!RE_FIELD.test(parsed[0])) { + return skipPart(part); + } + for (i = 0, len = parsed.length; i < len; ++i) { + if (RE_NAME.test(parsed[i][0])) { + fieldname = parsed[i][1]; + } else if (RE_FILENAME.test(parsed[i][0])) { + filename = parsed[i][1]; + if (!preservePath) { + filename = basename(filename); + } + } + } + } else { + return skipPart(part); + } + if (header["content-transfer-encoding"]) { + encoding = header["content-transfer-encoding"][0].toLowerCase(); + } else { + encoding = "7bit"; + } + let onData, onEnd; + if (isPartAFile(fieldname, contype, filename)) { + if (nfiles === filesLimit) { + if (!boy.hitFilesLimit) { + boy.hitFilesLimit = true; + boy.emit("filesLimit"); + } + return skipPart(part); + } + ++nfiles; + if (boy.listenerCount("file") === 0) { + self2.parser._ignore(); + return; + } + ++nends; + const file = new FileStream(fileOpts); + curFile = file; + file.on("end", function() { + --nends; + self2._pause = false; + checkFinished(); + if (self2._cb && !self2._needDrain) { + const cb = self2._cb; + self2._cb = void 0; + cb(); + } + }); + file._read = function(n) { + if (!self2._pause) { + return; + } + self2._pause = false; + if (self2._cb && !self2._needDrain) { + const cb = self2._cb; + self2._cb = void 0; + cb(); + } + }; + boy.emit("file", fieldname, file, filename, encoding, contype); + onData = function(data) { + if ((nsize += data.length) > fileSizeLimit) { + const extralen = fileSizeLimit - nsize + data.length; + if (extralen > 0) { + file.push(data.slice(0, extralen)); + } + file.truncated = true; + file.bytesRead = fileSizeLimit; + part.removeAllListeners("data"); + file.emit("limit"); + return; + } else if (!file.push(data)) { + self2._pause = true; + } + file.bytesRead = nsize; + }; + onEnd = function() { + curFile = void 0; + file.push(null); + }; + } else { + if (nfields === fieldsLimit) { + if (!boy.hitFieldsLimit) { + boy.hitFieldsLimit = true; + boy.emit("fieldsLimit"); + } + return skipPart(part); + } + ++nfields; + ++nends; + let buffer = ""; + let truncated = false; + curField = part; + onData = function(data) { + if ((nsize += data.length) > fieldSizeLimit) { + const extralen = fieldSizeLimit - (nsize - data.length); + buffer += data.toString("binary", 0, extralen); + truncated = true; + part.removeAllListeners("data"); + } else { + buffer += data.toString("binary"); + } + }; + onEnd = function() { + curField = void 0; + if (buffer.length) { + buffer = decodeText(buffer, "binary", charset); + } + boy.emit("field", fieldname, buffer, false, truncated, encoding, contype); + --nends; + checkFinished(); + }; + } + part._readableState.sync = false; + part.on("data", onData); + part.on("end", onEnd); + }).on("error", function(err) { + if (curFile) { + curFile.emit("error", err); + } + }); + }).on("error", function(err) { + boy.emit("error", err); + }).on("finish", function() { + finished = true; + checkFinished(); + }); + } + Multipart.prototype.write = function(chunk, cb) { + const r = this.parser.write(chunk); + if (r && !this._pause) { + cb(); + } else { + this._needDrain = !r; + this._cb = cb; + } + }; + Multipart.prototype.end = function() { + const self2 = this; + if (self2.parser.writable) { + self2.parser.end(); + } else if (!self2._boy._done) { + process.nextTick(function() { + self2._boy._done = true; + self2._boy.emit("finish"); + }); + } + }; + function skipPart(part) { + part.resume(); + } + function FileStream(opts) { + Readable.call(this, opts); + this.bytesRead = 0; + this.truncated = false; + } + inherits(FileStream, Readable); + FileStream.prototype._read = function(n) { + }; + module2.exports = Multipart; + } +}); + +// node_modules/@fastify/busboy/lib/utils/Decoder.js +var require_Decoder = __commonJS({ + "node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) { + "use strict"; + var RE_PLUS = /\+/g; + var HEX = [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ]; + function Decoder() { + this.buffer = void 0; + } + Decoder.prototype.write = function(str) { + str = str.replace(RE_PLUS, " "); + let res = ""; + let i = 0; + let p = 0; + const len = str.length; + for (; i < len; ++i) { + if (this.buffer !== void 0) { + if (!HEX[str.charCodeAt(i)]) { + res += "%" + this.buffer; + this.buffer = void 0; + --i; + } else { + this.buffer += str[i]; + ++p; + if (this.buffer.length === 2) { + res += String.fromCharCode(parseInt(this.buffer, 16)); + this.buffer = void 0; + } + } + } else if (str[i] === "%") { + if (i > p) { + res += str.substring(p, i); + p = i; + } + this.buffer = ""; + ++p; + } + } + if (p < len && this.buffer === void 0) { + res += str.substring(p); + } + return res; + }; + Decoder.prototype.reset = function() { + this.buffer = void 0; + }; + module2.exports = Decoder; + } +}); + +// node_modules/@fastify/busboy/lib/types/urlencoded.js +var require_urlencoded = __commonJS({ + "node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) { + "use strict"; + var Decoder = require_Decoder(); + var decodeText = require_decodeText(); + var getLimit = require_getLimit(); + var RE_CHARSET = /^charset$/i; + UrlEncoded.detect = /^application\/x-www-form-urlencoded/i; + function UrlEncoded(boy, cfg) { + const limits = cfg.limits; + const parsedConType = cfg.parsedConType; + this.boy = boy; + this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); + this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100); + this.fieldsLimit = getLimit(limits, "fields", Infinity); + let charset; + for (var i = 0, len = parsedConType.length; i < len; ++i) { + if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) { + charset = parsedConType[i][1].toLowerCase(); + break; + } + } + if (charset === void 0) { + charset = cfg.defCharset || "utf8"; + } + this.decoder = new Decoder(); + this.charset = charset; + this._fields = 0; + this._state = "key"; + this._checkingBytes = true; + this._bytesKey = 0; + this._bytesVal = 0; + this._key = ""; + this._val = ""; + this._keyTrunc = false; + this._valTrunc = false; + this._hitLimit = false; + } + UrlEncoded.prototype.write = function(data, cb) { + if (this._fields === this.fieldsLimit) { + if (!this.boy.hitFieldsLimit) { + this.boy.hitFieldsLimit = true; + this.boy.emit("fieldsLimit"); + } + return cb(); + } + let idxeq; + let idxamp; + let i; + let p = 0; + const len = data.length; + while (p < len) { + if (this._state === "key") { + idxeq = idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 61) { + idxeq = i; + break; + } else if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesKey; + } + } + if (idxeq !== void 0) { + if (idxeq > p) { + this._key += this.decoder.write(data.toString("binary", p, idxeq)); + } + this._state = "val"; + this._hitLimit = false; + this._checkingBytes = true; + this._val = ""; + this._bytesVal = 0; + this._valTrunc = false; + this.decoder.reset(); + p = idxeq + 1; + } else if (idxamp !== void 0) { + ++this._fields; + let key; + const keyTrunc = this._keyTrunc; + if (idxamp > p) { + key = this._key += this.decoder.write(data.toString("binary", p, idxamp)); + } else { + key = this._key; + } + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + if (key.length) { + this.boy.emit( + "field", + decodeText(key, "binary", this.charset), + "", + keyTrunc, + false + ); + } + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._key += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) { + this._checkingBytes = false; + this._keyTrunc = true; + } + } else { + if (p < len) { + this._key += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } else { + idxamp = void 0; + for (i = p; i < len; ++i) { + if (!this._checkingBytes) { + ++p; + } + if (data[i] === 38) { + idxamp = i; + break; + } + if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) { + this._hitLimit = true; + break; + } else if (this._checkingBytes) { + ++this._bytesVal; + } + } + if (idxamp !== void 0) { + ++this._fields; + if (idxamp > p) { + this._val += this.decoder.write(data.toString("binary", p, idxamp)); + } + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + this._state = "key"; + this._hitLimit = false; + this._checkingBytes = true; + this._key = ""; + this._bytesKey = 0; + this._keyTrunc = false; + this.decoder.reset(); + p = idxamp + 1; + if (this._fields === this.fieldsLimit) { + return cb(); + } + } else if (this._hitLimit) { + if (i > p) { + this._val += this.decoder.write(data.toString("binary", p, i)); + } + p = i; + if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) { + this._checkingBytes = false; + this._valTrunc = true; + } + } else { + if (p < len) { + this._val += this.decoder.write(data.toString("binary", p)); + } + p = len; + } + } + } + cb(); + }; + UrlEncoded.prototype.end = function() { + if (this.boy._done) { + return; + } + if (this._state === "key" && this._key.length > 0) { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + "", + this._keyTrunc, + false + ); + } else if (this._state === "val") { + this.boy.emit( + "field", + decodeText(this._key, "binary", this.charset), + decodeText(this._val, "binary", this.charset), + this._keyTrunc, + this._valTrunc + ); + } + this.boy._done = true; + this.boy.emit("finish"); + }; + module2.exports = UrlEncoded; + } +}); + +// node_modules/@fastify/busboy/lib/main.js +var require_main = __commonJS({ + "node_modules/@fastify/busboy/lib/main.js"(exports2, module2) { + "use strict"; + var WritableStream = require("node:stream").Writable; + var { inherits } = require("node:util"); + var Dicer = require_Dicer(); + var MultipartParser = require_multipart(); + var UrlencodedParser = require_urlencoded(); + var parseParams = require_parseParams(); + function Busboy(opts) { + if (!(this instanceof Busboy)) { + return new Busboy(opts); + } + if (typeof opts !== "object") { + throw new TypeError("Busboy expected an options-Object."); + } + if (typeof opts.headers !== "object") { + throw new TypeError("Busboy expected an options-Object with headers-attribute."); + } + if (typeof opts.headers["content-type"] !== "string") { + throw new TypeError("Missing Content-Type-header."); + } + const { + headers, + ...streamOptions + } = opts; + this.opts = { + autoDestroy: false, + ...streamOptions + }; + WritableStream.call(this, this.opts); + this._done = false; + this._parser = this.getParserByHeaders(headers); + this._finished = false; + } + inherits(Busboy, WritableStream); + Busboy.prototype.emit = function(ev) { + if (ev === "finish") { + if (!this._done) { + this._parser?.end(); + return; + } else if (this._finished) { + return; + } + this._finished = true; + } + WritableStream.prototype.emit.apply(this, arguments); + }; + Busboy.prototype.getParserByHeaders = function(headers) { + const parsed = parseParams(headers["content-type"]); + const cfg = { + defCharset: this.opts.defCharset, + fileHwm: this.opts.fileHwm, + headers, + highWaterMark: this.opts.highWaterMark, + isPartAFile: this.opts.isPartAFile, + limits: this.opts.limits, + parsedConType: parsed, + preservePath: this.opts.preservePath + }; + if (MultipartParser.detect.test(parsed[0])) { + return new MultipartParser(this, cfg); + } + if (UrlencodedParser.detect.test(parsed[0])) { + return new UrlencodedParser(this, cfg); + } + throw new Error("Unsupported Content-Type."); + }; + Busboy.prototype._write = function(chunk, encoding, cb) { + this._parser.write(chunk, cb); + }; + module2.exports = Busboy; + module2.exports.default = Busboy; + module2.exports.Busboy = Busboy; + module2.exports.Dicer = Dicer; + } +}); + +// node_modules/undici/lib/fetch/constants.js +var require_constants2 = __commonJS({ + "node_modules/undici/lib/fetch/constants.js"(exports2, module2) { + "use strict"; + var { MessageChannel, receiveMessageOnPort } = require("worker_threads"); + var corsSafeListedMethods = ["GET", "HEAD", "POST"]; + var corsSafeListedMethodsSet = new Set(corsSafeListedMethods); + var nullBodyStatus = [101, 204, 205, 304]; + var redirectStatus = [301, 302, 303, 307, 308]; + var redirectStatusSet = new Set(redirectStatus); + var badPorts = [ + "1", + "7", + "9", + "11", + "13", + "15", + "17", + "19", + "20", + "21", + "22", + "23", + "25", + "37", + "42", + "43", + "53", + "69", + "77", + "79", + "87", + "95", + "101", + "102", + "103", + "104", + "109", + "110", + "111", + "113", + "115", + "117", + "119", + "123", + "135", + "137", + "139", + "143", + "161", + "179", + "389", + "427", + "465", + "512", + "513", + "514", + "515", + "526", + "530", + "531", + "532", + "540", + "548", + "554", + "556", + "563", + "587", + "601", + "636", + "989", + "990", + "993", + "995", + "1719", + "1720", + "1723", + "2049", + "3659", + "4045", + "5060", + "5061", + "6000", + "6566", + "6665", + "6666", + "6667", + "6668", + "6669", + "6697", + "10080" + ]; + var badPortsSet = new Set(badPorts); + var referrerPolicy = [ + "", + "no-referrer", + "no-referrer-when-downgrade", + "same-origin", + "origin", + "strict-origin", + "origin-when-cross-origin", + "strict-origin-when-cross-origin", + "unsafe-url" + ]; + var referrerPolicySet = new Set(referrerPolicy); + var requestRedirect = ["follow", "manual", "error"]; + var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"]; + var safeMethodsSet = new Set(safeMethods); + var requestMode = ["navigate", "same-origin", "no-cors", "cors"]; + var requestCredentials = ["omit", "same-origin", "include"]; + var requestCache = [ + "default", + "no-store", + "reload", + "no-cache", + "force-cache", + "only-if-cached" + ]; + var requestBodyHeader = [ + "content-encoding", + "content-language", + "content-location", + "content-type", + // See https://github.com/nodejs/undici/issues/2021 + // 'Content-Length' is a forbidden header name, which is typically + // removed in the Headers implementation. However, undici doesn't + // filter out headers, so we add it here. + "content-length" + ]; + var requestDuplex = [ + "half" + ]; + var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"]; + var forbiddenMethodsSet = new Set(forbiddenMethods); + var subresource = [ + "audio", + "audioworklet", + "font", + "image", + "manifest", + "paintworklet", + "script", + "style", + "track", + "video", + "xslt", + "" + ]; + var subresourceSet = new Set(subresource); + var DOMException2 = globalThis.DOMException ?? (() => { + try { + atob("~"); + } catch (err) { + return Object.getPrototypeOf(err).constructor; + } + })(); + var channel; + var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js + // structuredClone was added in v17.0.0, but fetch supports v16.8 + function structuredClone2(value, options = void 0) { + if (arguments.length === 0) { + throw new TypeError("missing argument"); + } + if (!channel) { + channel = new MessageChannel(); + } + channel.port1.unref(); + channel.port2.unref(); + channel.port1.postMessage(value, options?.transfer); + return receiveMessageOnPort(channel.port2).message; + }; + module2.exports = { + DOMException: DOMException2, + structuredClone, + subresource, + forbiddenMethods, + requestBodyHeader, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + redirectStatus, + corsSafeListedMethods, + nullBodyStatus, + safeMethods, + badPorts, + requestDuplex, + subresourceSet, + badPortsSet, + redirectStatusSet, + corsSafeListedMethodsSet, + safeMethodsSet, + forbiddenMethodsSet, + referrerPolicySet + }; + } +}); + +// node_modules/undici/lib/fetch/global.js +var require_global = __commonJS({ + "node_modules/undici/lib/fetch/global.js"(exports2, module2) { + "use strict"; + var globalOrigin = Symbol.for("undici.globalOrigin.1"); + function getGlobalOrigin() { + return globalThis[globalOrigin]; + } + function setGlobalOrigin(newOrigin) { + if (newOrigin === void 0) { + Object.defineProperty(globalThis, globalOrigin, { + value: void 0, + writable: true, + enumerable: false, + configurable: false + }); + return; + } + const parsedURL = new URL(newOrigin); + if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") { + throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`); + } + Object.defineProperty(globalThis, globalOrigin, { + value: parsedURL, + writable: true, + enumerable: false, + configurable: false + }); + } + module2.exports = { + getGlobalOrigin, + setGlobalOrigin + }; + } +}); + +// node_modules/undici/lib/fetch/util.js +var require_util2 = __commonJS({ + "node_modules/undici/lib/fetch/util.js"(exports2, module2) { + "use strict"; + var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2(); + var { getGlobalOrigin } = require_global(); + var { performance: performance2 } = require("perf_hooks"); + var { isBlobLike: isBlobLike2, toUSVString, ReadableStreamFrom: ReadableStreamFrom3 } = require_util(); + var assert = require("assert"); + var { isUint8Array } = require("util/types"); + var supportedHashes = []; + var crypto; + try { + crypto = require("crypto"); + const possibleRelevantHashes = ["sha256", "sha384", "sha512"]; + supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)); + } catch { + } + function responseURL(response) { + const urlList = response.urlList; + const length = urlList.length; + return length === 0 ? null : urlList[length - 1].toString(); + } + function responseLocationURL(response, requestFragment) { + if (!redirectStatusSet.has(response.status)) { + return null; + } + let location = response.headersList.get("location"); + if (location !== null && isValidHeaderValue(location)) { + location = new URL(location, responseURL(response)); + } + if (location && !location.hash) { + location.hash = requestFragment; + } + return location; + } + function requestCurrentURL(request) { + return request.urlList[request.urlList.length - 1]; + } + function requestBadPort(request) { + const url = requestCurrentURL(request); + if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) { + return "blocked"; + } + return "allowed"; + } + function isErrorLike(object) { + return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException"); + } + function isValidReasonPhrase(statusText) { + for (let i = 0; i < statusText.length; ++i) { + const c = statusText.charCodeAt(i); + if (!(c === 9 || // HTAB + c >= 32 && c <= 126 || // SP / VCHAR + c >= 128 && c <= 255)) { + return false; + } + } + return true; + } + function isTokenCharCode(c) { + switch (c) { + case 34: + case 40: + case 41: + case 44: + case 47: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 91: + case 92: + case 93: + case 123: + case 125: + return false; + default: + return c >= 33 && c <= 126; + } + } + function isValidHTTPToken(characters) { + if (characters.length === 0) { + return false; + } + for (let i = 0; i < characters.length; ++i) { + if (!isTokenCharCode(characters.charCodeAt(i))) { + return false; + } + } + return true; + } + function isValidHeaderName(potentialValue) { + return isValidHTTPToken(potentialValue); + } + function isValidHeaderValue(potentialValue) { + if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) { + return false; + } + if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) { + return false; + } + return true; + } + function setRequestReferrerPolicyOnRedirect(request, actualResponse) { + const { headersList } = actualResponse; + const policyHeader = (headersList.get("referrer-policy") ?? "").split(","); + let policy = ""; + if (policyHeader.length > 0) { + for (let i = policyHeader.length; i !== 0; i--) { + const token = policyHeader[i - 1].trim(); + if (referrerPolicyTokens.has(token)) { + policy = token; + break; + } + } + } + if (policy !== "") { + request.referrerPolicy = policy; + } + } + function crossOriginResourcePolicyCheck() { + return "allowed"; + } + function corsCheck() { + return "success"; + } + function TAOCheck() { + return "success"; + } + function appendFetchMetadata(httpRequest) { + let header = null; + header = httpRequest.mode; + httpRequest.headersList.set("sec-fetch-mode", header); + } + function appendRequestOriginHeader(request) { + let serializedOrigin = request.origin; + if (request.responseTainting === "cors" || request.mode === "websocket") { + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } else if (request.method !== "GET" && request.method !== "HEAD") { + switch (request.referrerPolicy) { + case "no-referrer": + serializedOrigin = null; + break; + case "no-referrer-when-downgrade": + case "strict-origin": + case "strict-origin-when-cross-origin": + if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + case "same-origin": + if (!sameOrigin(request, requestCurrentURL(request))) { + serializedOrigin = null; + } + break; + default: + } + if (serializedOrigin) { + request.headersList.append("origin", serializedOrigin); + } + } + } + function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) { + return performance2.now(); + } + function createOpaqueTimingInfo(timingInfo) { + return { + startTime: timingInfo.startTime ?? 0, + redirectStartTime: 0, + redirectEndTime: 0, + postRedirectStartTime: timingInfo.startTime ?? 0, + finalServiceWorkerStartTime: 0, + finalNetworkResponseStartTime: 0, + finalNetworkRequestStartTime: 0, + endTime: 0, + encodedBodySize: 0, + decodedBodySize: 0, + finalConnectionTimingInfo: null + }; + } + function makePolicyContainer() { + return { + referrerPolicy: "strict-origin-when-cross-origin" + }; + } + function clonePolicyContainer(policyContainer) { + return { + referrerPolicy: policyContainer.referrerPolicy + }; + } + function determineRequestsReferrer(request) { + const policy = request.referrerPolicy; + assert(policy); + let referrerSource = null; + if (request.referrer === "client") { + const globalOrigin = getGlobalOrigin(); + if (!globalOrigin || globalOrigin.origin === "null") { + return "no-referrer"; + } + referrerSource = new URL(globalOrigin); + } else if (request.referrer instanceof URL) { + referrerSource = request.referrer; + } + let referrerURL = stripURLForReferrer(referrerSource); + const referrerOrigin = stripURLForReferrer(referrerSource, true); + if (referrerURL.toString().length > 4096) { + referrerURL = referrerOrigin; + } + const areSameOrigin = sameOrigin(request, referrerURL); + const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request.url); + switch (policy) { + case "origin": + return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true); + case "unsafe-url": + return referrerURL; + case "same-origin": + return areSameOrigin ? referrerOrigin : "no-referrer"; + case "origin-when-cross-origin": + return areSameOrigin ? referrerURL : referrerOrigin; + case "strict-origin-when-cross-origin": { + const currentURL = requestCurrentURL(request); + if (sameOrigin(referrerURL, currentURL)) { + return referrerURL; + } + if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) { + return "no-referrer"; + } + return referrerOrigin; + } + case "strict-origin": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + case "no-referrer-when-downgrade": + // eslint-disable-line + /** + * 1. If referrerURL is a potentially trustworthy URL and + * request’s current URL is not a potentially trustworthy URL, + * then return no referrer. + * 2. Return referrerOrigin + */ + default: + return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin; + } + } + function stripURLForReferrer(url, originOnly) { + assert(url instanceof URL); + if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") { + return "no-referrer"; + } + url.username = ""; + url.password = ""; + url.hash = ""; + if (originOnly) { + url.pathname = ""; + url.search = ""; + } + return url; + } + function isURLPotentiallyTrustworthy(url) { + if (!(url instanceof URL)) { + return false; + } + if (url.href === "about:blank" || url.href === "about:srcdoc") { + return true; + } + if (url.protocol === "data:") return true; + if (url.protocol === "file:") return true; + return isOriginPotentiallyTrustworthy(url.origin); + function isOriginPotentiallyTrustworthy(origin) { + if (origin == null || origin === "null") return false; + const originAsURL = new URL(origin); + if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") { + return true; + } + if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) { + return true; + } + return false; + } + } + function bytesMatch(bytes, metadataList) { + if (crypto === void 0) { + return true; + } + const parsedMetadata = parseMetadata(metadataList); + if (parsedMetadata === "no metadata") { + return true; + } + if (parsedMetadata.length === 0) { + return true; + } + const strongest = getStrongestMetadata(parsedMetadata); + const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest); + for (const item of metadata) { + const algorithm = item.algo; + const expectedValue = item.hash; + let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64"); + if (actualValue[actualValue.length - 1] === "=") { + if (actualValue[actualValue.length - 2] === "=") { + actualValue = actualValue.slice(0, -2); + } else { + actualValue = actualValue.slice(0, -1); + } + } + if (compareBase64Mixed(actualValue, expectedValue)) { + return true; + } + } + return false; + } + var parseHashWithOptions = /(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i; + function parseMetadata(metadata) { + const result = []; + let empty = true; + for (const token of metadata.split(" ")) { + empty = false; + const parsedToken = parseHashWithOptions.exec(token); + if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) { + continue; + } + const algorithm = parsedToken.groups.algo.toLowerCase(); + if (supportedHashes.includes(algorithm)) { + result.push(parsedToken.groups); + } + } + if (empty === true) { + return "no metadata"; + } + return result; + } + function getStrongestMetadata(metadataList) { + let algorithm = metadataList[0].algo; + if (algorithm[3] === "5") { + return algorithm; + } + for (let i = 1; i < metadataList.length; ++i) { + const metadata = metadataList[i]; + if (metadata.algo[3] === "5") { + algorithm = "sha512"; + break; + } else if (algorithm[3] === "3") { + continue; + } else if (metadata.algo[3] === "3") { + algorithm = "sha384"; + } + } + return algorithm; + } + function filterMetadataListByAlgorithm(metadataList, algorithm) { + if (metadataList.length === 1) { + return metadataList; + } + let pos = 0; + for (let i = 0; i < metadataList.length; ++i) { + if (metadataList[i].algo === algorithm) { + metadataList[pos++] = metadataList[i]; + } + } + metadataList.length = pos; + return metadataList; + } + function compareBase64Mixed(actualValue, expectedValue) { + if (actualValue.length !== expectedValue.length) { + return false; + } + for (let i = 0; i < actualValue.length; ++i) { + if (actualValue[i] !== expectedValue[i]) { + if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") { + continue; + } + return false; + } + } + return true; + } + function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) { + } + function sameOrigin(A, B) { + if (A.origin === B.origin && A.origin === "null") { + return true; + } + if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) { + return true; + } + return false; + } + function createDeferredPromise() { + let res; + let rej; + const promise = new Promise((resolve, reject) => { + res = resolve; + rej = reject; + }); + return { promise, resolve: res, reject: rej }; + } + function isAborted(fetchParams) { + return fetchParams.controller.state === "aborted"; + } + function isCancelled(fetchParams) { + return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated"; + } + var normalizeMethodRecord = { + delete: "DELETE", + DELETE: "DELETE", + get: "GET", + GET: "GET", + head: "HEAD", + HEAD: "HEAD", + options: "OPTIONS", + OPTIONS: "OPTIONS", + post: "POST", + POST: "POST", + put: "PUT", + PUT: "PUT" + }; + Object.setPrototypeOf(normalizeMethodRecord, null); + function normalizeMethod(method) { + return normalizeMethodRecord[method.toLowerCase()] ?? method; + } + function serializeJavascriptValueToJSONString(value) { + const result = JSON.stringify(value); + if (result === void 0) { + throw new TypeError("Value is not JSON serializable"); + } + assert(typeof result === "string"); + return result; + } + var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); + function makeIterator(iterator, name, kind) { + const object = { + index: 0, + kind, + target: iterator + }; + const i = { + next() { + if (Object.getPrototypeOf(this) !== i) { + throw new TypeError( + `'next' called on an object that does not implement interface ${name} Iterator.` + ); + } + const { index, kind: kind2, target } = object; + const values = target(); + const len = values.length; + if (index >= len) { + return { value: void 0, done: true }; + } + const pair = values[index]; + object.index = index + 1; + return iteratorResult(pair, kind2); + }, + // The class string of an iterator prototype object for a given interface is the + // result of concatenating the identifier of the interface and the string " Iterator". + [Symbol.toStringTag]: `${name} Iterator` + }; + Object.setPrototypeOf(i, esIteratorPrototype); + return Object.setPrototypeOf({}, i); + } + function iteratorResult(pair, kind) { + let result; + switch (kind) { + case "key": { + result = pair[0]; + break; + } + case "value": { + result = pair[1]; + break; + } + case "key+value": { + result = pair; + break; + } + } + return { value: result, done: false }; + } + async function fullyReadBody(body, processBody, processBodyError) { + const successSteps = processBody; + const errorSteps = processBodyError; + let reader; + try { + reader = body.stream.getReader(); + } catch (e) { + errorSteps(e); + return; + } + try { + const result = await readAllBytes(reader); + successSteps(result); + } catch (e) { + errorSteps(e); + } + } + var ReadableStream = globalThis.ReadableStream; + function isReadableStreamLike(stream) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function"; + } + var MAXIMUM_ARGUMENT_LENGTH = 65535; + function isomorphicDecode(input) { + if (input.length < MAXIMUM_ARGUMENT_LENGTH) { + return String.fromCharCode(...input); + } + return input.reduce((previous, current) => previous + String.fromCharCode(current), ""); + } + function readableStreamClose(controller) { + try { + controller.close(); + } catch (err) { + if (!err.message.includes("Controller is already closed")) { + throw err; + } + } + } + function isomorphicEncode(input) { + for (let i = 0; i < input.length; i++) { + assert(input.charCodeAt(i) <= 255); + } + return input; + } + async function readAllBytes(reader) { + const bytes = []; + let byteLength = 0; + while (true) { + const { done, value: chunk } = await reader.read(); + if (done) { + return Buffer.concat(bytes, byteLength); + } + if (!isUint8Array(chunk)) { + throw new TypeError("Received non-Uint8Array chunk"); + } + bytes.push(chunk); + byteLength += chunk.length; + } + } + function urlIsLocal(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "about:" || protocol === "blob:" || protocol === "data:"; + } + function urlHasHttpsScheme(url) { + if (typeof url === "string") { + return url.startsWith("https:"); + } + return url.protocol === "https:"; + } + function urlIsHttpHttpsScheme(url) { + assert("protocol" in url); + const protocol = url.protocol; + return protocol === "http:" || protocol === "https:"; + } + var hasOwn3 = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key)); + module2.exports = { + isAborted, + isCancelled, + createDeferredPromise, + ReadableStreamFrom: ReadableStreamFrom3, + toUSVString, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + coarsenedSharedCurrentTime, + determineRequestsReferrer, + makePolicyContainer, + clonePolicyContainer, + appendFetchMetadata, + appendRequestOriginHeader, + TAOCheck, + corsCheck, + crossOriginResourcePolicyCheck, + createOpaqueTimingInfo, + setRequestReferrerPolicyOnRedirect, + isValidHTTPToken, + requestBadPort, + requestCurrentURL, + responseURL, + responseLocationURL, + isBlobLike: isBlobLike2, + isURLPotentiallyTrustworthy, + isValidReasonPhrase, + sameOrigin, + normalizeMethod, + serializeJavascriptValueToJSONString, + makeIterator, + isValidHeaderName, + isValidHeaderValue, + hasOwn: hasOwn3, + isErrorLike, + fullyReadBody, + bytesMatch, + isReadableStreamLike, + readableStreamClose, + isomorphicEncode, + isomorphicDecode, + urlIsLocal, + urlHasHttpsScheme, + urlIsHttpHttpsScheme, + readAllBytes, + normalizeMethodRecord, + parseMetadata + }; + } +}); + +// node_modules/undici/lib/fetch/symbols.js +var require_symbols2 = __commonJS({ + "node_modules/undici/lib/fetch/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kUrl: Symbol("url"), + kHeaders: Symbol("headers"), + kSignal: Symbol("signal"), + kState: Symbol("state"), + kGuard: Symbol("guard"), + kRealm: Symbol("realm") + }; + } +}); + +// node_modules/undici/lib/fetch/webidl.js +var require_webidl = __commonJS({ + "node_modules/undici/lib/fetch/webidl.js"(exports2, module2) { + "use strict"; + var { types } = require("util"); + var { hasOwn: hasOwn3, toUSVString } = require_util2(); + var webidl = {}; + webidl.converters = {}; + webidl.util = {}; + webidl.errors = {}; + webidl.errors.exception = function(message) { + return new TypeError(`${message.header}: ${message.message}`); + }; + webidl.errors.conversionFailed = function(context3) { + const plural = context3.types.length === 1 ? "" : " one of"; + const message = `${context3.argument} could not be converted to${plural}: ${context3.types.join(", ")}.`; + return webidl.errors.exception({ + header: context3.prefix, + message + }); + }; + webidl.errors.invalidArgument = function(context3) { + return webidl.errors.exception({ + header: context3.prefix, + message: `"${context3.value}" is an invalid ${context3.type}.` + }); + }; + webidl.brandCheck = function(V, I, opts = void 0) { + if (opts?.strict !== false && !(V instanceof I)) { + throw new TypeError("Illegal invocation"); + } else { + return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag]; + } + }; + webidl.argumentLengthCheck = function({ length }, min, ctx) { + if (length < min) { + throw webidl.errors.exception({ + message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`, + ...ctx + }); + } + }; + webidl.illegalConstructor = function() { + throw webidl.errors.exception({ + header: "TypeError", + message: "Illegal constructor" + }); + }; + webidl.util.Type = function(V) { + switch (typeof V) { + case "undefined": + return "Undefined"; + case "boolean": + return "Boolean"; + case "string": + return "String"; + case "symbol": + return "Symbol"; + case "number": + return "Number"; + case "bigint": + return "BigInt"; + case "function": + case "object": { + if (V === null) { + return "Null"; + } + return "Object"; + } + } + }; + webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) { + let upperBound; + let lowerBound; + if (bitLength === 64) { + upperBound = Math.pow(2, 53) - 1; + if (signedness === "unsigned") { + lowerBound = 0; + } else { + lowerBound = Math.pow(-2, 53) + 1; + } + } else if (signedness === "unsigned") { + lowerBound = 0; + upperBound = Math.pow(2, bitLength) - 1; + } else { + lowerBound = Math.pow(-2, bitLength) - 1; + upperBound = Math.pow(2, bitLength - 1) - 1; + } + let x = Number(V); + if (x === 0) { + x = 0; + } + if (opts.enforceRange === true) { + if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Could not convert ${V} to an integer.` + }); + } + x = webidl.util.IntegerPart(x); + if (x < lowerBound || x > upperBound) { + throw webidl.errors.exception({ + header: "Integer conversion", + message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` + }); + } + return x; + } + if (!Number.isNaN(x) && opts.clamp === true) { + x = Math.min(Math.max(x, lowerBound), upperBound); + if (Math.floor(x) % 2 === 0) { + x = Math.floor(x); + } else { + x = Math.ceil(x); + } + return x; + } + if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { + return 0; + } + x = webidl.util.IntegerPart(x); + x = x % Math.pow(2, bitLength); + if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) { + return x - Math.pow(2, bitLength); + } + return x; + }; + webidl.util.IntegerPart = function(n) { + const r = Math.floor(Math.abs(n)); + if (n < 0) { + return -1 * r; + } + return r; + }; + webidl.sequenceConverter = function(converter) { + return (V) => { + if (webidl.util.Type(V) !== "Object") { + throw webidl.errors.exception({ + header: "Sequence", + message: `Value of type ${webidl.util.Type(V)} is not an Object.` + }); + } + const method = V?.[Symbol.iterator]?.(); + const seq = []; + if (method === void 0 || typeof method.next !== "function") { + throw webidl.errors.exception({ + header: "Sequence", + message: "Object is not an iterator." + }); + } + while (true) { + const { done, value } = method.next(); + if (done) { + break; + } + seq.push(converter(value)); + } + return seq; + }; + }; + webidl.recordConverter = function(keyConverter, valueConverter) { + return (O) => { + if (webidl.util.Type(O) !== "Object") { + throw webidl.errors.exception({ + header: "Record", + message: `Value of type ${webidl.util.Type(O)} is not an Object.` + }); + } + const result = {}; + if (!types.isProxy(O)) { + const keys2 = Object.keys(O); + for (const key of keys2) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + return result; + } + const keys = Reflect.ownKeys(O); + for (const key of keys) { + const desc = Reflect.getOwnPropertyDescriptor(O, key); + if (desc?.enumerable) { + const typedKey = keyConverter(key); + const typedValue = valueConverter(O[key]); + result[typedKey] = typedValue; + } + } + return result; + }; + }; + webidl.interfaceConverter = function(i) { + return (V, opts = {}) => { + if (opts.strict !== false && !(V instanceof i)) { + throw webidl.errors.exception({ + header: i.name, + message: `Expected ${V} to be an instance of ${i.name}.` + }); + } + return V; + }; + }; + webidl.dictionaryConverter = function(converters) { + return (dictionary) => { + const type = webidl.util.Type(dictionary); + const dict = {}; + if (type === "Null" || type === "Undefined") { + return dict; + } else if (type !== "Object") { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` + }); + } + for (const options of converters) { + const { key, defaultValue, required, converter } = options; + if (required === true) { + if (!hasOwn3(dictionary, key)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `Missing required key "${key}".` + }); + } + } + let value = dictionary[key]; + const hasDefault = hasOwn3(options, "defaultValue"); + if (hasDefault && value !== null) { + value = value ?? defaultValue; + } + if (required || hasDefault || value !== void 0) { + value = converter(value); + if (options.allowedValues && !options.allowedValues.includes(value)) { + throw webidl.errors.exception({ + header: "Dictionary", + message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.` + }); + } + dict[key] = value; + } + } + return dict; + }; + }; + webidl.nullableConverter = function(converter) { + return (V) => { + if (V === null) { + return V; + } + return converter(V); + }; + }; + webidl.converters.DOMString = function(V, opts = {}) { + if (V === null && opts.legacyNullToEmptyString) { + return ""; + } + if (typeof V === "symbol") { + throw new TypeError("Could not convert argument of type symbol to string."); + } + return String(V); + }; + webidl.converters.ByteString = function(V) { + const x = webidl.converters.DOMString(V); + for (let index = 0; index < x.length; index++) { + if (x.charCodeAt(index) > 255) { + throw new TypeError( + `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.` + ); + } + } + return x; + }; + webidl.converters.USVString = toUSVString; + webidl.converters.boolean = function(V) { + const x = Boolean(V); + return x; + }; + webidl.converters.any = function(V) { + return V; + }; + webidl.converters["long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "signed"); + return x; + }; + webidl.converters["unsigned long long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 64, "unsigned"); + return x; + }; + webidl.converters["unsigned long"] = function(V) { + const x = webidl.util.ConvertToInt(V, 32, "unsigned"); + return x; + }; + webidl.converters["unsigned short"] = function(V, opts) { + const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts); + return x; + }; + webidl.converters.ArrayBuffer = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) { + throw webidl.errors.conversionFailed({ + prefix: `${V}`, + argument: `${V}`, + types: ["ArrayBuffer"] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.TypedArray = function(V, T, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) { + throw webidl.errors.conversionFailed({ + prefix: `${T.name}`, + argument: `${V}`, + types: [T.name] + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.DataView = function(V, opts = {}) { + if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) { + throw webidl.errors.exception({ + header: "DataView", + message: "Object is not a DataView." + }); + } + if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { + throw webidl.errors.exception({ + header: "ArrayBuffer", + message: "SharedArrayBuffer is not allowed." + }); + } + return V; + }; + webidl.converters.BufferSource = function(V, opts = {}) { + if (types.isAnyArrayBuffer(V)) { + return webidl.converters.ArrayBuffer(V, opts); + } + if (types.isTypedArray(V)) { + return webidl.converters.TypedArray(V, V.constructor); + } + if (types.isDataView(V)) { + return webidl.converters.DataView(V, opts); + } + throw new TypeError(`Could not convert ${V} to a BufferSource.`); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.ByteString + ); + webidl.converters["sequence>"] = webidl.sequenceConverter( + webidl.converters["sequence"] + ); + webidl.converters["record"] = webidl.recordConverter( + webidl.converters.ByteString, + webidl.converters.ByteString + ); + module2.exports = { + webidl + }; + } +}); + +// node_modules/undici/lib/fetch/dataURL.js +var require_dataURL = __commonJS({ + "node_modules/undici/lib/fetch/dataURL.js"(exports2, module2) { + var assert = require("assert"); + var { atob: atob2 } = require("buffer"); + var { isomorphicDecode } = require_util2(); + var encoder = new TextEncoder(); + var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/; + var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/; + var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/; + function dataURLProcessor(dataURL) { + assert(dataURL.protocol === "data:"); + let input = URLSerializer(dataURL, true); + input = input.slice(5); + const position = { position: 0 }; + let mimeType = collectASequenceOfCodePointsFast( + ",", + input, + position + ); + const mimeTypeLength = mimeType.length; + mimeType = removeASCIIWhitespace(mimeType, true, true); + if (position.position >= input.length) { + return "failure"; + } + position.position++; + const encodedBody = input.slice(mimeTypeLength + 1); + let body = stringPercentDecode(encodedBody); + if (/;(\u0020){0,}base64$/i.test(mimeType)) { + const stringBody = isomorphicDecode(body); + body = forgivingBase64(stringBody); + if (body === "failure") { + return "failure"; + } + mimeType = mimeType.slice(0, -6); + mimeType = mimeType.replace(/(\u0020)+$/, ""); + mimeType = mimeType.slice(0, -1); + } + if (mimeType.startsWith(";")) { + mimeType = "text/plain" + mimeType; + } + let mimeTypeRecord = parseMIMEType(mimeType); + if (mimeTypeRecord === "failure") { + mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII"); + } + return { mimeType: mimeTypeRecord, body }; + } + function URLSerializer(url, excludeFragment = false) { + if (!excludeFragment) { + return url.href; + } + const href = url.href; + const hashLength = url.hash.length; + return hashLength === 0 ? href : href.substring(0, href.length - hashLength); + } + function collectASequenceOfCodePoints(condition, input, position) { + let result = ""; + while (position.position < input.length && condition(input[position.position])) { + result += input[position.position]; + position.position++; + } + return result; + } + function collectASequenceOfCodePointsFast(char, input, position) { + const idx = input.indexOf(char, position.position); + const start = position.position; + if (idx === -1) { + position.position = input.length; + return input.slice(start); + } + position.position = idx; + return input.slice(start, position.position); + } + function stringPercentDecode(input) { + const bytes = encoder.encode(input); + return percentDecode(bytes); + } + function percentDecode(input) { + const output = []; + for (let i = 0; i < input.length; i++) { + const byte = input[i]; + if (byte !== 37) { + output.push(byte); + } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) { + output.push(37); + } else { + const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]); + const bytePoint = Number.parseInt(nextTwoBytes, 16); + output.push(bytePoint); + i += 2; + } + } + return Uint8Array.from(output); + } + function parseMIMEType(input) { + input = removeHTTPWhitespace(input, true, true); + const position = { position: 0 }; + const type = collectASequenceOfCodePointsFast( + "/", + input, + position + ); + if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) { + return "failure"; + } + if (position.position > input.length) { + return "failure"; + } + position.position++; + let subtype = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + subtype = removeHTTPWhitespace(subtype, false, true); + if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) { + return "failure"; + } + const typeLowercase = type.toLowerCase(); + const subtypeLowercase = subtype.toLowerCase(); + const mimeType = { + type: typeLowercase, + subtype: subtypeLowercase, + /** @type {Map} */ + parameters: /* @__PURE__ */ new Map(), + // https://mimesniff.spec.whatwg.org/#mime-type-essence + essence: `${typeLowercase}/${subtypeLowercase}` + }; + while (position.position < input.length) { + position.position++; + collectASequenceOfCodePoints( + // https://fetch.spec.whatwg.org/#http-whitespace + (char) => HTTP_WHITESPACE_REGEX.test(char), + input, + position + ); + let parameterName = collectASequenceOfCodePoints( + (char) => char !== ";" && char !== "=", + input, + position + ); + parameterName = parameterName.toLowerCase(); + if (position.position < input.length) { + if (input[position.position] === ";") { + continue; + } + position.position++; + } + if (position.position > input.length) { + break; + } + let parameterValue = null; + if (input[position.position] === '"') { + parameterValue = collectAnHTTPQuotedString(input, position, true); + collectASequenceOfCodePointsFast( + ";", + input, + position + ); + } else { + parameterValue = collectASequenceOfCodePointsFast( + ";", + input, + position + ); + parameterValue = removeHTTPWhitespace(parameterValue, false, true); + if (parameterValue.length === 0) { + continue; + } + } + if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) { + mimeType.parameters.set(parameterName, parameterValue); + } + } + return mimeType; + } + function forgivingBase64(data) { + data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, ""); + if (data.length % 4 === 0) { + data = data.replace(/=?=$/, ""); + } + if (data.length % 4 === 1) { + return "failure"; + } + if (/[^+/0-9A-Za-z]/.test(data)) { + return "failure"; + } + const binary = atob2(data); + const bytes = new Uint8Array(binary.length); + for (let byte = 0; byte < binary.length; byte++) { + bytes[byte] = binary.charCodeAt(byte); + } + return bytes; + } + function collectAnHTTPQuotedString(input, position, extractValue) { + const positionStart = position.position; + let value = ""; + assert(input[position.position] === '"'); + position.position++; + while (true) { + value += collectASequenceOfCodePoints( + (char) => char !== '"' && char !== "\\", + input, + position + ); + if (position.position >= input.length) { + break; + } + const quoteOrBackslash = input[position.position]; + position.position++; + if (quoteOrBackslash === "\\") { + if (position.position >= input.length) { + value += "\\"; + break; + } + value += input[position.position]; + position.position++; + } else { + assert(quoteOrBackslash === '"'); + break; + } + } + if (extractValue) { + return value; + } + return input.slice(positionStart, position.position); + } + function serializeAMimeType(mimeType) { + assert(mimeType !== "failure"); + const { parameters, essence } = mimeType; + let serialization = essence; + for (let [name, value] of parameters.entries()) { + serialization += ";"; + serialization += name; + serialization += "="; + if (!HTTP_TOKEN_CODEPOINTS.test(value)) { + value = value.replace(/(\\|")/g, "\\$1"); + value = '"' + value; + value += '"'; + } + serialization += value; + } + return serialization; + } + function isHTTPWhiteSpace(char) { + return char === "\r" || char === "\n" || char === " " || char === " "; + } + function removeHTTPWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + function isASCIIWhitespace(char) { + return char === "\r" || char === "\n" || char === " " || char === "\f" || char === " "; + } + function removeASCIIWhitespace(str, leading = true, trailing = true) { + let lead = 0; + let trail = str.length - 1; + if (leading) { + for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++) ; + } + if (trailing) { + for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--) ; + } + return str.slice(lead, trail + 1); + } + module2.exports = { + dataURLProcessor, + URLSerializer, + collectASequenceOfCodePoints, + collectASequenceOfCodePointsFast, + stringPercentDecode, + parseMIMEType, + collectAnHTTPQuotedString, + serializeAMimeType + }; + } +}); + +// node_modules/undici/lib/fetch/file.js +var require_file = __commonJS({ + "node_modules/undici/lib/fetch/file.js"(exports2, module2) { + "use strict"; + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { types } = require("util"); + var { kState } = require_symbols2(); + var { isBlobLike: isBlobLike2 } = require_util2(); + var { webidl } = require_webidl(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var { kEnumerableProperty } = require_util(); + var encoder = new TextEncoder(); + var File2 = class _File extends Blob2 { + constructor(fileBits, fileName, options = {}) { + webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" }); + fileBits = webidl.converters["sequence"](fileBits); + fileName = webidl.converters.USVString(fileName); + options = webidl.converters.FilePropertyBag(options); + const n = fileName; + let t = options.type; + let d; + substep: { + if (t) { + t = parseMIMEType(t); + if (t === "failure") { + t = ""; + break substep; + } + t = serializeAMimeType(t).toLowerCase(); + } + d = options.lastModified; + } + super(processBlobParts(fileBits, options), { type: t }); + this[kState] = { + name: n, + lastModified: d, + type: t + }; + } + get name() { + webidl.brandCheck(this, _File); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _File); + return this[kState].lastModified; + } + get type() { + webidl.brandCheck(this, _File); + return this[kState].type; + } + }; + var FileLike = class _FileLike { + constructor(blobLike, fileName, options = {}) { + const n = fileName; + const t = options.type; + const d = options.lastModified ?? Date.now(); + this[kState] = { + blobLike, + name: n, + type: t, + lastModified: d + }; + } + stream(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.stream(...args); + } + arrayBuffer(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.arrayBuffer(...args); + } + slice(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.slice(...args); + } + text(...args) { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.text(...args); + } + get size() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.size; + } + get type() { + webidl.brandCheck(this, _FileLike); + return this[kState].blobLike.type; + } + get name() { + webidl.brandCheck(this, _FileLike); + return this[kState].name; + } + get lastModified() { + webidl.brandCheck(this, _FileLike); + return this[kState].lastModified; + } + get [Symbol.toStringTag]() { + return "File"; + } + }; + Object.defineProperties(File2.prototype, { + [Symbol.toStringTag]: { + value: "File", + configurable: true + }, + name: kEnumerableProperty, + lastModified: kEnumerableProperty + }); + webidl.converters.Blob = webidl.interfaceConverter(Blob2); + webidl.converters.BlobPart = function(V, opts) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V, opts); + } + } + return webidl.converters.USVString(V, opts); + }; + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.BlobPart + ); + webidl.converters.FilePropertyBag = webidl.dictionaryConverter([ + { + key: "lastModified", + converter: webidl.converters["long long"], + get defaultValue() { + return Date.now(); + } + }, + { + key: "type", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "endings", + converter: (value) => { + value = webidl.converters.DOMString(value); + value = value.toLowerCase(); + if (value !== "native") { + value = "transparent"; + } + return value; + }, + defaultValue: "transparent" + } + ]); + function processBlobParts(parts, options) { + const bytes = []; + for (const element of parts) { + if (typeof element === "string") { + let s = element; + if (options.endings === "native") { + s = convertLineEndingsNative(s); + } + bytes.push(encoder.encode(s)); + } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) { + if (!element.buffer) { + bytes.push(new Uint8Array(element)); + } else { + bytes.push( + new Uint8Array(element.buffer, element.byteOffset, element.byteLength) + ); + } + } else if (isBlobLike2(element)) { + bytes.push(element); + } + } + return bytes; + } + function convertLineEndingsNative(s) { + let nativeLineEnding = "\n"; + if (process.platform === "win32") { + nativeLineEnding = "\r\n"; + } + return s.replace(/\r?\n/g, nativeLineEnding); + } + function isFileLike2(object) { + return NativeFile && object instanceof NativeFile || object instanceof File2 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File"; + } + module2.exports = { File: File2, FileLike, isFileLike: isFileLike2 }; + } +}); + +// node_modules/undici/lib/fetch/formdata.js +var require_formdata = __commonJS({ + "node_modules/undici/lib/fetch/formdata.js"(exports2, module2) { + "use strict"; + var { isBlobLike: isBlobLike2, toUSVString, makeIterator } = require_util2(); + var { kState } = require_symbols2(); + var { File: UndiciFile, FileLike, isFileLike: isFileLike2 } = require_file(); + var { webidl } = require_webidl(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var File2 = NativeFile ?? UndiciFile; + var FormData2 = class _FormData { + constructor(form) { + if (form !== void 0) { + throw webidl.errors.conversionFailed({ + prefix: "FormData constructor", + argument: "Argument 1", + types: ["undefined"] + }); + } + this[kState] = []; + } + append(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + this[kState].push(entry); + } + delete(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" }); + name = webidl.converters.USVString(name); + this[kState] = this[kState].filter((entry) => entry.name !== name); + } + get(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" }); + name = webidl.converters.USVString(name); + const idx = this[kState].findIndex((entry) => entry.name === name); + if (idx === -1) { + return null; + } + return this[kState][idx].value; + } + getAll(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" }); + name = webidl.converters.USVString(name); + return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); + } + has(name) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" }); + name = webidl.converters.USVString(name); + return this[kState].findIndex((entry) => entry.name === name) !== -1; + } + set(name, value, filename = void 0) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" }); + if (arguments.length === 3 && !isBlobLike2(value)) { + throw new TypeError( + "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" + ); + } + name = webidl.converters.USVString(name); + value = isBlobLike2(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); + filename = arguments.length === 3 ? toUSVString(filename) : void 0; + const entry = makeEntry(name, value, filename); + const idx = this[kState].findIndex((entry2) => entry2.name === name); + if (idx !== -1) { + this[kState] = [ + ...this[kState].slice(0, idx), + entry, + ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name) + ]; + } else { + this[kState].push(entry); + } + } + entries() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key+value" + ); + } + keys() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "key" + ); + } + values() { + webidl.brandCheck(this, _FormData); + return makeIterator( + () => this[kState].map((pair) => [pair.name, pair.value]), + "FormData", + "value" + ); + } + /** + * @param {(value: string, key: string, self: FormData) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _FormData); + webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'." + ); + } + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); + } + } + }; + FormData2.prototype[Symbol.iterator] = FormData2.prototype.entries; + Object.defineProperties(FormData2.prototype, { + [Symbol.toStringTag]: { + value: "FormData", + configurable: true + } + }); + function makeEntry(name, value, filename) { + name = Buffer.from(name).toString("utf8"); + if (typeof value === "string") { + value = Buffer.from(value).toString("utf8"); + } else { + if (!isFileLike2(value)) { + value = value instanceof Blob2 ? new File2([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type }); + } + if (filename !== void 0) { + const options = { + type: value.type, + lastModified: value.lastModified + }; + value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File2([value], filename, options) : new FileLike(value, filename, options); + } + } + return { name, value }; + } + module2.exports = { FormData: FormData2 }; + } +}); + +// node_modules/undici/lib/fetch/body.js +var require_body = __commonJS({ + "node_modules/undici/lib/fetch/body.js"(exports2, module2) { + "use strict"; + var Busboy = require_main(); + var util = require_util(); + var { + ReadableStreamFrom: ReadableStreamFrom3, + isBlobLike: isBlobLike2, + isReadableStreamLike, + readableStreamClose, + createDeferredPromise, + fullyReadBody + } = require_util2(); + var { FormData: FormData2 } = require_formdata(); + var { kState } = require_symbols2(); + var { webidl } = require_webidl(); + var { DOMException: DOMException2, structuredClone } = require_constants2(); + var { Blob: Blob2, File: NativeFile } = require("buffer"); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { isErrored } = require_util(); + var { isUint8Array, isArrayBuffer } = require("util/types"); + var { File: UndiciFile } = require_file(); + var { parseMIMEType, serializeAMimeType } = require_dataURL(); + var random; + try { + const crypto = require("node:crypto"); + random = (max) => crypto.randomInt(0, max); + } catch { + random = (max) => Math.floor(Math.random(max)); + } + var ReadableStream = globalThis.ReadableStream; + var File2 = NativeFile ?? UndiciFile; + var textEncoder = new TextEncoder(); + var textDecoder = new TextDecoder(); + function extractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + let stream = null; + if (object instanceof ReadableStream) { + stream = object; + } else if (isBlobLike2(object)) { + stream = object.stream(); + } else { + stream = new ReadableStream({ + async pull(controller) { + controller.enqueue( + typeof source === "string" ? textEncoder.encode(source) : source + ); + queueMicrotask(() => readableStreamClose(controller)); + }, + start() { + }, + type: void 0 + }); + } + assert(isReadableStreamLike(stream)); + let action = null; + let source = null; + let length = null; + let type = null; + if (typeof object === "string") { + source = object; + type = "text/plain;charset=UTF-8"; + } else if (object instanceof URLSearchParams) { + source = object.toString(); + type = "application/x-www-form-urlencoded;charset=UTF-8"; + } else if (isArrayBuffer(object)) { + source = new Uint8Array(object.slice()); + } else if (ArrayBuffer.isView(object)) { + source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)); + } else if (util.isFormDataLike(object)) { + const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`; + const prefix = `--${boundary}\r +Content-Disposition: form-data`; + const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); + const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n"); + const blobParts = []; + const rn = new Uint8Array([13, 10]); + length = 0; + let hasUnknownSizeValue = false; + for (const [name, value] of object) { + if (typeof value === "string") { + const chunk2 = textEncoder.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r +\r +${normalizeLinefeeds(value)}\r +`); + blobParts.push(chunk2); + length += chunk2.byteLength; + } else { + const chunk2 = textEncoder.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r +Content-Type: ${value.type || "application/octet-stream"}\r +\r +`); + blobParts.push(chunk2, value, rn); + if (typeof value.size === "number") { + length += chunk2.byteLength + value.size + rn.byteLength; + } else { + hasUnknownSizeValue = true; + } + } + } + const chunk = textEncoder.encode(`--${boundary}--`); + blobParts.push(chunk); + length += chunk.byteLength; + if (hasUnknownSizeValue) { + length = null; + } + source = object; + action = async function* () { + for (const part of blobParts) { + if (part.stream) { + yield* part.stream(); + } else { + yield part; + } + } + }; + type = "multipart/form-data; boundary=" + boundary; + } else if (isBlobLike2(object)) { + source = object; + length = object.size; + if (object.type) { + type = object.type; + } + } else if (typeof object[Symbol.asyncIterator] === "function") { + if (keepalive) { + throw new TypeError("keepalive"); + } + if (util.isDisturbed(object) || object.locked) { + throw new TypeError( + "Response body object should not be disturbed or locked" + ); + } + stream = object instanceof ReadableStream ? object : ReadableStreamFrom3(object); + } + if (typeof source === "string" || util.isBuffer(source)) { + length = Buffer.byteLength(source); + } + if (action != null) { + let iterator; + stream = new ReadableStream({ + async start() { + iterator = action(object)[Symbol.asyncIterator](); + }, + async pull(controller) { + const { value, done } = await iterator.next(); + if (done) { + queueMicrotask(() => { + controller.close(); + }); + } else { + if (!isErrored(stream)) { + controller.enqueue(new Uint8Array(value)); + } + } + return controller.desiredSize > 0; + }, + async cancel(reason) { + await iterator.return(); + }, + type: void 0 + }); + } + const body = { stream, source, length }; + return [body, type]; + } + function safelyExtractBody(object, keepalive = false) { + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + if (object instanceof ReadableStream) { + assert(!util.isDisturbed(object), "The body has already been consumed."); + assert(!object.locked, "The stream is locked."); + } + return extractBody(object, keepalive); + } + function cloneBody(body) { + const [out1, out2] = body.stream.tee(); + const out2Clone = structuredClone(out2, { transfer: [out2] }); + const [, finalClone] = out2Clone.tee(); + body.stream = out1; + return { + stream: finalClone, + length: body.length, + source: body.source + }; + } + async function* consumeBody(body) { + if (body) { + if (isUint8Array(body)) { + yield body; + } else { + const stream = body.stream; + if (util.isDisturbed(stream)) { + throw new TypeError("The body has already been consumed."); + } + if (stream.locked) { + throw new TypeError("The stream is locked."); + } + stream[kBodyUsed] = true; + yield* stream; + } + } + } + function throwIfAborted(state) { + if (state.aborted) { + throw new DOMException2("The operation was aborted.", "AbortError"); + } + } + function bodyMixinMethods(instance) { + const methods = { + blob() { + return specConsumeBody(this, (bytes) => { + let mimeType = bodyMimeType(this); + if (mimeType === "failure") { + mimeType = ""; + } else if (mimeType) { + mimeType = serializeAMimeType(mimeType); + } + return new Blob2([bytes], { type: mimeType }); + }, instance); + }, + arrayBuffer() { + return specConsumeBody(this, (bytes) => { + return new Uint8Array(bytes).buffer; + }, instance); + }, + text() { + return specConsumeBody(this, utf8DecodeBytes, instance); + }, + json() { + return specConsumeBody(this, parseJSONFromBytes, instance); + }, + async formData() { + webidl.brandCheck(this, instance); + throwIfAborted(this[kState]); + const contentType = this.headers.get("Content-Type"); + if (/multipart\/form-data/.test(contentType)) { + const headers = {}; + for (const [key, value] of this.headers) headers[key.toLowerCase()] = value; + const responseFormData = new FormData2(); + let busboy; + try { + busboy = new Busboy({ + headers, + preservePath: true + }); + } catch (err) { + throw new DOMException2(`${err}`, "AbortError"); + } + busboy.on("field", (name, value) => { + responseFormData.append(name, value); + }); + busboy.on("file", (name, value, filename, encoding, mimeType) => { + const chunks = []; + if (encoding === "base64" || encoding.toLowerCase() === "base64") { + let base64chunk = ""; + value.on("data", (chunk) => { + base64chunk += chunk.toString().replace(/[\r\n]/gm, ""); + const end = base64chunk.length - base64chunk.length % 4; + chunks.push(Buffer.from(base64chunk.slice(0, end), "base64")); + base64chunk = base64chunk.slice(end); + }); + value.on("end", () => { + chunks.push(Buffer.from(base64chunk, "base64")); + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } else { + value.on("data", (chunk) => { + chunks.push(chunk); + }); + value.on("end", () => { + responseFormData.append(name, new File2(chunks, filename, { type: mimeType })); + }); + } + }); + const busboyResolve = new Promise((resolve, reject) => { + busboy.on("finish", resolve); + busboy.on("error", (err) => reject(new TypeError(err))); + }); + if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk); + busboy.end(); + await busboyResolve; + return responseFormData; + } else if (/application\/x-www-form-urlencoded/.test(contentType)) { + let entries; + try { + let text = ""; + const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true }); + for await (const chunk of consumeBody(this[kState].body)) { + if (!isUint8Array(chunk)) { + throw new TypeError("Expected Uint8Array chunk"); + } + text += streamingDecoder.decode(chunk, { stream: true }); + } + text += streamingDecoder.decode(); + entries = new URLSearchParams(text); + } catch (err) { + throw Object.assign(new TypeError(), { cause: err }); + } + const formData = new FormData2(); + for (const [name, value] of entries) { + formData.append(name, value); + } + return formData; + } else { + await Promise.resolve(); + throwIfAborted(this[kState]); + throw webidl.errors.exception({ + header: `${instance.name}.formData`, + message: "Could not parse content as FormData." + }); + } + } + }; + return methods; + } + function mixinBody(prototype) { + Object.assign(prototype.prototype, bodyMixinMethods(prototype)); + } + async function specConsumeBody(object, convertBytesToJSValue, instance) { + webidl.brandCheck(object, instance); + throwIfAborted(object[kState]); + if (bodyUnusable(object[kState].body)) { + throw new TypeError("Body is unusable"); + } + const promise = createDeferredPromise(); + const errorSteps = (error) => promise.reject(error); + const successSteps = (data) => { + try { + promise.resolve(convertBytesToJSValue(data)); + } catch (e) { + errorSteps(e); + } + }; + if (object[kState].body == null) { + successSteps(new Uint8Array()); + return promise.promise; + } + await fullyReadBody(object[kState].body, successSteps, errorSteps); + return promise.promise; + } + function bodyUnusable(body) { + return body != null && (body.stream.locked || util.isDisturbed(body.stream)); + } + function utf8DecodeBytes(buffer) { + if (buffer.length === 0) { + return ""; + } + if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) { + buffer = buffer.subarray(3); + } + const output = textDecoder.decode(buffer); + return output; + } + function parseJSONFromBytes(bytes) { + return JSON.parse(utf8DecodeBytes(bytes)); + } + function bodyMimeType(object) { + const { headersList } = object[kState]; + const contentType = headersList.get("content-type"); + if (contentType === null) { + return "failure"; + } + return parseMIMEType(contentType); + } + module2.exports = { + extractBody, + safelyExtractBody, + cloneBody, + mixinBody + }; + } +}); + +// node_modules/undici/lib/core/request.js +var require_request = __commonJS({ + "node_modules/undici/lib/core/request.js"(exports2, module2) { + "use strict"; + var { + InvalidArgumentError, + NotSupportedError + } = require_errors(); + var assert = require("assert"); + var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols(); + var util = require_util(); + var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/; + var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; + var invalidPathRegex = /[^\u0021-\u00ff]/; + var kHandler = Symbol("handler"); + var channels = {}; + var extractBody; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.create = diagnosticsChannel.channel("undici:request:create"); + channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent"); + channels.headers = diagnosticsChannel.channel("undici:request:headers"); + channels.trailers = diagnosticsChannel.channel("undici:request:trailers"); + channels.error = diagnosticsChannel.channel("undici:request:error"); + } catch { + channels.create = { hasSubscribers: false }; + channels.bodySent = { hasSubscribers: false }; + channels.headers = { hasSubscribers: false }; + channels.trailers = { hasSubscribers: false }; + channels.error = { hasSubscribers: false }; + } + var Request = class _Request { + constructor(origin, { + path: path3, + method, + body, + headers, + query, + idempotent, + blocking, + upgrade, + headersTimeout, + bodyTimeout, + reset, + throwOnError, + expectContinue + }, handler) { + if (typeof path3 !== "string") { + throw new InvalidArgumentError("path must be a string"); + } else if (path3[0] !== "/" && !(path3.startsWith("http://") || path3.startsWith("https://")) && method !== "CONNECT") { + throw new InvalidArgumentError("path must be an absolute URL or start with a slash"); + } else if (invalidPathRegex.exec(path3) !== null) { + throw new InvalidArgumentError("invalid request path"); + } + if (typeof method !== "string") { + throw new InvalidArgumentError("method must be a string"); + } else if (tokenRegExp.exec(method) === null) { + throw new InvalidArgumentError("invalid request method"); + } + if (upgrade && typeof upgrade !== "string") { + throw new InvalidArgumentError("upgrade must be a string"); + } + if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("invalid headersTimeout"); + } + if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("invalid bodyTimeout"); + } + if (reset != null && typeof reset !== "boolean") { + throw new InvalidArgumentError("invalid reset"); + } + if (expectContinue != null && typeof expectContinue !== "boolean") { + throw new InvalidArgumentError("invalid expectContinue"); + } + this.headersTimeout = headersTimeout; + this.bodyTimeout = bodyTimeout; + this.throwOnError = throwOnError === true; + this.method = method; + this.abort = null; + if (body == null) { + this.body = null; + } else if (util.isStream(body)) { + this.body = body; + const rState = this.body._readableState; + if (!rState || !rState.autoDestroy) { + this.endHandler = function autoDestroy() { + util.destroy(this); + }; + this.body.on("end", this.endHandler); + } + this.errorHandler = (err) => { + if (this.abort) { + this.abort(err); + } else { + this.error = err; + } + }; + this.body.on("error", this.errorHandler); + } else if (util.isBuffer(body)) { + this.body = body.byteLength ? body : null; + } else if (ArrayBuffer.isView(body)) { + this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null; + } else if (body instanceof ArrayBuffer) { + this.body = body.byteLength ? Buffer.from(body) : null; + } else if (typeof body === "string") { + this.body = body.length ? Buffer.from(body) : null; + } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) { + this.body = body; + } else { + throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable"); + } + this.completed = false; + this.aborted = false; + this.upgrade = upgrade || null; + this.path = query ? util.buildURL(path3, query) : path3; + this.origin = origin; + this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; + this.blocking = blocking == null ? false : blocking; + this.reset = reset == null ? null : reset; + this.host = null; + this.contentLength = null; + this.contentType = null; + this.headers = ""; + this.expectContinue = expectContinue != null ? expectContinue : false; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(this, headers[i], headers[i + 1]); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(this, key, headers[key]); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + if (util.isFormDataLike(this.body)) { + if (util.nodeMajor < 16 || util.nodeMajor === 16 && util.nodeMinor < 8) { + throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer."); + } + if (!extractBody) { + extractBody = require_body().extractBody; + } + const [bodyStream, contentType] = extractBody(body); + if (this.contentType == null) { + this.contentType = contentType; + this.headers += `content-type: ${contentType}\r +`; + } + this.body = bodyStream.stream; + this.contentLength = bodyStream.length; + } else if (util.isBlobLike(body) && this.contentType == null && body.type) { + this.contentType = body.type; + this.headers += `content-type: ${body.type}\r +`; + } + util.validateHandler(handler, method, upgrade); + this.servername = util.getServerName(this.host); + this[kHandler] = handler; + if (channels.create.hasSubscribers) { + channels.create.publish({ request: this }); + } + } + onBodySent(chunk) { + if (this[kHandler].onBodySent) { + try { + return this[kHandler].onBodySent(chunk); + } catch (err) { + this.abort(err); + } + } + } + onRequestSent() { + if (channels.bodySent.hasSubscribers) { + channels.bodySent.publish({ request: this }); + } + if (this[kHandler].onRequestSent) { + try { + return this[kHandler].onRequestSent(); + } catch (err) { + this.abort(err); + } + } + } + onConnect(abort) { + assert(!this.aborted); + assert(!this.completed); + if (this.error) { + abort(this.error); + } else { + this.abort = abort; + return this[kHandler].onConnect(abort); + } + } + onHeaders(statusCode, headers, resume, statusText) { + assert(!this.aborted); + assert(!this.completed); + if (channels.headers.hasSubscribers) { + channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }); + } + try { + return this[kHandler].onHeaders(statusCode, headers, resume, statusText); + } catch (err) { + this.abort(err); + } + } + onData(chunk) { + assert(!this.aborted); + assert(!this.completed); + try { + return this[kHandler].onData(chunk); + } catch (err) { + this.abort(err); + return false; + } + } + onUpgrade(statusCode, headers, socket) { + assert(!this.aborted); + assert(!this.completed); + return this[kHandler].onUpgrade(statusCode, headers, socket); + } + onComplete(trailers) { + this.onFinally(); + assert(!this.aborted); + this.completed = true; + if (channels.trailers.hasSubscribers) { + channels.trailers.publish({ request: this, trailers }); + } + try { + return this[kHandler].onComplete(trailers); + } catch (err) { + this.onError(err); + } + } + onError(error) { + this.onFinally(); + if (channels.error.hasSubscribers) { + channels.error.publish({ request: this, error }); + } + if (this.aborted) { + return; + } + this.aborted = true; + return this[kHandler].onError(error); + } + onFinally() { + if (this.errorHandler) { + this.body.off("error", this.errorHandler); + this.errorHandler = null; + } + if (this.endHandler) { + this.body.off("end", this.endHandler); + this.endHandler = null; + } + } + // TODO: adjust to support H2 + addHeader(key, value) { + processHeader(this, key, value); + return this; + } + static [kHTTP1BuildRequest](origin, opts, handler) { + return new _Request(origin, opts, handler); + } + static [kHTTP2BuildRequest](origin, opts, handler) { + const headers = opts.headers; + opts = { ...opts, headers: null }; + const request = new _Request(origin, opts, handler); + request.headers = {}; + if (Array.isArray(headers)) { + if (headers.length % 2 !== 0) { + throw new InvalidArgumentError("headers array must be even"); + } + for (let i = 0; i < headers.length; i += 2) { + processHeader(request, headers[i], headers[i + 1], true); + } + } else if (headers && typeof headers === "object") { + const keys = Object.keys(headers); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + processHeader(request, key, headers[key], true); + } + } else if (headers != null) { + throw new InvalidArgumentError("headers must be an object or an array"); + } + return request; + } + static [kHTTP2CopyHeaders](raw) { + const rawHeaders = raw.split("\r\n"); + const headers = {}; + for (const header of rawHeaders) { + const [key, value] = header.split(": "); + if (value == null || value.length === 0) continue; + if (headers[key]) headers[key] += `,${value}`; + else headers[key] = value; + } + return headers; + } + }; + function processHeaderValue(key, val, skipAppend) { + if (val && typeof val === "object") { + throw new InvalidArgumentError(`invalid ${key} header`); + } + val = val != null ? `${val}` : ""; + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + return skipAppend ? val : `${key}: ${val}\r +`; + } + function processHeader(request, key, val, skipAppend = false) { + if (val && (typeof val === "object" && !Array.isArray(val))) { + throw new InvalidArgumentError(`invalid ${key} header`); + } else if (val === void 0) { + return; + } + if (request.host === null && key.length === 4 && key.toLowerCase() === "host") { + if (headerCharRegex.exec(val) !== null) { + throw new InvalidArgumentError(`invalid ${key} header`); + } + request.host = val; + } else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") { + request.contentLength = parseInt(val, 10); + if (!Number.isFinite(request.contentLength)) { + throw new InvalidArgumentError("invalid content-length header"); + } + } else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") { + request.contentType = val; + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); + } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") { + throw new InvalidArgumentError("invalid transfer-encoding header"); + } else if (key.length === 10 && key.toLowerCase() === "connection") { + const value = typeof val === "string" ? val.toLowerCase() : null; + if (value !== "close" && value !== "keep-alive") { + throw new InvalidArgumentError("invalid connection header"); + } else if (value === "close") { + request.reset = true; + } + } else if (key.length === 10 && key.toLowerCase() === "keep-alive") { + throw new InvalidArgumentError("invalid keep-alive header"); + } else if (key.length === 7 && key.toLowerCase() === "upgrade") { + throw new InvalidArgumentError("invalid upgrade header"); + } else if (key.length === 6 && key.toLowerCase() === "expect") { + throw new NotSupportedError("expect header not supported"); + } else if (tokenRegExp.exec(key) === null) { + throw new InvalidArgumentError("invalid header key"); + } else { + if (Array.isArray(val)) { + for (let i = 0; i < val.length; i++) { + if (skipAppend) { + if (request.headers[key]) request.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`; + else request.headers[key] = processHeaderValue(key, val[i], skipAppend); + } else { + request.headers += processHeaderValue(key, val[i]); + } + } + } else { + if (skipAppend) request.headers[key] = processHeaderValue(key, val, skipAppend); + else request.headers += processHeaderValue(key, val); + } + } + } + module2.exports = Request; + } +}); + +// node_modules/undici/lib/dispatcher.js +var require_dispatcher = __commonJS({ + "node_modules/undici/lib/dispatcher.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events"); + var Dispatcher = class extends EventEmitter { + dispatch() { + throw new Error("not implemented"); + } + close() { + throw new Error("not implemented"); + } + destroy() { + throw new Error("not implemented"); + } + }; + module2.exports = Dispatcher; + } +}); + +// node_modules/undici/lib/dispatcher-base.js +var require_dispatcher_base = __commonJS({ + "node_modules/undici/lib/dispatcher-base.js"(exports2, module2) { + "use strict"; + var Dispatcher = require_dispatcher(); + var { + ClientDestroyedError, + ClientClosedError, + InvalidArgumentError + } = require_errors(); + var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols(); + var kDestroyed = Symbol("destroyed"); + var kClosed = Symbol("closed"); + var kOnDestroyed = Symbol("onDestroyed"); + var kOnClosed = Symbol("onClosed"); + var kInterceptedDispatch = Symbol("Intercepted Dispatch"); + var DispatcherBase = class extends Dispatcher { + constructor() { + super(); + this[kDestroyed] = false; + this[kOnDestroyed] = null; + this[kClosed] = false; + this[kOnClosed] = []; + } + get destroyed() { + return this[kDestroyed]; + } + get closed() { + return this[kClosed]; + } + get interceptors() { + return this[kInterceptors]; + } + set interceptors(newInterceptors) { + if (newInterceptors) { + for (let i = newInterceptors.length - 1; i >= 0; i--) { + const interceptor = this[kInterceptors][i]; + if (typeof interceptor !== "function") { + throw new InvalidArgumentError("interceptor must be an function"); + } + } + } + this[kInterceptors] = newInterceptors; + } + close(callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.close((err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + queueMicrotask(() => callback(new ClientDestroyedError(), null)); + return; + } + if (this[kClosed]) { + if (this[kOnClosed]) { + this[kOnClosed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + this[kClosed] = true; + this[kOnClosed].push(callback); + const onClosed = () => { + const callbacks = this[kOnClosed]; + this[kOnClosed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kClose]().then(() => this.destroy()).then(() => { + queueMicrotask(onClosed); + }); + } + destroy(err, callback) { + if (typeof err === "function") { + callback = err; + err = null; + } + if (callback === void 0) { + return new Promise((resolve, reject) => { + this.destroy(err, (err2, data) => { + return err2 ? ( + /* istanbul ignore next: should never error */ + reject(err2) + ) : resolve(data); + }); + }); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (this[kDestroyed]) { + if (this[kOnDestroyed]) { + this[kOnDestroyed].push(callback); + } else { + queueMicrotask(() => callback(null, null)); + } + return; + } + if (!err) { + err = new ClientDestroyedError(); + } + this[kDestroyed] = true; + this[kOnDestroyed] = this[kOnDestroyed] || []; + this[kOnDestroyed].push(callback); + const onDestroyed = () => { + const callbacks = this[kOnDestroyed]; + this[kOnDestroyed] = null; + for (let i = 0; i < callbacks.length; i++) { + callbacks[i](null, null); + } + }; + this[kDestroy](err).then(() => { + queueMicrotask(onDestroyed); + }); + } + [kInterceptedDispatch](opts, handler) { + if (!this[kInterceptors] || this[kInterceptors].length === 0) { + this[kInterceptedDispatch] = this[kDispatch]; + return this[kDispatch](opts, handler); + } + let dispatch = this[kDispatch].bind(this); + for (let i = this[kInterceptors].length - 1; i >= 0; i--) { + dispatch = this[kInterceptors][i](dispatch); + } + this[kInterceptedDispatch] = dispatch; + return dispatch(opts, handler); + } + dispatch(opts, handler) { + if (!handler || typeof handler !== "object") { + throw new InvalidArgumentError("handler must be an object"); + } + try { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object."); + } + if (this[kDestroyed] || this[kOnDestroyed]) { + throw new ClientDestroyedError(); + } + if (this[kClosed]) { + throw new ClientClosedError(); + } + return this[kInterceptedDispatch](opts, handler); + } catch (err) { + if (typeof handler.onError !== "function") { + throw new InvalidArgumentError("invalid onError method"); + } + handler.onError(err); + return false; + } + } + }; + module2.exports = DispatcherBase; + } +}); + +// node_modules/undici/lib/core/connect.js +var require_connect = __commonJS({ + "node_modules/undici/lib/core/connect.js"(exports2, module2) { + "use strict"; + var net = require("net"); + var assert = require("assert"); + var util = require_util(); + var { InvalidArgumentError, ConnectTimeoutError } = require_errors(); + var tls; + var SessionCache; + if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) { + SessionCache = class WeakSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + this._sessionRegistry = new global.FinalizationRegistry((key) => { + if (this._sessionCache.size < this._maxCachedSessions) { + return; + } + const ref = this._sessionCache.get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this._sessionCache.delete(key); + } + }); + } + get(sessionKey) { + const ref = this._sessionCache.get(sessionKey); + return ref ? ref.deref() : null; + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + this._sessionCache.set(sessionKey, new WeakRef(session)); + this._sessionRegistry.register(session, sessionKey); + } + }; + } else { + SessionCache = class SimpleSessionCache { + constructor(maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions; + this._sessionCache = /* @__PURE__ */ new Map(); + } + get(sessionKey) { + return this._sessionCache.get(sessionKey); + } + set(sessionKey, session) { + if (this._maxCachedSessions === 0) { + return; + } + if (this._sessionCache.size >= this._maxCachedSessions) { + const { value: oldestKey } = this._sessionCache.keys().next(); + this._sessionCache.delete(oldestKey); + } + this._sessionCache.set(sessionKey, session); + } + }; + } + function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) { + if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { + throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero"); + } + const options = { path: socketPath, ...opts }; + const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions); + timeout = timeout == null ? 1e4 : timeout; + allowH2 = allowH2 != null ? allowH2 : false; + return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { + let socket; + if (protocol === "https:") { + if (!tls) { + tls = require("tls"); + } + servername = servername || options.servername || util.getServerName(host) || null; + const sessionKey = servername || hostname; + const session = sessionCache.get(sessionKey) || null; + assert(sessionKey); + socket = tls.connect({ + highWaterMark: 16384, + // TLS in node can't have bigger HWM anyway... + ...options, + servername, + session, + localAddress, + // TODO(HTTP/2): Add support for h2c + ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"], + socket: httpSocket, + // upgrade socket connection + port: port || 443, + host: hostname + }); + socket.on("session", function(session2) { + sessionCache.set(sessionKey, session2); + }); + } else { + assert(!httpSocket, "httpSocket can only be sent on TLS update"); + socket = net.connect({ + highWaterMark: 64 * 1024, + // Same as nodejs fs streams. + ...options, + localAddress, + port: port || 80, + host: hostname + }); + } + if (options.keepAlive == null || options.keepAlive) { + const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay; + socket.setKeepAlive(true, keepAliveInitialDelay); + } + const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout); + socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(null, this); + } + }).on("error", function(err) { + cancelTimeout(); + if (callback) { + const cb = callback; + callback = null; + cb(err); + } + }); + return socket; + }; + } + function setupTimeout(onConnectTimeout2, timeout) { + if (!timeout) { + return () => { + }; + } + let s1 = null; + let s2 = null; + const timeoutId = setTimeout(() => { + s1 = setImmediate(() => { + if (process.platform === "win32") { + s2 = setImmediate(() => onConnectTimeout2()); + } else { + onConnectTimeout2(); + } + }); + }, timeout); + return () => { + clearTimeout(timeoutId); + clearImmediate(s1); + clearImmediate(s2); + }; + } + function onConnectTimeout(socket) { + util.destroy(socket, new ConnectTimeoutError()); + } + module2.exports = buildConnector; + } +}); + +// node_modules/undici/lib/llhttp/utils.js +var require_utils2 = __commonJS({ + "node_modules/undici/lib/llhttp/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.enumToMap = void 0; + function enumToMap(obj) { + const res = {}; + Object.keys(obj).forEach((key) => { + const value = obj[key]; + if (typeof value === "number") { + res[key] = value; + } + }); + return res; + } + exports2.enumToMap = enumToMap; + } +}); + +// node_modules/undici/lib/llhttp/constants.js +var require_constants3 = __commonJS({ + "node_modules/undici/lib/llhttp/constants.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0; + var utils_1 = require_utils2(); + var ERROR; + (function(ERROR2) { + ERROR2[ERROR2["OK"] = 0] = "OK"; + ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL"; + ERROR2[ERROR2["STRICT"] = 2] = "STRICT"; + ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED"; + ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; + ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; + ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD"; + ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL"; + ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; + ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION"; + ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; + ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; + ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; + ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS"; + ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; + ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; + ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; + ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; + ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; + ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; + ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; + ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED"; + ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; + ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; + ERROR2[ERROR2["USER"] = 24] = "USER"; + })(ERROR = exports2.ERROR || (exports2.ERROR = {})); + var TYPE; + (function(TYPE2) { + TYPE2[TYPE2["BOTH"] = 0] = "BOTH"; + TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST"; + TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE"; + })(TYPE = exports2.TYPE || (exports2.TYPE = {})); + var FLAGS; + (function(FLAGS2) { + FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; + FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; + FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; + FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED"; + FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE"; + FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; + FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY"; + FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING"; + FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; + })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {})); + var LENIENT_FLAGS; + (function(LENIENT_FLAGS2) { + LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS"; + LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; + LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; + })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {})); + var METHODS; + (function(METHODS2) { + METHODS2[METHODS2["DELETE"] = 0] = "DELETE"; + METHODS2[METHODS2["GET"] = 1] = "GET"; + METHODS2[METHODS2["HEAD"] = 2] = "HEAD"; + METHODS2[METHODS2["POST"] = 3] = "POST"; + METHODS2[METHODS2["PUT"] = 4] = "PUT"; + METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT"; + METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS"; + METHODS2[METHODS2["TRACE"] = 7] = "TRACE"; + METHODS2[METHODS2["COPY"] = 8] = "COPY"; + METHODS2[METHODS2["LOCK"] = 9] = "LOCK"; + METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL"; + METHODS2[METHODS2["MOVE"] = 11] = "MOVE"; + METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND"; + METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH"; + METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH"; + METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK"; + METHODS2[METHODS2["BIND"] = 16] = "BIND"; + METHODS2[METHODS2["REBIND"] = 17] = "REBIND"; + METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND"; + METHODS2[METHODS2["ACL"] = 19] = "ACL"; + METHODS2[METHODS2["REPORT"] = 20] = "REPORT"; + METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY"; + METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT"; + METHODS2[METHODS2["MERGE"] = 23] = "MERGE"; + METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH"; + METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY"; + METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE"; + METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; + METHODS2[METHODS2["PATCH"] = 28] = "PATCH"; + METHODS2[METHODS2["PURGE"] = 29] = "PURGE"; + METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR"; + METHODS2[METHODS2["LINK"] = 31] = "LINK"; + METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK"; + METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE"; + METHODS2[METHODS2["PRI"] = 34] = "PRI"; + METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE"; + METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE"; + METHODS2[METHODS2["SETUP"] = 37] = "SETUP"; + METHODS2[METHODS2["PLAY"] = 38] = "PLAY"; + METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE"; + METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN"; + METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER"; + METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER"; + METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT"; + METHODS2[METHODS2["RECORD"] = 44] = "RECORD"; + METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH"; + })(METHODS = exports2.METHODS || (exports2.METHODS = {})); + exports2.METHODS_HTTP = [ + METHODS.DELETE, + METHODS.GET, + METHODS.HEAD, + METHODS.POST, + METHODS.PUT, + METHODS.CONNECT, + METHODS.OPTIONS, + METHODS.TRACE, + METHODS.COPY, + METHODS.LOCK, + METHODS.MKCOL, + METHODS.MOVE, + METHODS.PROPFIND, + METHODS.PROPPATCH, + METHODS.SEARCH, + METHODS.UNLOCK, + METHODS.BIND, + METHODS.REBIND, + METHODS.UNBIND, + METHODS.ACL, + METHODS.REPORT, + METHODS.MKACTIVITY, + METHODS.CHECKOUT, + METHODS.MERGE, + METHODS["M-SEARCH"], + METHODS.NOTIFY, + METHODS.SUBSCRIBE, + METHODS.UNSUBSCRIBE, + METHODS.PATCH, + METHODS.PURGE, + METHODS.MKCALENDAR, + METHODS.LINK, + METHODS.UNLINK, + METHODS.PRI, + // TODO(indutny): should we allow it with HTTP? + METHODS.SOURCE + ]; + exports2.METHODS_ICE = [ + METHODS.SOURCE + ]; + exports2.METHODS_RTSP = [ + METHODS.OPTIONS, + METHODS.DESCRIBE, + METHODS.ANNOUNCE, + METHODS.SETUP, + METHODS.PLAY, + METHODS.PAUSE, + METHODS.TEARDOWN, + METHODS.GET_PARAMETER, + METHODS.SET_PARAMETER, + METHODS.REDIRECT, + METHODS.RECORD, + METHODS.FLUSH, + // For AirPlay + METHODS.GET, + METHODS.POST + ]; + exports2.METHOD_MAP = utils_1.enumToMap(METHODS); + exports2.H_METHOD_MAP = {}; + Object.keys(exports2.METHOD_MAP).forEach((key) => { + if (/^H/.test(key)) { + exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key]; + } + }); + var FINISH; + (function(FINISH2) { + FINISH2[FINISH2["SAFE"] = 0] = "SAFE"; + FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; + FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE"; + })(FINISH = exports2.FINISH || (exports2.FINISH = {})); + exports2.ALPHA = []; + for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) { + exports2.ALPHA.push(String.fromCharCode(i)); + exports2.ALPHA.push(String.fromCharCode(i + 32)); + } + exports2.NUM_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9 + }; + exports2.HEX_MAP = { + 0: 0, + 1: 1, + 2: 2, + 3: 3, + 4: 4, + 5: 5, + 6: 6, + 7: 7, + 8: 8, + 9: 9, + A: 10, + B: 11, + C: 12, + D: 13, + E: 14, + F: 15, + a: 10, + b: 11, + c: 12, + d: 13, + e: 14, + f: 15 + }; + exports2.NUM = [ + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9" + ]; + exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM); + exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"]; + exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]); + exports2.STRICT_URL_CHAR = [ + "!", + '"', + "$", + "%", + "&", + "'", + "(", + ")", + "*", + "+", + ",", + "-", + ".", + "/", + ":", + ";", + "<", + "=", + ">", + "@", + "[", + "\\", + "]", + "^", + "_", + "`", + "{", + "|", + "}", + "~" + ].concat(exports2.ALPHANUM); + exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]); + for (let i = 128; i <= 255; i++) { + exports2.URL_CHAR.push(i); + } + exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]); + exports2.STRICT_TOKEN = [ + "!", + "#", + "$", + "%", + "&", + "'", + "*", + "+", + "-", + ".", + "^", + "_", + "`", + "|", + "~" + ].concat(exports2.ALPHANUM); + exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]); + exports2.HEADER_CHARS = [" "]; + for (let i = 32; i <= 255; i++) { + if (i !== 127) { + exports2.HEADER_CHARS.push(i); + } + } + exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44); + exports2.MAJOR = exports2.NUM_MAP; + exports2.MINOR = exports2.MAJOR; + var HEADER_STATE; + (function(HEADER_STATE2) { + HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL"; + HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION"; + HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; + HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; + HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; + HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; + })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {})); + exports2.SPECIAL_HEADERS = { + "connection": HEADER_STATE.CONNECTION, + "content-length": HEADER_STATE.CONTENT_LENGTH, + "proxy-connection": HEADER_STATE.CONNECTION, + "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING, + "upgrade": HEADER_STATE.UPGRADE + }; + } +}); + +// node_modules/undici/lib/handler/RedirectHandler.js +var require_RedirectHandler = __commonJS({ + "node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) { + "use strict"; + var util = require_util(); + var { kBodyUsed } = require_symbols(); + var assert = require("assert"); + var { InvalidArgumentError } = require_errors(); + var EE = require("events"); + var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; + var kBody = Symbol("body"); + var BodyAsyncIterable = class { + constructor(body) { + this[kBody] = body; + this[kBodyUsed] = false; + } + async *[Symbol.asyncIterator]() { + assert(!this[kBodyUsed], "disturbed"); + this[kBodyUsed] = true; + yield* this[kBody]; + } + }; + var RedirectHandler = class { + constructor(dispatch, maxRedirections, opts, handler) { + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + util.validateHandler(handler, opts.method, opts.upgrade); + this.dispatch = dispatch; + this.location = null; + this.abort = null; + this.opts = { ...opts, maxRedirections: 0 }; + this.maxRedirections = maxRedirections; + this.handler = handler; + this.history = []; + if (util.isStream(this.opts.body)) { + if (util.bodyLength(this.opts.body) === 0) { + this.opts.body.on("data", function() { + assert(false); + }); + } + if (typeof this.opts.body.readableDidRead !== "boolean") { + this.opts.body[kBodyUsed] = false; + EE.prototype.on.call(this.opts.body, "data", function() { + this[kBodyUsed] = true; + }); + } + } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) { + this.opts.body = new BodyAsyncIterable(this.opts.body); + } + } + onConnect(abort) { + this.abort = abort; + this.handler.onConnect(abort, { history: this.history }); + } + onUpgrade(statusCode, headers, socket) { + this.handler.onUpgrade(statusCode, headers, socket); + } + onError(error) { + this.handler.onError(error); + } + onHeaders(statusCode, headers, resume, statusText) { + this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers); + if (this.opts.origin) { + this.history.push(new URL(this.opts.path, this.opts.origin)); + } + if (!this.location) { + return this.handler.onHeaders(statusCode, headers, resume, statusText); + } + const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); + const path3 = search ? `${pathname}${search}` : pathname; + this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); + this.opts.path = path3; + this.opts.origin = origin; + this.opts.maxRedirections = 0; + this.opts.query = null; + if (statusCode === 303 && this.opts.method !== "HEAD") { + this.opts.method = "GET"; + this.opts.body = null; + } + } + onData(chunk) { + if (this.location) { + } else { + return this.handler.onData(chunk); + } + } + onComplete(trailers) { + if (this.location) { + this.location = null; + this.abort = null; + this.dispatch(this.opts, this); + } else { + this.handler.onComplete(trailers); + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) { + this.handler.onBodySent(chunk); + } + } + }; + function parseLocation(statusCode, headers) { + if (redirectableStatusCodes.indexOf(statusCode) === -1) { + return null; + } + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toString().toLowerCase() === "location") { + return headers[i + 1]; + } + } + } + function shouldRemoveHeader(header, removeContent, unknownOrigin) { + if (header.length === 4) { + return util.headerNameToString(header) === "host"; + } + if (removeContent && util.headerNameToString(header).startsWith("content-")) { + return true; + } + if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { + const name = util.headerNameToString(header); + return name === "authorization" || name === "cookie" || name === "proxy-authorization"; + } + return false; + } + function cleanRequestHeaders(headers, removeContent, unknownOrigin) { + const ret = []; + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) { + ret.push(headers[i], headers[i + 1]); + } + } + } else if (headers && typeof headers === "object") { + for (const key of Object.keys(headers)) { + if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) { + ret.push(key, headers[key]); + } + } + } else { + assert(headers == null, "headers must be an object or an array"); + } + return ret; + } + module2.exports = RedirectHandler; + } +}); + +// node_modules/undici/lib/interceptor/redirectInterceptor.js +var require_redirectInterceptor = __commonJS({ + "node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) { + "use strict"; + var RedirectHandler = require_RedirectHandler(); + function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { + return (dispatch) => { + return function Intercept(opts, handler) { + const { maxRedirections = defaultMaxRedirections } = opts; + if (!maxRedirections) { + return dispatch(opts, handler); + } + const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler); + opts = { ...opts, maxRedirections: 0 }; + return dispatch(opts, redirectHandler); + }; + }; + } + module2.exports = createRedirectInterceptor; + } +}); + +// node_modules/undici/lib/llhttp/llhttp-wasm.js +var require_llhttp_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { + module2.exports = "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"; + } +}); + +// node_modules/undici/lib/llhttp/llhttp_simd-wasm.js +var require_llhttp_simd_wasm = __commonJS({ + "node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { + module2.exports = "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"; + } +}); + +// node_modules/undici/lib/client.js +var require_client = __commonJS({ + "node_modules/undici/lib/client.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var net = require("net"); + var http = require("http"); + var { pipeline } = require("stream"); + var util = require_util(); + var timers = require_timers(); + var Request = require_request(); + var DispatcherBase = require_dispatcher_base(); + var { + RequestContentLengthMismatchError, + ResponseContentLengthMismatchError, + InvalidArgumentError, + RequestAbortedError, + HeadersTimeoutError, + HeadersOverflowError, + SocketError, + InformationalError, + BodyTimeoutError, + HTTPParserError, + ResponseExceededMaxSizeError, + ClientDestroyedError + } = require_errors(); + var buildConnector = require_connect(); + var { + kUrl, + kReset, + kServerName, + kClient, + kBusy, + kParser, + kConnect, + kBlocking, + kResuming, + kRunning, + kPending, + kSize, + kWriting, + kQueue, + kConnected, + kConnecting, + kNeedDrain, + kNoRef, + kKeepAliveDefaultTimeout, + kHostHeader, + kPendingIdx, + kRunningIdx, + kError, + kPipelining, + kSocket, + kKeepAliveTimeoutValue, + kMaxHeadersSize, + kKeepAliveMaxTimeout, + kKeepAliveTimeoutThreshold, + kHeadersTimeout, + kBodyTimeout, + kStrictContentLength, + kConnector, + kMaxRedirections, + kMaxRequests, + kCounter, + kClose, + kDestroy, + kDispatch, + kInterceptors, + kLocalAddress, + kMaxResponseSize, + kHTTPConnVersion, + // HTTP2 + kHost, + kHTTP2Session, + kHTTP2SessionState, + kHTTP2BuildRequest, + kHTTP2CopyHeaders, + kHTTP1BuildRequest + } = require_symbols(); + var http2; + try { + http2 = require("http2"); + } catch { + http2 = { constants: {} }; + } + var { + constants: { + HTTP2_HEADER_AUTHORITY, + HTTP2_HEADER_METHOD, + HTTP2_HEADER_PATH, + HTTP2_HEADER_SCHEME, + HTTP2_HEADER_CONTENT_LENGTH, + HTTP2_HEADER_EXPECT, + HTTP2_HEADER_STATUS + } + } = http2; + var h2ExperimentalWarned = false; + var FastBuffer = Buffer[Symbol.species]; + var kClosedResolve = Symbol("kClosedResolve"); + var channels = {}; + try { + const diagnosticsChannel = require("diagnostics_channel"); + channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders"); + channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect"); + channels.connectError = diagnosticsChannel.channel("undici:client:connectError"); + channels.connected = diagnosticsChannel.channel("undici:client:connected"); + } catch { + channels.sendHeaders = { hasSubscribers: false }; + channels.beforeConnect = { hasSubscribers: false }; + channels.connectError = { hasSubscribers: false }; + channels.connected = { hasSubscribers: false }; + } + var Client = class extends DispatcherBase { + /** + * + * @param {string|URL} url + * @param {import('../types/client').Client.Options} options + */ + constructor(url, { + interceptors, + maxHeaderSize, + headersTimeout, + socketTimeout, + requestTimeout, + connectTimeout, + bodyTimeout, + idleTimeout, + keepAlive, + keepAliveTimeout, + maxKeepAliveTimeout, + keepAliveMaxTimeout, + keepAliveTimeoutThreshold, + socketPath, + pipelining, + tls, + strictContentLength, + maxCachedSessions, + maxRedirections, + connect: connect2, + maxRequestsPerClient, + localAddress, + maxResponseSize, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + // h2 + allowH2, + maxConcurrentStreams + } = {}) { + super(); + if (keepAlive !== void 0) { + throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead"); + } + if (socketTimeout !== void 0) { + throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead"); + } + if (requestTimeout !== void 0) { + throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead"); + } + if (idleTimeout !== void 0) { + throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead"); + } + if (maxKeepAliveTimeout !== void 0) { + throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead"); + } + if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) { + throw new InvalidArgumentError("invalid maxHeaderSize"); + } + if (socketPath != null && typeof socketPath !== "string") { + throw new InvalidArgumentError("invalid socketPath"); + } + if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) { + throw new InvalidArgumentError("invalid connectTimeout"); + } + if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveTimeout"); + } + if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) { + throw new InvalidArgumentError("invalid keepAliveMaxTimeout"); + } + if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) { + throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold"); + } + if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) { + throw new InvalidArgumentError("headersTimeout must be a positive integer or zero"); + } + if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) { + throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero"); + } + if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) { + throw new InvalidArgumentError("maxRequestsPerClient must be a positive number"); + } + if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) { + throw new InvalidArgumentError("localAddress must be valid string IP address"); + } + if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) { + throw new InvalidArgumentError("maxResponseSize must be a positive number"); + } + if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) { + throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number"); + } + if (allowH2 != null && typeof allowH2 !== "boolean") { + throw new InvalidArgumentError("allowH2 must be a valid boolean value"); + } + if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) { + throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0"); + } + if (typeof connect2 !== "function") { + connect2 = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect2 + }); + } + this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })]; + this[kUrl] = util.parseOrigin(url); + this[kConnector] = connect2; + this[kSocket] = null; + this[kPipelining] = pipelining != null ? pipelining : 1; + this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize; + this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout; + this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout; + this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold; + this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]; + this[kServerName] = null; + this[kLocalAddress] = localAddress != null ? localAddress : null; + this[kResuming] = 0; + this[kNeedDrain] = 0; + this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r +`; + this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5; + this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5; + this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength; + this[kMaxRedirections] = maxRedirections; + this[kMaxRequests] = maxRequestsPerClient; + this[kClosedResolve] = null; + this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1; + this[kHTTPConnVersion] = "h1"; + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = !allowH2 ? null : { + // streams: null, // Fixed queue of streams - For future support of `push` + openStreams: 0, + // Keep track of them to decide wether or not unref the session + maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100 + // Max peerConcurrentStreams for a Node h2 server + }; + this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`; + this[kQueue] = []; + this[kRunningIdx] = 0; + this[kPendingIdx] = 0; + } + get pipelining() { + return this[kPipelining]; + } + set pipelining(value) { + this[kPipelining] = value; + resume(this, true); + } + get [kPending]() { + return this[kQueue].length - this[kPendingIdx]; + } + get [kRunning]() { + return this[kPendingIdx] - this[kRunningIdx]; + } + get [kSize]() { + return this[kQueue].length - this[kRunningIdx]; + } + get [kConnected]() { + return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed; + } + get [kBusy]() { + const socket = this[kSocket]; + return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0; + } + /* istanbul ignore: only used for test */ + [kConnect](cb) { + connect(this); + this.once("connect", cb); + } + [kDispatch](opts, handler) { + const origin = opts.origin || this[kUrl].origin; + const request = this[kHTTPConnVersion] === "h2" ? Request[kHTTP2BuildRequest](origin, opts, handler) : Request[kHTTP1BuildRequest](origin, opts, handler); + this[kQueue].push(request); + if (this[kResuming]) { + } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) { + this[kResuming] = 1; + process.nextTick(resume, this); + } else { + resume(this, true); + } + if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) { + this[kNeedDrain] = 2; + } + return this[kNeedDrain] < 2; + } + async [kClose]() { + return new Promise((resolve) => { + if (!this[kSize]) { + resolve(null); + } else { + this[kClosedResolve] = resolve; + } + }); + } + async [kDestroy](err) { + return new Promise((resolve) => { + const requests = this[kQueue].splice(this[kPendingIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + const callback = () => { + if (this[kClosedResolve]) { + this[kClosedResolve](); + this[kClosedResolve] = null; + } + resolve(); + }; + if (this[kHTTP2Session] != null) { + util.destroy(this[kHTTP2Session], err); + this[kHTTP2Session] = null; + this[kHTTP2SessionState] = null; + } + if (!this[kSocket]) { + queueMicrotask(callback); + } else { + util.destroy(this[kSocket].on("close", callback), err); + } + resume(this); + }); + } + }; + function onHttp2SessionError(err) { + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + this[kSocket][kError] = err; + onError(this[kClient], err); + } + function onHttp2FrameError(type, code, id) { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + if (id === 0) { + this[kSocket][kError] = err; + onError(this[kClient], err); + } + } + function onHttp2SessionEnd() { + util.destroy(this, new SocketError("other side closed")); + util.destroy(this[kSocket], new SocketError("other side closed")); + } + function onHTTP2GoAway(code) { + const client = this[kClient]; + const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`); + client[kSocket] = null; + client[kHTTP2Session] = null; + if (client.destroyed) { + assert(this[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(this, request, err); + } + } else if (client[kRunning] > 0) { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit( + "disconnect", + client[kUrl], + [client], + err + ); + resume(client); + } + var constants = require_constants3(); + var createRedirectInterceptor = require_redirectInterceptor(); + var EMPTY_BUF = Buffer.alloc(0); + async function lazyllhttp() { + const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0; + let mod; + try { + mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64")); + } catch (e) { + mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64")); + } + return await WebAssembly.instantiate(mod, { + env: { + /* eslint-disable camelcase */ + wasm_on_url: (p, at, len) => { + return 0; + }, + wasm_on_status: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_begin: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageBegin() || 0; + }, + wasm_on_header_field: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_header_value: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; + }, + wasm_on_body: (p, at, len) => { + assert.strictEqual(currentParser.ptr, p); + const start = at - currentBufferPtr + currentBufferRef.byteOffset; + return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; + }, + wasm_on_message_complete: (p) => { + assert.strictEqual(currentParser.ptr, p); + return currentParser.onMessageComplete() || 0; + } + /* eslint-enable camelcase */ + } + }); + } + var llhttpInstance = null; + var llhttpPromise = lazyllhttp(); + llhttpPromise.catch(); + var currentParser = null; + var currentBufferRef = null; + var currentBufferSize = 0; + var currentBufferPtr = null; + var TIMEOUT_HEADERS = 1; + var TIMEOUT_BODY = 2; + var TIMEOUT_IDLE = 3; + var Parser = class { + constructor(client, socket, { exports: exports3 }) { + assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); + this.llhttp = exports3; + this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE); + this.client = client; + this.socket = socket; + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.statusCode = null; + this.statusText = ""; + this.upgrade = false; + this.headers = []; + this.headersSize = 0; + this.headersMaxSize = client[kMaxHeadersSize]; + this.shouldKeepAlive = false; + this.paused = false; + this.resume = this.resume.bind(this); + this.bytesRead = 0; + this.keepAlive = ""; + this.contentLength = ""; + this.connection = ""; + this.maxResponseSize = client[kMaxResponseSize]; + } + setTimeout(value, type) { + this.timeoutType = type; + if (value !== this.timeoutValue) { + timers.clearTimeout(this.timeout); + if (value) { + this.timeout = timers.setTimeout(onParserTimeout, value, this); + if (this.timeout.unref) { + this.timeout.unref(); + } + } else { + this.timeout = null; + } + this.timeoutValue = value; + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + } + resume() { + if (this.socket.destroyed || !this.paused) { + return; + } + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_resume(this.ptr); + assert(this.timeoutType === TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + this.paused = false; + this.execute(this.socket.read() || EMPTY_BUF); + this.readMore(); + } + readMore() { + while (!this.paused && this.ptr) { + const chunk = this.socket.read(); + if (chunk === null) { + break; + } + this.execute(chunk); + } + } + execute(data) { + assert(this.ptr != null); + assert(currentParser == null); + assert(!this.paused); + const { socket, llhttp } = this; + if (data.length > currentBufferSize) { + if (currentBufferPtr) { + llhttp.free(currentBufferPtr); + } + currentBufferSize = Math.ceil(data.length / 4096) * 4096; + currentBufferPtr = llhttp.malloc(currentBufferSize); + } + new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data); + try { + let ret; + try { + currentBufferRef = data; + currentParser = this; + ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length); + } catch (err) { + throw err; + } finally { + currentParser = null; + currentBufferRef = null; + } + const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; + if (ret === constants.ERROR.PAUSED_UPGRADE) { + this.onUpgrade(data.slice(offset)); + } else if (ret === constants.ERROR.PAUSED) { + this.paused = true; + socket.unshift(data.slice(offset)); + } else if (ret !== constants.ERROR.OK) { + const ptr = llhttp.llhttp_get_error_reason(this.ptr); + let message = ""; + if (ptr) { + const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); + message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; + } + throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)); + } + } catch (err) { + util.destroy(socket, err); + } + } + destroy() { + assert(this.ptr != null); + assert(currentParser == null); + this.llhttp.llhttp_free(this.ptr); + this.ptr = null; + timers.clearTimeout(this.timeout); + this.timeout = null; + this.timeoutValue = null; + this.timeoutType = null; + this.paused = false; + } + onStatus(buf) { + this.statusText = buf.toString(); + } + onMessageBegin() { + const { socket, client } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + } + onHeaderField(buf) { + const len = this.headers.length; + if ((len & 1) === 0) { + this.headers.push(buf); + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + } + this.trackHeader(buf.length); + } + onHeaderValue(buf) { + let len = this.headers.length; + if ((len & 1) === 1) { + this.headers.push(buf); + len += 1; + } else { + this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); + } + const key = this.headers[len - 2]; + if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") { + this.keepAlive += buf.toString(); + } else if (key.length === 10 && key.toString().toLowerCase() === "connection") { + this.connection += buf.toString(); + } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") { + this.contentLength += buf.toString(); + } + this.trackHeader(buf.length); + } + trackHeader(len) { + this.headersSize += len; + if (this.headersSize >= this.headersMaxSize) { + util.destroy(this.socket, new HeadersOverflowError()); + } + } + onUpgrade(head) { + const { upgrade, client, socket, headers, statusCode } = this; + assert(upgrade); + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(!socket.destroyed); + assert(socket === client[kSocket]); + assert(!this.paused); + assert(request.upgrade || request.method === "CONNECT"); + this.statusCode = null; + this.statusText = ""; + this.shouldKeepAlive = null; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + socket.unshift(head); + socket[kParser].destroy(); + socket[kParser] = null; + socket[kClient] = null; + socket[kError] = null; + socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose); + client[kSocket] = null; + client[kQueue][client[kRunningIdx]++] = null; + client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); + try { + request.onUpgrade(statusCode, headers, socket); + } catch (err) { + util.destroy(socket, err); + } + resume(client); + } + onHeadersComplete(statusCode, upgrade, shouldKeepAlive) { + const { client, socket, headers, statusText } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + if (!request) { + return -1; + } + assert(!this.upgrade); + assert(this.statusCode < 200); + if (statusCode === 100) { + util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket))); + return -1; + } + if (upgrade && !request.upgrade) { + util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket))); + return -1; + } + assert.strictEqual(this.timeoutType, TIMEOUT_HEADERS); + this.statusCode = statusCode; + this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. + request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; + if (this.statusCode >= 200) { + const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]; + this.setTimeout(bodyTimeout, TIMEOUT_BODY); + } else if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + if (request.method === "CONNECT") { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + if (upgrade) { + assert(client[kRunning] === 1); + this.upgrade = true; + return 2; + } + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (this.shouldKeepAlive && client[kPipelining]) { + const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null; + if (keepAliveTimeout != null) { + const timeout = Math.min( + keepAliveTimeout - client[kKeepAliveTimeoutThreshold], + client[kKeepAliveMaxTimeout] + ); + if (timeout <= 0) { + socket[kReset] = true; + } else { + client[kKeepAliveTimeoutValue] = timeout; + } + } else { + client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]; + } + } else { + socket[kReset] = true; + } + const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false; + if (request.aborted) { + return -1; + } + if (request.method === "HEAD") { + return 1; + } + if (statusCode < 200) { + return 1; + } + if (socket[kBlocking]) { + socket[kBlocking] = false; + resume(client); + } + return pause ? constants.ERROR.PAUSED : 0; + } + onBody(buf) { + const { client, socket, statusCode, maxResponseSize } = this; + if (socket.destroyed) { + return -1; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert.strictEqual(this.timeoutType, TIMEOUT_BODY); + if (this.timeout) { + if (this.timeout.refresh) { + this.timeout.refresh(); + } + } + assert(statusCode >= 200); + if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) { + util.destroy(socket, new ResponseExceededMaxSizeError()); + return -1; + } + this.bytesRead += buf.length; + if (request.onData(buf) === false) { + return constants.ERROR.PAUSED; + } + } + onMessageComplete() { + const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this; + if (socket.destroyed && (!statusCode || shouldKeepAlive)) { + return -1; + } + if (upgrade) { + return; + } + const request = client[kQueue][client[kRunningIdx]]; + assert(request); + assert(statusCode >= 100); + this.statusCode = null; + this.statusText = ""; + this.bytesRead = 0; + this.contentLength = ""; + this.keepAlive = ""; + this.connection = ""; + assert(this.headers.length % 2 === 0); + this.headers = []; + this.headersSize = 0; + if (statusCode < 200) { + return; + } + if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) { + util.destroy(socket, new ResponseContentLengthMismatchError()); + return -1; + } + request.onComplete(headers); + client[kQueue][client[kRunningIdx]++] = null; + if (socket[kWriting]) { + assert.strictEqual(client[kRunning], 0); + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (!shouldKeepAlive) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (socket[kReset] && client[kRunning] === 0) { + util.destroy(socket, new InformationalError("reset")); + return constants.ERROR.PAUSED; + } else if (client[kPipelining] === 1) { + setImmediate(resume, client); + } else { + resume(client); + } + } + }; + function onParserTimeout(parser) { + const { socket, timeoutType, client } = parser; + if (timeoutType === TIMEOUT_HEADERS) { + if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { + assert(!parser.paused, "cannot be paused while waiting for headers"); + util.destroy(socket, new HeadersTimeoutError()); + } + } else if (timeoutType === TIMEOUT_BODY) { + if (!parser.paused) { + util.destroy(socket, new BodyTimeoutError()); + } + } else if (timeoutType === TIMEOUT_IDLE) { + assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); + util.destroy(socket, new InformationalError("socket idle timeout")); + } + } + function onSocketReadable() { + const { [kParser]: parser } = this; + if (parser) { + parser.readMore(); + } + } + function onSocketError(err) { + const { [kClient]: client, [kParser]: parser } = this; + assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + if (client[kHTTPConnVersion] !== "h2") { + if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + this[kError] = err; + onError(this[kClient], err); + } + function onError(client, err) { + if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") { + assert(client[kPendingIdx] === client[kRunningIdx]); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + assert(client[kSize] === 0); + } + } + function onSocketEnd() { + const { [kParser]: parser, [kClient]: client } = this; + if (client[kHTTPConnVersion] !== "h2") { + if (parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + return; + } + } + util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this))); + } + function onSocketClose() { + const { [kClient]: client, [kParser]: parser } = this; + if (client[kHTTPConnVersion] === "h1" && parser) { + if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) { + parser.onMessageComplete(); + } + this[kParser].destroy(); + this[kParser] = null; + } + const err = this[kError] || new SocketError("closed", util.getSocketInfo(this)); + client[kSocket] = null; + if (client.destroyed) { + assert(client[kPending] === 0); + const requests = client[kQueue].splice(client[kRunningIdx]); + for (let i = 0; i < requests.length; i++) { + const request = requests[i]; + errorRequest(client, request, err); + } + } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") { + const request = client[kQueue][client[kRunningIdx]]; + client[kQueue][client[kRunningIdx]++] = null; + errorRequest(client, request, err); + } + client[kPendingIdx] = client[kRunningIdx]; + assert(client[kRunning] === 0); + client.emit("disconnect", client[kUrl], [client], err); + resume(client); + } + async function connect(client) { + assert(!client[kConnecting]); + assert(!client[kSocket]); + let { host, hostname, protocol, port } = client[kUrl]; + if (hostname[0] === "[") { + const idx = hostname.indexOf("]"); + assert(idx !== -1); + const ip = hostname.substring(1, idx); + assert(net.isIP(ip)); + hostname = ip; + } + client[kConnecting] = true; + if (channels.beforeConnect.hasSubscribers) { + channels.beforeConnect.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector] + }); + } + try { + const socket = await new Promise((resolve, reject) => { + client[kConnector]({ + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, (err, socket2) => { + if (err) { + reject(err); + } else { + resolve(socket2); + } + }); + }); + if (client.destroyed) { + util.destroy(socket.on("error", () => { + }), new ClientDestroyedError()); + return; + } + client[kConnecting] = false; + assert(socket); + const isH2 = socket.alpnProtocol === "h2"; + if (isH2) { + if (!h2ExperimentalWarned) { + h2ExperimentalWarned = true; + process.emitWarning("H2 support is experimental, expect them to change at any time.", { + code: "UNDICI-H2" + }); + } + const session = http2.connect(client[kUrl], { + createConnection: () => socket, + peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams + }); + client[kHTTPConnVersion] = "h2"; + session[kClient] = client; + session[kSocket] = socket; + session.on("error", onHttp2SessionError); + session.on("frameError", onHttp2FrameError); + session.on("end", onHttp2SessionEnd); + session.on("goaway", onHTTP2GoAway); + session.on("close", onSocketClose); + session.unref(); + client[kHTTP2Session] = session; + socket[kHTTP2Session] = session; + } else { + if (!llhttpInstance) { + llhttpInstance = await llhttpPromise; + llhttpPromise = null; + } + socket[kNoRef] = false; + socket[kWriting] = false; + socket[kReset] = false; + socket[kBlocking] = false; + socket[kParser] = new Parser(client, socket, llhttpInstance); + } + socket[kCounter] = 0; + socket[kMaxRequests] = client[kMaxRequests]; + socket[kClient] = client; + socket[kError] = null; + socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose); + client[kSocket] = socket; + if (channels.connected.hasSubscribers) { + channels.connected.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + socket + }); + } + client.emit("connect", client[kUrl], [client]); + } catch (err) { + if (client.destroyed) { + return; + } + client[kConnecting] = false; + if (channels.connectError.hasSubscribers) { + channels.connectError.publish({ + connectParams: { + host, + hostname, + protocol, + port, + servername: client[kServerName], + localAddress: client[kLocalAddress] + }, + connector: client[kConnector], + error: err + }); + } + if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { + assert(client[kRunning] === 0); + while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { + const request = client[kQueue][client[kPendingIdx]++]; + errorRequest(client, request, err); + } + } else { + onError(client, err); + } + client.emit("connectionError", client[kUrl], [client], err); + } + resume(client); + } + function emitDrain(client) { + client[kNeedDrain] = 0; + client.emit("drain", client[kUrl], [client]); + } + function resume(client, sync) { + if (client[kResuming] === 2) { + return; + } + client[kResuming] = 2; + _resume(client, sync); + client[kResuming] = 0; + if (client[kRunningIdx] > 256) { + client[kQueue].splice(0, client[kRunningIdx]); + client[kPendingIdx] -= client[kRunningIdx]; + client[kRunningIdx] = 0; + } + } + function _resume(client, sync) { + while (true) { + if (client.destroyed) { + assert(client[kPending] === 0); + return; + } + if (client[kClosedResolve] && !client[kSize]) { + client[kClosedResolve](); + client[kClosedResolve] = null; + return; + } + const socket = client[kSocket]; + if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") { + if (client[kSize] === 0) { + if (!socket[kNoRef] && socket.unref) { + socket.unref(); + socket[kNoRef] = true; + } + } else if (socket[kNoRef] && socket.ref) { + socket.ref(); + socket[kNoRef] = false; + } + if (client[kSize] === 0) { + if (socket[kParser].timeoutType !== TIMEOUT_IDLE) { + socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE); + } + } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) { + if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) { + const request2 = client[kQueue][client[kRunningIdx]]; + const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout]; + socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS); + } + } + } + if (client[kBusy]) { + client[kNeedDrain] = 2; + } else if (client[kNeedDrain] === 2) { + if (sync) { + client[kNeedDrain] = 1; + process.nextTick(emitDrain, client); + } else { + emitDrain(client); + } + continue; + } + if (client[kPending] === 0) { + return; + } + if (client[kRunning] >= (client[kPipelining] || 1)) { + return; + } + const request = client[kQueue][client[kPendingIdx]]; + if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) { + if (client[kRunning] > 0) { + return; + } + client[kServerName] = request.servername; + if (socket && socket.servername !== request.servername) { + util.destroy(socket, new InformationalError("servername changed")); + return; + } + } + if (client[kConnecting]) { + return; + } + if (!socket && !client[kHTTP2Session]) { + connect(client); + return; + } + if (socket.destroyed || socket[kWriting] || socket[kReset] || socket[kBlocking]) { + return; + } + if (client[kRunning] > 0 && !request.idempotent) { + return; + } + if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) { + return; + } + if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 && (util.isStream(request.body) || util.isAsyncIterable(request.body))) { + return; + } + if (!request.aborted && write(client, request)) { + client[kPendingIdx]++; + } else { + client[kQueue].splice(client[kPendingIdx], 1); + } + } + } + function shouldSendContentLength(method) { + return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; + } + function write(client, request) { + if (client[kHTTPConnVersion] === "h2") { + writeH2(client, client[kHTTP2Session], request); + return; + } + const { body, method, path: path3, host, upgrade, headers, blocking, reset } = request; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + const bodyLength = util.bodyLength(body); + let contentLength = bodyLength; + if (contentLength === null) { + contentLength = request.contentLength; + } + if (contentLength === 0 && !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + const socket = client[kSocket]; + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); + util.destroy(socket, new InformationalError("aborted")); + }); + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + if (method === "HEAD") { + socket[kReset] = true; + } + if (upgrade || method === "CONNECT") { + socket[kReset] = true; + } + if (reset != null) { + socket[kReset] = reset; + } + if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { + socket[kReset] = true; + } + if (blocking) { + socket[kBlocking] = true; + } + let header = `${method} ${path3} HTTP/1.1\r +`; + if (typeof host === "string") { + header += `host: ${host}\r +`; + } else { + header += client[kHostHeader]; + } + if (upgrade) { + header += `connection: upgrade\r +upgrade: ${upgrade}\r +`; + } else if (client[kPipelining] && !socket[kReset]) { + header += "connection: keep-alive\r\n"; + } else { + header += "connection: close\r\n"; + } + if (headers) { + header += headers; + } + if (channels.sendHeaders.hasSubscribers) { + channels.sendHeaders.publish({ request, headers: header, socket }); + } + if (!body || bodyLength === 0) { + if (contentLength === 0) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + assert(contentLength === null, "no body must not have content length"); + socket.write(`${header}\r +`, "latin1"); + } + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(body); + socket.uncork(); + request.onBodySent(body); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload }); + } else { + writeBlob({ body, client, request, socket, contentLength, header, expectsPayload }); + } + } else if (util.isStream(body)) { + writeStream({ body, client, request, socket, contentLength, header, expectsPayload }); + } else if (util.isIterable(body)) { + writeIterable({ body, client, request, socket, contentLength, header, expectsPayload }); + } else { + assert(false); + } + return true; + } + function writeH2(client, session, request) { + const { body, method, path: path3, host, upgrade, expectContinue, signal, headers: reqHeaders } = request; + let headers; + if (typeof reqHeaders === "string") headers = Request[kHTTP2CopyHeaders](reqHeaders.trim()); + else headers = reqHeaders; + if (upgrade) { + errorRequest(client, request, new Error("Upgrade not supported for H2")); + return false; + } + try { + request.onConnect((err) => { + if (request.aborted || request.completed) { + return; + } + errorRequest(client, request, err || new RequestAbortedError()); + }); + } catch (err) { + errorRequest(client, request, err); + } + if (request.aborted) { + return false; + } + let stream; + const h2State = client[kHTTP2SessionState]; + headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost]; + headers[HTTP2_HEADER_METHOD] = method; + if (method === "CONNECT") { + session.ref(); + stream = session.request(headers, { endStream: false, signal }); + if (stream.id && !stream.pending) { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + } else { + stream.once("ready", () => { + request.onUpgrade(null, null, stream); + ++h2State.openStreams; + }); + } + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) session.unref(); + }); + return true; + } + headers[HTTP2_HEADER_PATH] = path3; + headers[HTTP2_HEADER_SCHEME] = "https"; + const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; + if (body && typeof body.read === "function") { + body.read(0); + } + let contentLength = util.bodyLength(body); + if (contentLength == null) { + contentLength = request.contentLength; + } + if (contentLength === 0 || !expectsPayload) { + contentLength = null; + } + if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { + if (client[kStrictContentLength]) { + errorRequest(client, request, new RequestContentLengthMismatchError()); + return false; + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + if (contentLength != null) { + assert(body, "no body must not have content length"); + headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`; + } + session.ref(); + const shouldEndStream = method === "GET" || method === "HEAD"; + if (expectContinue) { + headers[HTTP2_HEADER_EXPECT] = "100-continue"; + stream = session.request(headers, { endStream: shouldEndStream, signal }); + stream.once("continue", writeBodyH2); + } else { + stream = session.request(headers, { + endStream: shouldEndStream, + signal + }); + writeBodyH2(); + } + ++h2State.openStreams; + stream.once("response", (headers2) => { + const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2; + if (request.onHeaders(Number(statusCode), realHeaders, stream.resume.bind(stream), "") === false) { + stream.pause(); + } + }); + stream.once("end", () => { + request.onComplete([]); + }); + stream.on("data", (chunk) => { + if (request.onData(chunk) === false) { + stream.pause(); + } + }); + stream.once("close", () => { + h2State.openStreams -= 1; + if (h2State.openStreams === 0) { + session.unref(); + } + }); + stream.once("error", function(err) { + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + stream.once("frameError", (type, code) => { + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + errorRequest(client, request, err); + if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) { + h2State.streams -= 1; + util.destroy(stream, err); + } + }); + return true; + function writeBodyH2() { + if (!body) { + request.onRequestSent(); + } else if (util.isBuffer(body)) { + assert(contentLength === body.byteLength, "buffer body must have content length"); + stream.cork(); + stream.write(body); + stream.uncork(); + stream.end(); + request.onBodySent(body); + request.onRequestSent(); + } else if (util.isBlobLike(body)) { + if (typeof body.stream === "function") { + writeIterable({ + client, + request, + contentLength, + h2stream: stream, + expectsPayload, + body: body.stream(), + socket: client[kSocket], + header: "" + }); + } else { + writeBlob({ + body, + client, + request, + contentLength, + expectsPayload, + h2stream: stream, + header: "", + socket: client[kSocket] + }); + } + } else if (util.isStream(body)) { + writeStream({ + body, + client, + request, + contentLength, + expectsPayload, + socket: client[kSocket], + h2stream: stream, + header: "" + }); + } else if (util.isIterable(body)) { + writeIterable({ + body, + client, + request, + contentLength, + expectsPayload, + header: "", + h2stream: stream, + socket: client[kSocket] + }); + } else { + assert(false); + } + } + } + function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + if (client[kHTTPConnVersion] === "h2") { + let onPipeData = function(chunk) { + request.onBodySent(chunk); + }; + const pipe = pipeline( + body, + h2stream, + (err) => { + if (err) { + util.destroy(body, err); + util.destroy(h2stream, err); + } else { + request.onRequestSent(); + } + } + ); + pipe.on("data", onPipeData); + pipe.once("end", () => { + pipe.removeListener("data", onPipeData); + util.destroy(pipe); + }); + return; + } + let finished = false; + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + const onData = function(chunk) { + if (finished) { + return; + } + try { + if (!writer.write(chunk) && this.pause) { + this.pause(); + } + } catch (err) { + util.destroy(this, err); + } + }; + const onDrain = function() { + if (finished) { + return; + } + if (body.resume) { + body.resume(); + } + }; + const onAbort = function() { + if (finished) { + return; + } + const err = new RequestAbortedError(); + queueMicrotask(() => onFinished(err)); + }; + const onFinished = function(err) { + if (finished) { + return; + } + finished = true; + assert(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); + socket.off("drain", onDrain).off("error", onFinished); + body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort); + if (!err) { + try { + writer.end(); + } catch (er) { + err = er; + } + } + writer.destroy(err); + if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) { + util.destroy(body, err); + } else { + util.destroy(body); + } + }; + body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort); + if (body.resume) { + body.resume(); + } + socket.on("drain", onDrain).on("error", onFinished); + } + async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength === body.size, "blob body must have content length"); + const isH2 = client[kHTTPConnVersion] === "h2"; + try { + if (contentLength != null && contentLength !== body.size) { + throw new RequestContentLengthMismatchError(); + } + const buffer = Buffer.from(await body.arrayBuffer()); + if (isH2) { + h2stream.cork(); + h2stream.write(buffer); + h2stream.uncork(); + } else { + socket.cork(); + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + socket.write(buffer); + socket.uncork(); + } + request.onBodySent(buffer); + request.onRequestSent(); + if (!expectsPayload) { + socket[kReset] = true; + } + resume(client); + } catch (err) { + util.destroy(isH2 ? h2stream : socket, err); + } + } + async function writeIterable({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) { + assert(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + let callback = null; + function onDrain() { + if (callback) { + const cb = callback; + callback = null; + cb(); + } + } + const waitForDrain = () => new Promise((resolve, reject) => { + assert(callback === null); + if (socket[kError]) { + reject(socket[kError]); + } else { + callback = resolve; + } + }); + if (client[kHTTPConnVersion] === "h2") { + h2stream.on("close", onDrain).on("drain", onDrain); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + const res = h2stream.write(chunk); + request.onBodySent(chunk); + if (!res) { + await waitForDrain(); + } + } + } catch (err) { + h2stream.destroy(err); + } finally { + request.onRequestSent(); + h2stream.end(); + h2stream.off("close", onDrain).off("drain", onDrain); + } + return; + } + socket.on("close", onDrain).on("drain", onDrain); + const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header }); + try { + for await (const chunk of body) { + if (socket[kError]) { + throw socket[kError]; + } + if (!writer.write(chunk)) { + await waitForDrain(); + } + } + writer.end(); + } catch (err) { + writer.destroy(err); + } finally { + socket.off("close", onDrain).off("drain", onDrain); + } + } + var AsyncWriter = class { + constructor({ socket, request, contentLength, client, expectsPayload, header }) { + this.socket = socket; + this.request = request; + this.contentLength = contentLength; + this.client = client; + this.bytesWritten = 0; + this.expectsPayload = expectsPayload; + this.header = header; + socket[kWriting] = true; + } + write(chunk) { + const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return false; + } + const len = Buffer.byteLength(chunk); + if (!len) { + return true; + } + if (contentLength !== null && bytesWritten + len > contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } + process.emitWarning(new RequestContentLengthMismatchError()); + } + socket.cork(); + if (bytesWritten === 0) { + if (!expectsPayload) { + socket[kReset] = true; + } + if (contentLength === null) { + socket.write(`${header}transfer-encoding: chunked\r +`, "latin1"); + } else { + socket.write(`${header}content-length: ${contentLength}\r +\r +`, "latin1"); + } + } + if (contentLength === null) { + socket.write(`\r +${len.toString(16)}\r +`, "latin1"); + } + this.bytesWritten += len; + const ret = socket.write(chunk); + socket.uncork(); + request.onBodySent(chunk); + if (!ret) { + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + } + return ret; + } + end() { + const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this; + request.onRequestSent(); + socket[kWriting] = false; + if (socket[kError]) { + throw socket[kError]; + } + if (socket.destroyed) { + return; + } + if (bytesWritten === 0) { + if (expectsPayload) { + socket.write(`${header}content-length: 0\r +\r +`, "latin1"); + } else { + socket.write(`${header}\r +`, "latin1"); + } + } else if (contentLength === null) { + socket.write("\r\n0\r\n\r\n", "latin1"); + } + if (contentLength !== null && bytesWritten !== contentLength) { + if (client[kStrictContentLength]) { + throw new RequestContentLengthMismatchError(); + } else { + process.emitWarning(new RequestContentLengthMismatchError()); + } + } + if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) { + if (socket[kParser].timeout.refresh) { + socket[kParser].timeout.refresh(); + } + } + resume(client); + } + destroy(err) { + const { socket, client } = this; + socket[kWriting] = false; + if (err) { + assert(client[kRunning] <= 1, "pipeline should only contain this request"); + util.destroy(socket, err); + } + } + }; + function errorRequest(client, request, err) { + try { + request.onError(err); + assert(request.aborted); + } catch (err2) { + client.emit("error", err2); + } + } + module2.exports = Client; + } +}); + +// node_modules/undici/lib/node/fixed-queue.js +var require_fixed_queue = __commonJS({ + "node_modules/undici/lib/node/fixed-queue.js"(exports2, module2) { + "use strict"; + var kSize = 2048; + var kMask = kSize - 1; + var FixedCircularBuffer = class { + constructor() { + this.bottom = 0; + this.top = 0; + this.list = new Array(kSize); + this.next = null; + } + isEmpty() { + return this.top === this.bottom; + } + isFull() { + return (this.top + 1 & kMask) === this.bottom; + } + push(data) { + this.list[this.top] = data; + this.top = this.top + 1 & kMask; + } + shift() { + const nextItem = this.list[this.bottom]; + if (nextItem === void 0) + return null; + this.list[this.bottom] = void 0; + this.bottom = this.bottom + 1 & kMask; + return nextItem; + } + }; + module2.exports = class FixedQueue { + constructor() { + this.head = this.tail = new FixedCircularBuffer(); + } + isEmpty() { + return this.head.isEmpty(); + } + push(data) { + if (this.head.isFull()) { + this.head = this.head.next = new FixedCircularBuffer(); + } + this.head.push(data); + } + shift() { + const tail = this.tail; + const next = tail.shift(); + if (tail.isEmpty() && tail.next !== null) { + this.tail = tail.next; + } + return next; + } + }; + } +}); + +// node_modules/undici/lib/pool-stats.js +var require_pool_stats = __commonJS({ + "node_modules/undici/lib/pool-stats.js"(exports2, module2) { + var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols(); + var kPool = Symbol("pool"); + var PoolStats = class { + constructor(pool) { + this[kPool] = pool; + } + get connected() { + return this[kPool][kConnected]; + } + get free() { + return this[kPool][kFree]; + } + get pending() { + return this[kPool][kPending]; + } + get queued() { + return this[kPool][kQueued]; + } + get running() { + return this[kPool][kRunning]; + } + get size() { + return this[kPool][kSize]; + } + }; + module2.exports = PoolStats; + } +}); + +// node_modules/undici/lib/pool-base.js +var require_pool_base = __commonJS({ + "node_modules/undici/lib/pool-base.js"(exports2, module2) { + "use strict"; + var DispatcherBase = require_dispatcher_base(); + var FixedQueue = require_fixed_queue(); + var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols(); + var PoolStats = require_pool_stats(); + var kClients = Symbol("clients"); + var kNeedDrain = Symbol("needDrain"); + var kQueue = Symbol("queue"); + var kClosedResolve = Symbol("closed resolve"); + var kOnDrain = Symbol("onDrain"); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kGetDispatcher = Symbol("get dispatcher"); + var kAddClient = Symbol("add client"); + var kRemoveClient = Symbol("remove client"); + var kStats = Symbol("stats"); + var PoolBase = class extends DispatcherBase { + constructor() { + super(); + this[kQueue] = new FixedQueue(); + this[kClients] = []; + this[kQueued] = 0; + const pool = this; + this[kOnDrain] = function onDrain(origin, targets) { + const queue = pool[kQueue]; + let needDrain = false; + while (!needDrain) { + const item = queue.shift(); + if (!item) { + break; + } + pool[kQueued]--; + needDrain = !this.dispatch(item.opts, item.handler); + } + this[kNeedDrain] = needDrain; + if (!this[kNeedDrain] && pool[kNeedDrain]) { + pool[kNeedDrain] = false; + pool.emit("drain", origin, [pool, ...targets]); + } + if (pool[kClosedResolve] && queue.isEmpty()) { + Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]); + } + }; + this[kOnConnect] = (origin, targets) => { + pool.emit("connect", origin, [pool, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + pool.emit("disconnect", origin, [pool, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + pool.emit("connectionError", origin, [pool, ...targets], err); + }; + this[kStats] = new PoolStats(this); + } + get [kBusy]() { + return this[kNeedDrain]; + } + get [kConnected]() { + return this[kClients].filter((client) => client[kConnected]).length; + } + get [kFree]() { + return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length; + } + get [kPending]() { + let ret = this[kQueued]; + for (const { [kPending]: pending } of this[kClients]) { + ret += pending; + } + return ret; + } + get [kRunning]() { + let ret = 0; + for (const { [kRunning]: running } of this[kClients]) { + ret += running; + } + return ret; + } + get [kSize]() { + let ret = this[kQueued]; + for (const { [kSize]: size } of this[kClients]) { + ret += size; + } + return ret; + } + get stats() { + return this[kStats]; + } + async [kClose]() { + if (this[kQueue].isEmpty()) { + return Promise.all(this[kClients].map((c) => c.close())); + } else { + return new Promise((resolve) => { + this[kClosedResolve] = resolve; + }); + } + } + async [kDestroy](err) { + while (true) { + const item = this[kQueue].shift(); + if (!item) { + break; + } + item.handler.onError(err); + } + return Promise.all(this[kClients].map((c) => c.destroy(err))); + } + [kDispatch](opts, handler) { + const dispatcher = this[kGetDispatcher](); + if (!dispatcher) { + this[kNeedDrain] = true; + this[kQueue].push({ opts, handler }); + this[kQueued]++; + } else if (!dispatcher.dispatch(opts, handler)) { + dispatcher[kNeedDrain] = true; + this[kNeedDrain] = !this[kGetDispatcher](); + } + return !this[kNeedDrain]; + } + [kAddClient](client) { + client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].push(client); + if (this[kNeedDrain]) { + process.nextTick(() => { + if (this[kNeedDrain]) { + this[kOnDrain](client[kUrl], [this, client]); + } + }); + } + return this; + } + [kRemoveClient](client) { + client.close(() => { + const idx = this[kClients].indexOf(client); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + }); + this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true); + } + }; + module2.exports = { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + }; + } +}); + +// node_modules/undici/lib/pool.js +var require_pool = __commonJS({ + "node_modules/undici/lib/pool.js"(exports2, module2) { + "use strict"; + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kGetDispatcher + } = require_pool_base(); + var Client = require_client(); + var { + InvalidArgumentError + } = require_errors(); + var util = require_util(); + var { kUrl, kInterceptors } = require_symbols(); + var buildConnector = require_connect(); + var kOptions = Symbol("options"); + var kConnections = Symbol("connections"); + var kFactory = Symbol("factory"); + function defaultFactory(origin, opts) { + return new Client(origin, opts); + } + var Pool = class extends PoolBase { + constructor(origin, { + connections, + factory = defaultFactory, + connect, + connectTimeout, + tls, + maxCachedSessions, + socketPath, + autoSelectFamily, + autoSelectFamilyAttemptTimeout, + allowH2, + ...options + } = {}) { + super(); + if (connections != null && (!Number.isFinite(connections) || connections < 0)) { + throw new InvalidArgumentError("invalid connections"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (typeof connect !== "function") { + connect = buildConnector({ + ...tls, + maxCachedSessions, + allowH2, + socketPath, + timeout: connectTimeout, + ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, + ...connect + }); + } + this[kInterceptors] = options.interceptors && options.interceptors.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : []; + this[kConnections] = connections || null; + this[kUrl] = util.parseOrigin(origin); + this[kOptions] = { ...util.deepClone(options), connect, allowH2 }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kFactory] = factory; + this.on("connectionError", (origin2, targets, error) => { + for (const target of targets) { + const idx = this[kClients].indexOf(target); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } + } + }); + } + [kGetDispatcher]() { + let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]); + if (dispatcher) { + return dispatcher; + } + if (!this[kConnections] || this[kClients].length < this[kConnections]) { + dispatcher = this[kFactory](this[kUrl], this[kOptions]); + this[kAddClient](dispatcher); + } + return dispatcher; + } + }; + module2.exports = Pool; + } +}); + +// node_modules/undici/lib/balanced-pool.js +var require_balanced_pool = __commonJS({ + "node_modules/undici/lib/balanced-pool.js"(exports2, module2) { + "use strict"; + var { + BalancedPoolMissingUpstreamError, + InvalidArgumentError + } = require_errors(); + var { + PoolBase, + kClients, + kNeedDrain, + kAddClient, + kRemoveClient, + kGetDispatcher + } = require_pool_base(); + var Pool = require_pool(); + var { kUrl, kInterceptors } = require_symbols(); + var { parseOrigin } = require_util(); + var kFactory = Symbol("factory"); + var kOptions = Symbol("options"); + var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor"); + var kCurrentWeight = Symbol("kCurrentWeight"); + var kIndex = Symbol("kIndex"); + var kWeight = Symbol("kWeight"); + var kMaxWeightPerServer = Symbol("kMaxWeightPerServer"); + var kErrorPenalty = Symbol("kErrorPenalty"); + function getGreatestCommonDivisor(a, b) { + if (b === 0) return a; + return getGreatestCommonDivisor(b, a % b); + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var BalancedPool = class extends PoolBase { + constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) { + super(); + this[kOptions] = opts; + this[kIndex] = -1; + this[kCurrentWeight] = 0; + this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100; + this[kErrorPenalty] = this[kOptions].errorPenalty || 15; + if (!Array.isArray(upstreams)) { + upstreams = [upstreams]; + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : []; + this[kFactory] = factory; + for (const upstream of upstreams) { + this.addUpstream(upstream); + } + this._updateBalancedPoolStats(); + } + addUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) { + return this; + } + const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions])); + this[kAddClient](pool); + pool.on("connect", () => { + pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]); + }); + pool.on("connectionError", () => { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + }); + pool.on("disconnect", (...args) => { + const err = args[2]; + if (err && err.code === "UND_ERR_SOCKET") { + pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty]); + this._updateBalancedPoolStats(); + } + }); + for (const client of this[kClients]) { + client[kWeight] = this[kMaxWeightPerServer]; + } + this._updateBalancedPoolStats(); + return this; + } + _updateBalancedPoolStats() { + this[kGreatestCommonDivisor] = this[kClients].map((p) => p[kWeight]).reduce(getGreatestCommonDivisor, 0); + } + removeUpstream(upstream) { + const upstreamOrigin = parseOrigin(upstream).origin; + const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true); + if (pool) { + this[kRemoveClient](pool); + } + return this; + } + get upstreams() { + return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin); + } + [kGetDispatcher]() { + if (this[kClients].length === 0) { + throw new BalancedPoolMissingUpstreamError(); + } + const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true); + if (!dispatcher) { + return; + } + const allClientsBusy = this[kClients].map((pool) => pool[kNeedDrain]).reduce((a, b) => a && b, true); + if (allClientsBusy) { + return; + } + let counter = 0; + let maxWeightIndex = this[kClients].findIndex((pool) => !pool[kNeedDrain]); + while (counter++ < this[kClients].length) { + this[kIndex] = (this[kIndex] + 1) % this[kClients].length; + const pool = this[kClients][this[kIndex]]; + if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) { + maxWeightIndex = this[kIndex]; + } + if (this[kIndex] === 0) { + this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]; + if (this[kCurrentWeight] <= 0) { + this[kCurrentWeight] = this[kMaxWeightPerServer]; + } + } + if (pool[kWeight] >= this[kCurrentWeight] && !pool[kNeedDrain]) { + return pool; + } + } + this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]; + this[kIndex] = maxWeightIndex; + return this[kClients][maxWeightIndex]; + } + }; + module2.exports = BalancedPool; + } +}); + +// node_modules/undici/lib/compat/dispatcher-weakref.js +var require_dispatcher_weakref = __commonJS({ + "node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module2) { + "use strict"; + var { kConnected, kSize } = require_symbols(); + var CompatWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value; + } + }; + var CompatFinalizer = class { + constructor(finalizer) { + this.finalizer = finalizer; + } + register(dispatcher, key) { + if (dispatcher.on) { + dispatcher.on("disconnect", () => { + if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) { + this.finalizer(key); + } + }); + } + } + }; + module2.exports = function() { + if (process.env.NODE_V8_COVERAGE) { + return { + WeakRef: CompatWeakRef, + FinalizationRegistry: CompatFinalizer + }; + } + return { + WeakRef: global.WeakRef || CompatWeakRef, + FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer + }; + }; + } +}); + +// node_modules/undici/lib/agent.js +var require_agent = __commonJS({ + "node_modules/undici/lib/agent.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError } = require_errors(); + var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); + var DispatcherBase = require_dispatcher_base(); + var Pool = require_pool(); + var Client = require_client(); + var util = require_util(); + var createRedirectInterceptor = require_redirectInterceptor(); + var { WeakRef: WeakRef2, FinalizationRegistry } = require_dispatcher_weakref()(); + var kOnConnect = Symbol("onConnect"); + var kOnDisconnect = Symbol("onDisconnect"); + var kOnConnectionError = Symbol("onConnectionError"); + var kMaxRedirections = Symbol("maxRedirections"); + var kOnDrain = Symbol("onDrain"); + var kFactory = Symbol("factory"); + var kFinalizer = Symbol("finalizer"); + var kOptions = Symbol("options"); + function defaultFactory(origin, opts) { + return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts); + } + var Agent = class extends DispatcherBase { + constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { + super(); + if (typeof factory !== "function") { + throw new InvalidArgumentError("factory must be a function."); + } + if (connect != null && typeof connect !== "function" && typeof connect !== "object") { + throw new InvalidArgumentError("connect must be a function or an object"); + } + if (!Number.isInteger(maxRedirections) || maxRedirections < 0) { + throw new InvalidArgumentError("maxRedirections must be a positive number"); + } + if (connect && typeof connect !== "function") { + connect = { ...connect }; + } + this[kInterceptors] = options.interceptors && options.interceptors.Agent && Array.isArray(options.interceptors.Agent) ? options.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })]; + this[kOptions] = { ...util.deepClone(options), connect }; + this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0; + this[kMaxRedirections] = maxRedirections; + this[kFactory] = factory; + this[kClients] = /* @__PURE__ */ new Map(); + this[kFinalizer] = new FinalizationRegistry( + /* istanbul ignore next: gc is undeterministic */ + (key) => { + const ref = this[kClients].get(key); + if (ref !== void 0 && ref.deref() === void 0) { + this[kClients].delete(key); + } + } + ); + const agent = this; + this[kOnDrain] = (origin, targets) => { + agent.emit("drain", origin, [agent, ...targets]); + }; + this[kOnConnect] = (origin, targets) => { + agent.emit("connect", origin, [agent, ...targets]); + }; + this[kOnDisconnect] = (origin, targets, err) => { + agent.emit("disconnect", origin, [agent, ...targets], err); + }; + this[kOnConnectionError] = (origin, targets, err) => { + agent.emit("connectionError", origin, [agent, ...targets], err); + }; + } + get [kRunning]() { + let ret = 0; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + ret += client[kRunning]; + } + } + return ret; + } + [kDispatch](opts, handler) { + let key; + if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) { + key = String(opts.origin); + } else { + throw new InvalidArgumentError("opts.origin must be a non-empty string or URL."); + } + const ref = this[kClients].get(key); + let dispatcher = ref ? ref.deref() : null; + if (!dispatcher) { + dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]); + this[kClients].set(key, new WeakRef2(dispatcher)); + this[kFinalizer].register(dispatcher, key); + } + return dispatcher.dispatch(opts, handler); + } + async [kClose]() { + const closePromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + closePromises.push(client.close()); + } + } + await Promise.all(closePromises); + } + async [kDestroy](err) { + const destroyPromises = []; + for (const ref of this[kClients].values()) { + const client = ref.deref(); + if (client) { + destroyPromises.push(client.destroy(err)); + } + } + await Promise.all(destroyPromises); + } + }; + module2.exports = Agent; + } +}); + +// node_modules/undici/lib/api/readable.js +var require_readable = __commonJS({ + "node_modules/undici/lib/api/readable.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { Readable } = require("stream"); + var { RequestAbortedError, NotSupportedError, InvalidArgumentError } = require_errors(); + var util = require_util(); + var { ReadableStreamFrom: ReadableStreamFrom3, toUSVString } = require_util(); + var Blob2; + var kConsume = Symbol("kConsume"); + var kReading = Symbol("kReading"); + var kBody = Symbol("kBody"); + var kAbort = Symbol("abort"); + var kContentType = Symbol("kContentType"); + var noop3 = () => { + }; + module2.exports = class BodyReadable extends Readable { + constructor({ + resume, + abort, + contentType = "", + highWaterMark = 64 * 1024 + // Same as nodejs fs streams. + }) { + super({ + autoDestroy: true, + read: resume, + highWaterMark + }); + this._readableState.dataEmitted = false; + this[kAbort] = abort; + this[kConsume] = null; + this[kBody] = null; + this[kContentType] = contentType; + this[kReading] = false; + } + destroy(err) { + if (this.destroyed) { + return this; + } + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (err) { + this[kAbort](); + } + return super.destroy(err); + } + emit(ev, ...args) { + if (ev === "data") { + this._readableState.dataEmitted = true; + } else if (ev === "error") { + this._readableState.errorEmitted = true; + } + return super.emit(ev, ...args); + } + on(ev, ...args) { + if (ev === "data" || ev === "readable") { + this[kReading] = true; + } + return super.on(ev, ...args); + } + addListener(ev, ...args) { + return this.on(ev, ...args); + } + off(ev, ...args) { + const ret = super.off(ev, ...args); + if (ev === "data" || ev === "readable") { + this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0; + } + return ret; + } + removeListener(ev, ...args) { + return this.off(ev, ...args); + } + push(chunk) { + if (this[kConsume] && chunk !== null && this.readableLength === 0) { + consumePush(this[kConsume], chunk); + return this[kReading] ? super.push(chunk) : true; + } + return super.push(chunk); + } + // https://fetch.spec.whatwg.org/#dom-body-text + async text() { + return consume(this, "text"); + } + // https://fetch.spec.whatwg.org/#dom-body-json + async json() { + return consume(this, "json"); + } + // https://fetch.spec.whatwg.org/#dom-body-blob + async blob() { + return consume(this, "blob"); + } + // https://fetch.spec.whatwg.org/#dom-body-arraybuffer + async arrayBuffer() { + return consume(this, "arrayBuffer"); + } + // https://fetch.spec.whatwg.org/#dom-body-formdata + async formData() { + throw new NotSupportedError(); + } + // https://fetch.spec.whatwg.org/#dom-body-bodyused + get bodyUsed() { + return util.isDisturbed(this); + } + // https://fetch.spec.whatwg.org/#dom-body-body + get body() { + if (!this[kBody]) { + this[kBody] = ReadableStreamFrom3(this); + if (this[kConsume]) { + this[kBody].getReader(); + assert(this[kBody].locked); + } + } + return this[kBody]; + } + dump(opts) { + let limit3 = opts && Number.isFinite(opts.limit) ? opts.limit : 262144; + const signal = opts && opts.signal; + if (signal) { + try { + if (typeof signal !== "object" || !("aborted" in signal)) { + throw new InvalidArgumentError("signal must be an AbortSignal"); + } + util.throwIfAborted(signal); + } catch (err) { + return Promise.reject(err); + } + } + if (this.closed) { + return Promise.resolve(null); + } + return new Promise((resolve, reject) => { + const signalListenerCleanup = signal ? util.addAbortListener(signal, () => { + this.destroy(); + }) : noop3; + this.on("close", function() { + signalListenerCleanup(); + if (signal && signal.aborted) { + reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" })); + } else { + resolve(null); + } + }).on("error", noop3).on("data", function(chunk) { + limit3 -= chunk.length; + if (limit3 <= 0) { + this.destroy(); + } + }).resume(); + }); + } + }; + function isLocked(self2) { + return self2[kBody] && self2[kBody].locked === true || self2[kConsume]; + } + function isUnusable(self2) { + return util.isDisturbed(self2) || isLocked(self2); + } + async function consume(stream, type) { + if (isUnusable(stream)) { + throw new TypeError("unusable"); + } + assert(!stream[kConsume]); + return new Promise((resolve, reject) => { + stream[kConsume] = { + type, + stream, + resolve, + reject, + length: 0, + body: [] + }; + stream.on("error", function(err) { + consumeFinish(this[kConsume], err); + }).on("close", function() { + if (this[kConsume].body !== null) { + consumeFinish(this[kConsume], new RequestAbortedError()); + } + }); + process.nextTick(consumeStart, stream[kConsume]); + }); + } + function consumeStart(consume2) { + if (consume2.body === null) { + return; + } + const { _readableState: state } = consume2.stream; + for (const chunk of state.buffer) { + consumePush(consume2, chunk); + } + if (state.endEmitted) { + consumeEnd(this[kConsume]); + } else { + consume2.stream.on("end", function() { + consumeEnd(this[kConsume]); + }); + } + consume2.stream.resume(); + while (consume2.stream.read() != null) { + } + } + function consumeEnd(consume2) { + const { type, body, resolve, stream, length } = consume2; + try { + if (type === "text") { + resolve(toUSVString(Buffer.concat(body))); + } else if (type === "json") { + resolve(JSON.parse(Buffer.concat(body))); + } else if (type === "arrayBuffer") { + const dst = new Uint8Array(length); + let pos = 0; + for (const buf of body) { + dst.set(buf, pos); + pos += buf.byteLength; + } + resolve(dst.buffer); + } else if (type === "blob") { + if (!Blob2) { + Blob2 = require("buffer").Blob; + } + resolve(new Blob2(body, { type: stream[kContentType] })); + } + consumeFinish(consume2); + } catch (err) { + stream.destroy(err); + } + } + function consumePush(consume2, chunk) { + consume2.length += chunk.length; + consume2.body.push(chunk); + } + function consumeFinish(consume2, err) { + if (consume2.body === null) { + return; + } + if (err) { + consume2.reject(err); + } else { + consume2.resolve(); + } + consume2.type = null; + consume2.stream = null; + consume2.resolve = null; + consume2.reject = null; + consume2.length = 0; + consume2.body = null; + } + } +}); + +// node_modules/undici/lib/api/util.js +var require_util3 = __commonJS({ + "node_modules/undici/lib/api/util.js"(exports2, module2) { + var assert = require("assert"); + var { + ResponseStatusCodeError + } = require_errors(); + var { toUSVString } = require_util(); + async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) { + assert(body); + let chunks = []; + let limit3 = 0; + for await (const chunk of body) { + chunks.push(chunk); + limit3 += chunk.length; + if (limit3 > 128 * 1024) { + chunks = null; + break; + } + } + if (statusCode === 204 || !contentType || !chunks) { + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + return; + } + try { + if (contentType.startsWith("application/json")) { + const payload = JSON.parse(toUSVString(Buffer.concat(chunks))); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + if (contentType.startsWith("text/")) { + const payload = toUSVString(Buffer.concat(chunks)); + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload)); + return; + } + } catch (err) { + } + process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers)); + } + module2.exports = { getResolveErrorBodyCallback }; + } +}); + +// node_modules/undici/lib/api/abort-signal.js +var require_abort_signal = __commonJS({ + "node_modules/undici/lib/api/abort-signal.js"(exports2, module2) { + var { addAbortListener } = require_util(); + var { RequestAbortedError } = require_errors(); + var kListener = Symbol("kListener"); + var kSignal = Symbol("kSignal"); + function abort(self2) { + if (self2.abort) { + self2.abort(); + } else { + self2.onError(new RequestAbortedError()); + } + } + function addSignal(self2, signal) { + self2[kSignal] = null; + self2[kListener] = null; + if (!signal) { + return; + } + if (signal.aborted) { + abort(self2); + return; + } + self2[kSignal] = signal; + self2[kListener] = () => { + abort(self2); + }; + addAbortListener(self2[kSignal], self2[kListener]); + } + function removeSignal(self2) { + if (!self2[kSignal]) { + return; + } + if ("removeEventListener" in self2[kSignal]) { + self2[kSignal].removeEventListener("abort", self2[kListener]); + } else { + self2[kSignal].removeListener("abort", self2[kListener]); + } + self2[kSignal] = null; + self2[kListener] = null; + } + module2.exports = { + addSignal, + removeSignal + }; + } +}); + +// node_modules/undici/lib/api/api-request.js +var require_api_request = __commonJS({ + "node_modules/undici/lib/api/api-request.js"(exports2, module2) { + "use strict"; + var Readable = require_readable(); + var { + InvalidArgumentError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var RequestHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) { + throw new InvalidArgumentError("invalid highWaterMark"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_REQUEST"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.res = null; + this.abort = null; + this.body = body; + this.trailers = {}; + this.context = null; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError; + this.highWaterMark = highWaterMark; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context3) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context3; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { callback, opaque, abort, context: context3, responseHeaders, highWaterMark } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + const body = new Readable({ resume, abort, contentType, highWaterMark }); + this.callback = null; + this.res = body; + if (callback !== null) { + if (this.throwOnError && statusCode >= 400) { + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body, contentType, statusCode, statusMessage, headers } + ); + } else { + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + trailers: this.trailers, + opaque, + body, + context: context3 + }); + } + } + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + util.parseHeaders(trailers, this.trailers); + res.push(null); + } + onError(err) { + const { res, callback, body, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (res) { + this.res = null; + queueMicrotask(() => { + util.destroy(res, err); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function request(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + request.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + this.dispatch(opts, new RequestHandler(opts, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = request; + module2.exports.RequestHandler = RequestHandler; + } +}); + +// node_modules/undici/lib/api/api-stream.js +var require_api_stream = __commonJS({ + "node_modules/undici/lib/api/api-stream.js"(exports2, module2) { + "use strict"; + var { finished, PassThrough } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { getResolveErrorBodyCallback } = require_util3(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var StreamHandler = class extends AsyncResource { + constructor(opts, factory, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts; + try { + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + if (typeof factory !== "function") { + throw new InvalidArgumentError("invalid factory"); + } + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_STREAM"); + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on("error", util.nop), err); + } + throw err; + } + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.factory = factory; + this.callback = callback; + this.res = null; + this.abort = null; + this.context = null; + this.trailers = null; + this.body = body; + this.onInfo = onInfo || null; + this.throwOnError = throwOnError || false; + if (util.isStream(body)) { + body.on("error", (err) => { + this.onError(err); + }); + } + addSignal(this, signal); + } + onConnect(abort, context3) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context3; + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const { factory, opaque, context: context3, callback, responseHeaders } = this; + const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }); + } + return; + } + this.factory = null; + let res; + if (this.throwOnError && statusCode >= 400) { + const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers; + const contentType = parsedHeaders["content-type"]; + res = new PassThrough(); + this.callback = null; + this.runInAsyncScope( + getResolveErrorBodyCallback, + null, + { callback, body: res, contentType, statusCode, statusMessage, headers } + ); + } else { + if (factory === null) { + return; + } + res = this.runInAsyncScope(factory, null, { + statusCode, + headers, + opaque, + context: context3 + }); + if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") { + throw new InvalidReturnValueError("expected Writable"); + } + finished(res, { readable: false }, (err) => { + const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this; + this.res = null; + if (err || !res2.readable) { + util.destroy(res2, err); + } + this.callback = null; + this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers }); + if (err) { + abort(); + } + }); + } + res.on("drain", resume); + this.res = res; + const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain; + return needDrain !== true; + } + onData(chunk) { + const { res } = this; + return res ? res.write(chunk) : true; + } + onComplete(trailers) { + const { res } = this; + removeSignal(this); + if (!res) { + return; + } + this.trailers = util.parseHeaders(trailers); + res.end(); + } + onError(err) { + const { res, callback, opaque, body } = this; + removeSignal(this); + this.factory = null; + if (res) { + this.res = null; + util.destroy(res, err); + } else if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + if (body) { + this.body = null; + util.destroy(body, err); + } + } + }; + function stream(opts, factory, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + stream.call(this, opts, factory, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + this.dispatch(opts, new StreamHandler(opts, factory, callback)); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = stream; + } +}); + +// node_modules/undici/lib/api/api-pipeline.js +var require_api_pipeline = __commonJS({ + "node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) { + "use strict"; + var { + Readable, + Duplex, + PassThrough + } = require("stream"); + var { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError + } = require_errors(); + var util = require_util(); + var { AsyncResource } = require("async_hooks"); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var kResume = Symbol("resume"); + var PipelineRequest = class extends Readable { + constructor() { + super({ autoDestroy: true }); + this[kResume] = null; + } + _read() { + const { [kResume]: resume } = this; + if (resume) { + this[kResume] = null; + resume(); + } + } + _destroy(err, callback) { + this._read(); + callback(err); + } + }; + var PipelineResponse = class extends Readable { + constructor(resume) { + super({ autoDestroy: true }); + this[kResume] = resume; + } + _read() { + this[kResume](); + } + _destroy(err, callback) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError(); + } + callback(err); + } + }; + var PipelineHandler = class extends AsyncResource { + constructor(opts, handler) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof handler !== "function") { + throw new InvalidArgumentError("invalid handler"); + } + const { signal, method, opaque, onInfo, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + if (method === "CONNECT") { + throw new InvalidArgumentError("invalid method"); + } + if (onInfo && typeof onInfo !== "function") { + throw new InvalidArgumentError("invalid onInfo callback"); + } + super("UNDICI_PIPELINE"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.handler = handler; + this.abort = null; + this.context = null; + this.onInfo = onInfo || null; + this.req = new PipelineRequest().on("error", util.nop); + this.ret = new Duplex({ + readableObjectMode: opts.objectMode, + autoDestroy: true, + read: () => { + const { body } = this; + if (body && body.resume) { + body.resume(); + } + }, + write: (chunk, encoding, callback) => { + const { req } = this; + if (req.push(chunk, encoding) || req._readableState.destroyed) { + callback(); + } else { + req[kResume] = callback; + } + }, + destroy: (err, callback) => { + const { body, req, res, ret, abort } = this; + if (!err && !ret._readableState.endEmitted) { + err = new RequestAbortedError(); + } + if (abort && err) { + abort(); + } + util.destroy(body, err); + util.destroy(req, err); + util.destroy(res, err); + removeSignal(this); + callback(err); + } + }).on("prefinish", () => { + const { req } = this; + req.push(null); + }); + this.res = null; + addSignal(this, signal); + } + onConnect(abort, context3) { + const { ret, res } = this; + assert(!res, "pipeline cannot be retried"); + if (ret.destroyed) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context3; + } + onHeaders(statusCode, rawHeaders, resume) { + const { opaque, handler, context: context3 } = this; + if (statusCode < 200) { + if (this.onInfo) { + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.onInfo({ statusCode, headers }); + } + return; + } + this.res = new PipelineResponse(resume); + let body; + try { + this.handler = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + body = this.runInAsyncScope(handler, null, { + statusCode, + headers, + opaque, + body: this.res, + context: context3 + }); + } catch (err) { + this.res.on("error", util.nop); + throw err; + } + if (!body || typeof body.on !== "function") { + throw new InvalidReturnValueError("expected Readable"); + } + body.on("data", (chunk) => { + const { ret, body: body2 } = this; + if (!ret.push(chunk) && body2.pause) { + body2.pause(); + } + }).on("error", (err) => { + const { ret } = this; + util.destroy(ret, err); + }).on("end", () => { + const { ret } = this; + ret.push(null); + }).on("close", () => { + const { ret } = this; + if (!ret._readableState.ended) { + util.destroy(ret, new RequestAbortedError()); + } + }); + this.body = body; + } + onData(chunk) { + const { res } = this; + return res.push(chunk); + } + onComplete(trailers) { + const { res } = this; + res.push(null); + } + onError(err) { + const { ret } = this; + this.handler = null; + util.destroy(ret, err); + } + }; + function pipeline(opts, handler) { + try { + const pipelineHandler = new PipelineHandler(opts, handler); + this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler); + return pipelineHandler.ret; + } catch (err) { + return new PassThrough().destroy(err); + } + } + module2.exports = pipeline; + } +}); + +// node_modules/undici/lib/api/api-upgrade.js +var require_api_upgrade = __commonJS({ + "node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) { + "use strict"; + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors(); + var { AsyncResource } = require("async_hooks"); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var assert = require("assert"); + var UpgradeHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_UPGRADE"); + this.responseHeaders = responseHeaders || null; + this.opaque = opaque || null; + this.callback = callback; + this.abort = null; + this.context = null; + addSignal(this, signal); + } + onConnect(abort, context3) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = null; + } + onHeaders() { + throw new SocketError("bad upgrade", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context: context3 } = this; + assert.strictEqual(statusCode, 101); + removeSignal(this); + this.callback = null; + const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + this.runInAsyncScope(callback, null, null, { + headers, + socket, + opaque, + context: context3 + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function upgrade(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + upgrade.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const upgradeHandler = new UpgradeHandler(opts, callback); + this.dispatch({ + ...opts, + method: opts.method || "GET", + upgrade: opts.protocol || "Websocket" + }, upgradeHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = upgrade; + } +}); + +// node_modules/undici/lib/api/api-connect.js +var require_api_connect = __commonJS({ + "node_modules/undici/lib/api/api-connect.js"(exports2, module2) { + "use strict"; + var { AsyncResource } = require("async_hooks"); + var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors(); + var util = require_util(); + var { addSignal, removeSignal } = require_abort_signal(); + var ConnectHandler = class extends AsyncResource { + constructor(opts, callback) { + if (!opts || typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (typeof callback !== "function") { + throw new InvalidArgumentError("invalid callback"); + } + const { signal, opaque, responseHeaders } = opts; + if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { + throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget"); + } + super("UNDICI_CONNECT"); + this.opaque = opaque || null; + this.responseHeaders = responseHeaders || null; + this.callback = callback; + this.abort = null; + addSignal(this, signal); + } + onConnect(abort, context3) { + if (!this.callback) { + throw new RequestAbortedError(); + } + this.abort = abort; + this.context = context3; + } + onHeaders() { + throw new SocketError("bad connect", null); + } + onUpgrade(statusCode, rawHeaders, socket) { + const { callback, opaque, context: context3 } = this; + removeSignal(this); + this.callback = null; + let headers = rawHeaders; + if (headers != null) { + headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); + } + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + socket, + opaque, + context: context3 + }); + } + onError(err) { + const { callback, opaque } = this; + removeSignal(this); + if (callback) { + this.callback = null; + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }); + }); + } + } + }; + function connect(opts, callback) { + if (callback === void 0) { + return new Promise((resolve, reject) => { + connect.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data); + }); + }); + } + try { + const connectHandler = new ConnectHandler(opts, callback); + this.dispatch({ ...opts, method: "CONNECT" }, connectHandler); + } catch (err) { + if (typeof callback !== "function") { + throw err; + } + const opaque = opts && opts.opaque; + queueMicrotask(() => callback(err, { opaque })); + } + } + module2.exports = connect; + } +}); + +// node_modules/undici/lib/api/index.js +var require_api = __commonJS({ + "node_modules/undici/lib/api/index.js"(exports2, module2) { + "use strict"; + module2.exports.request = require_api_request(); + module2.exports.stream = require_api_stream(); + module2.exports.pipeline = require_api_pipeline(); + module2.exports.upgrade = require_api_upgrade(); + module2.exports.connect = require_api_connect(); + } +}); + +// node_modules/undici/lib/mock/mock-errors.js +var require_mock_errors = __commonJS({ + "node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) { + "use strict"; + var { UndiciError } = require_errors(); + var MockNotMatchedError = class _MockNotMatchedError extends UndiciError { + constructor(message) { + super(message); + Error.captureStackTrace(this, _MockNotMatchedError); + this.name = "MockNotMatchedError"; + this.message = message || "The request does not match any registered mock dispatches"; + this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED"; + } + }; + module2.exports = { + MockNotMatchedError + }; + } +}); + +// node_modules/undici/lib/mock/mock-symbols.js +var require_mock_symbols = __commonJS({ + "node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kAgent: Symbol("agent"), + kOptions: Symbol("options"), + kFactory: Symbol("factory"), + kDispatches: Symbol("dispatches"), + kDispatchKey: Symbol("dispatch key"), + kDefaultHeaders: Symbol("default headers"), + kDefaultTrailers: Symbol("default trailers"), + kContentLength: Symbol("content length"), + kMockAgent: Symbol("mock agent"), + kMockAgentSet: Symbol("mock agent set"), + kMockAgentGet: Symbol("mock agent get"), + kMockDispatch: Symbol("mock dispatch"), + kClose: Symbol("close"), + kOriginalClose: Symbol("original agent close"), + kOrigin: Symbol("origin"), + kIsMockActive: Symbol("is mock active"), + kNetConnect: Symbol("net connect"), + kGetNetConnect: Symbol("get net connect"), + kConnected: Symbol("connected") + }; + } +}); + +// node_modules/undici/lib/mock/mock-utils.js +var require_mock_utils = __commonJS({ + "node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) { + "use strict"; + var { MockNotMatchedError } = require_mock_errors(); + var { + kDispatches, + kMockAgent, + kOriginalDispatch, + kOrigin, + kGetNetConnect + } = require_mock_symbols(); + var { buildURL, nop } = require_util(); + var { STATUS_CODES } = require("http"); + var { + types: { + isPromise + } + } = require("util"); + function matchValue(match, value) { + if (typeof match === "string") { + return match === value; + } + if (match instanceof RegExp) { + return match.test(value); + } + if (typeof match === "function") { + return match(value) === true; + } + return false; + } + function lowerCaseEntries(headers) { + return Object.fromEntries( + Object.entries(headers).map(([headerName, headerValue]) => { + return [headerName.toLocaleLowerCase(), headerValue]; + }) + ); + } + function getHeaderByName(headers, key) { + if (Array.isArray(headers)) { + for (let i = 0; i < headers.length; i += 2) { + if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) { + return headers[i + 1]; + } + } + return void 0; + } else if (typeof headers.get === "function") { + return headers.get(key); + } else { + return lowerCaseEntries(headers)[key.toLocaleLowerCase()]; + } + } + function buildHeadersFromArray(headers) { + const clone = headers.slice(); + const entries = []; + for (let index = 0; index < clone.length; index += 2) { + entries.push([clone[index], clone[index + 1]]); + } + return Object.fromEntries(entries); + } + function matchHeaders(mockDispatch2, headers) { + if (typeof mockDispatch2.headers === "function") { + if (Array.isArray(headers)) { + headers = buildHeadersFromArray(headers); + } + return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {}); + } + if (typeof mockDispatch2.headers === "undefined") { + return true; + } + if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") { + return false; + } + for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) { + const headerValue = getHeaderByName(headers, matchHeaderName); + if (!matchValue(matchHeaderValue, headerValue)) { + return false; + } + } + return true; + } + function safeUrl(path3) { + if (typeof path3 !== "string") { + return path3; + } + const pathSegments = path3.split("?"); + if (pathSegments.length !== 2) { + return path3; + } + const qp = new URLSearchParams(pathSegments.pop()); + qp.sort(); + return [...pathSegments, qp.toString()].join("?"); + } + function matchKey(mockDispatch2, { path: path3, method, body, headers }) { + const pathMatch = matchValue(mockDispatch2.path, path3); + const methodMatch = matchValue(mockDispatch2.method, method); + const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true; + const headersMatch = matchHeaders(mockDispatch2, headers); + return pathMatch && methodMatch && bodyMatch && headersMatch; + } + function getResponseData(data) { + if (Buffer.isBuffer(data)) { + return data; + } else if (typeof data === "object") { + return JSON.stringify(data); + } else { + return data.toString(); + } + } + function getMockDispatch(mockDispatches, key) { + const basePath = key.query ? buildURL(key.path, key.query) : key.path; + const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath; + let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path3 }) => matchValue(safeUrl(path3), resolvedPath)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`); + } + matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`); + } + matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers)); + if (matchedMockDispatches.length === 0) { + throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`); + } + return matchedMockDispatches[0]; + } + function addMockDispatch(mockDispatches, key, data) { + const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false }; + const replyData = typeof data === "function" ? { callback: data } : { ...data }; + const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } }; + mockDispatches.push(newMockDispatch); + return newMockDispatch; + } + function deleteMockDispatch(mockDispatches, key) { + const index = mockDispatches.findIndex((dispatch) => { + if (!dispatch.consumed) { + return false; + } + return matchKey(dispatch, key); + }); + if (index !== -1) { + mockDispatches.splice(index, 1); + } + } + function buildKey(opts) { + const { path: path3, method, body, headers, query } = opts; + return { + path: path3, + method, + body, + headers, + query + }; + } + function generateKeyValues(data) { + return Object.entries(data).reduce((keyValuePairs, [key, value]) => [ + ...keyValuePairs, + Buffer.from(`${key}`), + Array.isArray(value) ? value.map((x) => Buffer.from(`${x}`)) : Buffer.from(`${value}`) + ], []); + } + function getStatusText(statusCode) { + return STATUS_CODES[statusCode] || "unknown"; + } + async function getResponse(body) { + const buffers = []; + for await (const data of body) { + buffers.push(data); + } + return Buffer.concat(buffers).toString("utf8"); + } + function mockDispatch(opts, handler) { + const key = buildKey(opts); + const mockDispatch2 = getMockDispatch(this[kDispatches], key); + mockDispatch2.timesInvoked++; + if (mockDispatch2.data.callback) { + mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) }; + } + const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2; + const { timesInvoked, times } = mockDispatch2; + mockDispatch2.consumed = !persist && timesInvoked >= times; + mockDispatch2.pending = timesInvoked < times; + if (error !== null) { + deleteMockDispatch(this[kDispatches], key); + handler.onError(error); + return true; + } + if (typeof delay === "number" && delay > 0) { + setTimeout(() => { + handleReply(this[kDispatches]); + }, delay); + } else { + handleReply(this[kDispatches]); + } + function handleReply(mockDispatches, _data = data) { + const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers; + const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data; + if (isPromise(body)) { + body.then((newData) => handleReply(mockDispatches, newData)); + return; + } + const responseData = getResponseData(body); + const responseHeaders = generateKeyValues(headers); + const responseTrailers = generateKeyValues(trailers); + handler.abort = nop; + handler.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode)); + handler.onData(Buffer.from(responseData)); + handler.onComplete(responseTrailers); + deleteMockDispatch(mockDispatches, key); + } + function resume() { + } + return true; + } + function buildMockDispatch() { + const agent = this[kMockAgent]; + const origin = this[kOrigin]; + const originalDispatch = this[kOriginalDispatch]; + return function dispatch(opts, handler) { + if (agent.isMockActive) { + try { + mockDispatch.call(this, opts, handler); + } catch (error) { + if (error instanceof MockNotMatchedError) { + const netConnect = agent[kGetNetConnect](); + if (netConnect === false) { + throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`); + } + if (checkNetConnect(netConnect, origin)) { + originalDispatch.call(this, opts, handler); + } else { + throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`); + } + } else { + throw error; + } + } + } else { + originalDispatch.call(this, opts, handler); + } + }; + } + function checkNetConnect(netConnect, origin) { + const url = new URL(origin); + if (netConnect === true) { + return true; + } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) { + return true; + } + return false; + } + function buildMockOptions(opts) { + if (opts) { + const { agent, ...mockOptions } = opts; + return mockOptions; + } + } + module2.exports = { + getResponseData, + getMockDispatch, + addMockDispatch, + deleteMockDispatch, + buildKey, + generateKeyValues, + matchValue, + getResponse, + getStatusText, + mockDispatch, + buildMockDispatch, + checkNetConnect, + buildMockOptions, + getHeaderByName + }; + } +}); + +// node_modules/undici/lib/mock/mock-interceptor.js +var require_mock_interceptor = __commonJS({ + "node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) { + "use strict"; + var { getResponseData, buildKey, addMockDispatch } = require_mock_utils(); + var { + kDispatches, + kDispatchKey, + kDefaultHeaders, + kDefaultTrailers, + kContentLength, + kMockDispatch + } = require_mock_symbols(); + var { InvalidArgumentError } = require_errors(); + var { buildURL } = require_util(); + var MockScope = class { + constructor(mockDispatch) { + this[kMockDispatch] = mockDispatch; + } + /** + * Delay a reply by a set amount in ms. + */ + delay(waitInMs) { + if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) { + throw new InvalidArgumentError("waitInMs must be a valid integer > 0"); + } + this[kMockDispatch].delay = waitInMs; + return this; + } + /** + * For a defined reply, never mark as consumed. + */ + persist() { + this[kMockDispatch].persist = true; + return this; + } + /** + * Allow one to define a reply for a set amount of matching requests. + */ + times(repeatTimes) { + if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) { + throw new InvalidArgumentError("repeatTimes must be a valid integer > 0"); + } + this[kMockDispatch].times = repeatTimes; + return this; + } + }; + var MockInterceptor = class { + constructor(opts, mockDispatches) { + if (typeof opts !== "object") { + throw new InvalidArgumentError("opts must be an object"); + } + if (typeof opts.path === "undefined") { + throw new InvalidArgumentError("opts.path must be defined"); + } + if (typeof opts.method === "undefined") { + opts.method = "GET"; + } + if (typeof opts.path === "string") { + if (opts.query) { + opts.path = buildURL(opts.path, opts.query); + } else { + const parsedURL = new URL(opts.path, "data://"); + opts.path = parsedURL.pathname + parsedURL.search; + } + } + if (typeof opts.method === "string") { + opts.method = opts.method.toUpperCase(); + } + this[kDispatchKey] = buildKey(opts); + this[kDispatches] = mockDispatches; + this[kDefaultHeaders] = {}; + this[kDefaultTrailers] = {}; + this[kContentLength] = false; + } + createMockScopeDispatchData(statusCode, data, responseOptions = {}) { + const responseData = getResponseData(data); + const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {}; + const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }; + const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }; + return { statusCode, data, headers, trailers }; + } + validateReplyParameters(statusCode, data, responseOptions) { + if (typeof statusCode === "undefined") { + throw new InvalidArgumentError("statusCode must be defined"); + } + if (typeof data === "undefined") { + throw new InvalidArgumentError("data must be defined"); + } + if (typeof responseOptions !== "object") { + throw new InvalidArgumentError("responseOptions must be an object"); + } + } + /** + * Mock an undici request with a defined reply. + */ + reply(replyData) { + if (typeof replyData === "function") { + const wrappedDefaultsCallback = (opts) => { + const resolvedData = replyData(opts); + if (typeof resolvedData !== "object") { + throw new InvalidArgumentError("reply options callback must return an object"); + } + const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData; + this.validateReplyParameters(statusCode2, data2, responseOptions2); + return { + ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2) + }; + }; + const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback); + return new MockScope(newMockDispatch2); + } + const [statusCode, data = "", responseOptions = {}] = [...arguments]; + this.validateReplyParameters(statusCode, data, responseOptions); + const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions); + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData); + return new MockScope(newMockDispatch); + } + /** + * Mock an undici request with a defined error. + */ + replyWithError(error) { + if (typeof error === "undefined") { + throw new InvalidArgumentError("error must be defined"); + } + const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error }); + return new MockScope(newMockDispatch); + } + /** + * Set default reply headers on the interceptor for subsequent replies + */ + defaultReplyHeaders(headers) { + if (typeof headers === "undefined") { + throw new InvalidArgumentError("headers must be defined"); + } + this[kDefaultHeaders] = headers; + return this; + } + /** + * Set default reply trailers on the interceptor for subsequent replies + */ + defaultReplyTrailers(trailers) { + if (typeof trailers === "undefined") { + throw new InvalidArgumentError("trailers must be defined"); + } + this[kDefaultTrailers] = trailers; + return this; + } + /** + * Set reply content length header for replies on the interceptor + */ + replyContentLength() { + this[kContentLength] = true; + return this; + } + }; + module2.exports.MockInterceptor = MockInterceptor; + module2.exports.MockScope = MockScope; + } +}); + +// node_modules/undici/lib/mock/mock-client.js +var require_mock_client = __commonJS({ + "node_modules/undici/lib/mock/mock-client.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Client = require_client(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockClient = class extends Client { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockClient; + } +}); + +// node_modules/undici/lib/mock/mock-pool.js +var require_mock_pool = __commonJS({ + "node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) { + "use strict"; + var { promisify } = require("util"); + var Pool = require_pool(); + var { buildMockDispatch } = require_mock_utils(); + var { + kDispatches, + kMockAgent, + kClose, + kOriginalClose, + kOrigin, + kOriginalDispatch, + kConnected + } = require_mock_symbols(); + var { MockInterceptor } = require_mock_interceptor(); + var Symbols = require_symbols(); + var { InvalidArgumentError } = require_errors(); + var MockPool = class extends Pool { + constructor(origin, opts) { + super(origin, opts); + if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + this[kMockAgent] = opts.agent; + this[kOrigin] = origin; + this[kDispatches] = []; + this[kConnected] = 1; + this[kOriginalDispatch] = this.dispatch; + this[kOriginalClose] = this.close.bind(this); + this.dispatch = buildMockDispatch.call(this); + this.close = this[kClose]; + } + get [Symbols.kConnected]() { + return this[kConnected]; + } + /** + * Sets up the base interceptor for mocking replies from undici. + */ + intercept(opts) { + return new MockInterceptor(opts, this[kDispatches]); + } + async [kClose]() { + await promisify(this[kOriginalClose])(); + this[kConnected] = 0; + this[kMockAgent][Symbols.kClients].delete(this[kOrigin]); + } + }; + module2.exports = MockPool; + } +}); + +// node_modules/undici/lib/mock/pluralizer.js +var require_pluralizer = __commonJS({ + "node_modules/undici/lib/mock/pluralizer.js"(exports2, module2) { + "use strict"; + var singulars = { + pronoun: "it", + is: "is", + was: "was", + this: "this" + }; + var plurals = { + pronoun: "they", + is: "are", + was: "were", + this: "these" + }; + module2.exports = class Pluralizer { + constructor(singular, plural) { + this.singular = singular; + this.plural = plural; + } + pluralize(count) { + const one = count === 1; + const keys = one ? singulars : plurals; + const noun = one ? this.singular : this.plural; + return { ...keys, count, noun }; + } + }; + } +}); + +// node_modules/undici/lib/mock/pending-interceptors-formatter.js +var require_pending_interceptors_formatter = __commonJS({ + "node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module2) { + "use strict"; + var { Transform } = require("stream"); + var { Console } = require("console"); + module2.exports = class PendingInterceptorsFormatter { + constructor({ disableColors } = {}) { + this.transform = new Transform({ + transform(chunk, _enc, cb) { + cb(null, chunk); + } + }); + this.logger = new Console({ + stdout: this.transform, + inspectOptions: { + colors: !disableColors && !process.env.CI + } + }); + } + format(pendingInterceptors) { + const withPrettyHeaders = pendingInterceptors.map( + ({ method, path: path3, data: { statusCode }, persist, times, timesInvoked, origin }) => ({ + Method: method, + Origin: origin, + Path: path3, + "Status code": statusCode, + Persistent: persist ? "\u2705" : "\u274C", + Invocations: timesInvoked, + Remaining: persist ? Infinity : times - timesInvoked + }) + ); + this.logger.table(withPrettyHeaders); + return this.transform.read().toString(); + } + }; + } +}); + +// node_modules/undici/lib/mock/mock-agent.js +var require_mock_agent = __commonJS({ + "node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) { + "use strict"; + var { kClients } = require_symbols(); + var Agent = require_agent(); + var { + kAgent, + kMockAgentSet, + kMockAgentGet, + kDispatches, + kIsMockActive, + kNetConnect, + kGetNetConnect, + kOptions, + kFactory + } = require_mock_symbols(); + var MockClient = require_mock_client(); + var MockPool = require_mock_pool(); + var { matchValue, buildMockOptions } = require_mock_utils(); + var { InvalidArgumentError, UndiciError } = require_errors(); + var Dispatcher = require_dispatcher(); + var Pluralizer = require_pluralizer(); + var PendingInterceptorsFormatter = require_pending_interceptors_formatter(); + var FakeWeakRef = class { + constructor(value) { + this.value = value; + } + deref() { + return this.value; + } + }; + var MockAgent = class extends Dispatcher { + constructor(opts) { + super(opts); + this[kNetConnect] = true; + this[kIsMockActive] = true; + if (opts && opts.agent && typeof opts.agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument opts.agent must implement Agent"); + } + const agent = opts && opts.agent ? opts.agent : new Agent(opts); + this[kAgent] = agent; + this[kClients] = agent[kClients]; + this[kOptions] = buildMockOptions(opts); + } + get(origin) { + let dispatcher = this[kMockAgentGet](origin); + if (!dispatcher) { + dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + } + return dispatcher; + } + dispatch(opts, handler) { + this.get(opts.origin); + return this[kAgent].dispatch(opts, handler); + } + async close() { + await this[kAgent].close(); + this[kClients].clear(); + } + deactivate() { + this[kIsMockActive] = false; + } + activate() { + this[kIsMockActive] = true; + } + enableNetConnect(matcher) { + if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) { + if (Array.isArray(this[kNetConnect])) { + this[kNetConnect].push(matcher); + } else { + this[kNetConnect] = [matcher]; + } + } else if (typeof matcher === "undefined") { + this[kNetConnect] = true; + } else { + throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp."); + } + } + disableNetConnect() { + this[kNetConnect] = false; + } + // This is required to bypass issues caused by using global symbols - see: + // https://github.com/nodejs/undici/issues/1447 + get isMockActive() { + return this[kIsMockActive]; + } + [kMockAgentSet](origin, dispatcher) { + this[kClients].set(origin, new FakeWeakRef(dispatcher)); + } + [kFactory](origin) { + const mockOptions = Object.assign({ agent: this }, this[kOptions]); + return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions); + } + [kMockAgentGet](origin) { + const ref = this[kClients].get(origin); + if (ref) { + return ref.deref(); + } + if (typeof origin !== "string") { + const dispatcher = this[kFactory]("http://localhost:9999"); + this[kMockAgentSet](origin, dispatcher); + return dispatcher; + } + for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) { + const nonExplicitDispatcher = nonExplicitRef.deref(); + if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) { + const dispatcher = this[kFactory](origin); + this[kMockAgentSet](origin, dispatcher); + dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]; + return dispatcher; + } + } + } + [kGetNetConnect]() { + return this[kNetConnect]; + } + pendingInterceptors() { + const mockAgentClients = this[kClients]; + return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending); + } + assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) { + const pending = this.pendingInterceptors(); + if (pending.length === 0) { + return; + } + const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length); + throw new UndiciError(` +${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending: + +${pendingInterceptorsFormatter.format(pending)} +`.trim()); + } + }; + module2.exports = MockAgent; + } +}); + +// node_modules/undici/lib/proxy-agent.js +var require_proxy_agent = __commonJS({ + "node_modules/undici/lib/proxy-agent.js"(exports2, module2) { + "use strict"; + var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols(); + var { URL: URL2 } = require("url"); + var Agent = require_agent(); + var Pool = require_pool(); + var DispatcherBase = require_dispatcher_base(); + var { InvalidArgumentError, RequestAbortedError } = require_errors(); + var buildConnector = require_connect(); + var kAgent = Symbol("proxy agent"); + var kClient = Symbol("proxy client"); + var kProxyHeaders = Symbol("proxy headers"); + var kRequestTls = Symbol("request tls settings"); + var kProxyTls = Symbol("proxy tls settings"); + var kConnectEndpoint = Symbol("connect endpoint function"); + function defaultProtocolPort(protocol) { + return protocol === "https:" ? 443 : 80; + } + function buildProxyOptions(opts) { + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + return { + uri: opts.uri, + protocol: opts.protocol || "https" + }; + } + function defaultFactory(origin, opts) { + return new Pool(origin, opts); + } + var ProxyAgent = class extends DispatcherBase { + constructor(opts) { + super(opts); + this[kProxy] = buildProxyOptions(opts); + this[kAgent] = new Agent(opts); + this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : []; + if (typeof opts === "string") { + opts = { uri: opts }; + } + if (!opts || !opts.uri) { + throw new InvalidArgumentError("Proxy opts.uri is mandatory"); + } + const { clientFactory = defaultFactory } = opts; + if (typeof clientFactory !== "function") { + throw new InvalidArgumentError("Proxy opts.clientFactory must be a function."); + } + this[kRequestTls] = opts.requestTls; + this[kProxyTls] = opts.proxyTls; + this[kProxyHeaders] = opts.headers || {}; + const resolvedUrl = new URL2(opts.uri); + const { origin, port, host, username, password } = resolvedUrl; + if (opts.auth && opts.token) { + throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token"); + } else if (opts.auth) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`; + } else if (opts.token) { + this[kProxyHeaders]["proxy-authorization"] = opts.token; + } else if (username && password) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`; + } + const connect = buildConnector({ ...opts.proxyTls }); + this[kConnectEndpoint] = buildConnector({ ...opts.requestTls }); + this[kClient] = clientFactory(resolvedUrl, { connect }); + this[kAgent] = new Agent({ + ...opts, + connect: async (opts2, callback) => { + let requestedHost = opts2.host; + if (!opts2.port) { + requestedHost += `:${defaultProtocolPort(opts2.protocol)}`; + } + try { + const { socket, statusCode } = await this[kClient].connect({ + origin, + port, + path: requestedHost, + signal: opts2.signal, + headers: { + ...this[kProxyHeaders], + host + } + }); + if (statusCode !== 200) { + socket.on("error", () => { + }).destroy(); + callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`)); + } + if (opts2.protocol !== "https:") { + callback(null, socket); + return; + } + let servername; + if (this[kRequestTls]) { + servername = this[kRequestTls].servername; + } else { + servername = opts2.servername; + } + this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback); + } catch (err) { + callback(err); + } + } + }); + } + dispatch(opts, handler) { + const { host } = new URL2(opts.origin); + const headers = buildHeaders3(opts.headers); + throwIfProxyAuthIsSent(headers); + return this[kAgent].dispatch( + { + ...opts, + headers: { + ...headers, + host + } + }, + handler + ); + } + async [kClose]() { + await this[kAgent].close(); + await this[kClient].close(); + } + async [kDestroy]() { + await this[kAgent].destroy(); + await this[kClient].destroy(); + } + }; + function buildHeaders3(headers) { + if (Array.isArray(headers)) { + const headersPair = {}; + for (let i = 0; i < headers.length; i += 2) { + headersPair[headers[i]] = headers[i + 1]; + } + return headersPair; + } + return headers; + } + function throwIfProxyAuthIsSent(headers) { + const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization"); + if (existProxyAuth) { + throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor"); + } + } + module2.exports = ProxyAgent; + } +}); + +// node_modules/undici/lib/handler/RetryHandler.js +var require_RetryHandler = __commonJS({ + "node_modules/undici/lib/handler/RetryHandler.js"(exports2, module2) { + var assert = require("assert"); + var { kRetryHandlerDefaultRetry } = require_symbols(); + var { RequestRetryError } = require_errors(); + var { isDisturbed, parseHeaders, parseRangeHeader } = require_util(); + function calculateRetryAfterHeader(retryAfter) { + const current = Date.now(); + const diff = new Date(retryAfter).getTime() - current; + return diff; + } + var RetryHandler = class _RetryHandler { + constructor(opts, handlers) { + const { retryOptions, ...dispatchOpts } = opts; + const { + // Retry scoped + retry: retryFn, + maxRetries, + maxTimeout, + minTimeout, + timeoutFactor, + // Response scoped + methods, + errorCodes, + retryAfter, + statusCodes + } = retryOptions ?? {}; + this.dispatch = handlers.dispatch; + this.handler = handlers.handler; + this.opts = dispatchOpts; + this.abort = null; + this.aborted = false; + this.retryOpts = { + retry: retryFn ?? _RetryHandler[kRetryHandlerDefaultRetry], + retryAfter: retryAfter ?? true, + maxTimeout: maxTimeout ?? 30 * 1e3, + // 30s, + timeout: minTimeout ?? 500, + // .5s + timeoutFactor: timeoutFactor ?? 2, + maxRetries: maxRetries ?? 5, + // What errors we should retry + methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"], + // Indicates which errors to retry + statusCodes: statusCodes ?? [500, 502, 503, 504, 429], + // List of errors to retry + errorCodes: errorCodes ?? [ + "ECONNRESET", + "ECONNREFUSED", + "ENOTFOUND", + "ENETDOWN", + "ENETUNREACH", + "EHOSTDOWN", + "EHOSTUNREACH", + "EPIPE" + ] + }; + this.retryCount = 0; + this.start = 0; + this.end = null; + this.etag = null; + this.resume = null; + this.handler.onConnect((reason) => { + this.aborted = true; + if (this.abort) { + this.abort(reason); + } else { + this.reason = reason; + } + }); + } + onRequestSent() { + if (this.handler.onRequestSent) { + this.handler.onRequestSent(); + } + } + onUpgrade(statusCode, headers, socket) { + if (this.handler.onUpgrade) { + this.handler.onUpgrade(statusCode, headers, socket); + } + } + onConnect(abort) { + if (this.aborted) { + abort(this.reason); + } else { + this.abort = abort; + } + } + onBodySent(chunk) { + if (this.handler.onBodySent) return this.handler.onBodySent(chunk); + } + static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) { + const { statusCode, code, headers } = err; + const { method, retryOptions } = opts; + const { + maxRetries, + timeout, + maxTimeout, + timeoutFactor, + statusCodes, + errorCodes, + methods + } = retryOptions; + let { counter, currentTimeout } = state; + currentTimeout = currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout; + if (code && code !== "UND_ERR_REQ_RETRY" && code !== "UND_ERR_SOCKET" && !errorCodes.includes(code)) { + cb(err); + return; + } + if (Array.isArray(methods) && !methods.includes(method)) { + cb(err); + return; + } + if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) { + cb(err); + return; + } + if (counter > maxRetries) { + cb(err); + return; + } + let retryAfterHeader = headers != null && headers["retry-after"]; + if (retryAfterHeader) { + retryAfterHeader = Number(retryAfterHeader); + retryAfterHeader = isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3; + } + const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout); + state.currentTimeout = retryTimeout; + setTimeout(() => cb(null), retryTimeout); + } + onHeaders(statusCode, rawHeaders, resume, statusMessage) { + const headers = parseHeaders(rawHeaders); + this.retryCount += 1; + if (statusCode >= 300) { + this.abort( + new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.resume != null) { + this.resume = null; + if (statusCode !== 206) { + return true; + } + const contentRange = parseRangeHeader(headers["content-range"]); + if (!contentRange) { + this.abort( + new RequestRetryError("Content-Range mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + if (this.etag != null && this.etag !== headers.etag) { + this.abort( + new RequestRetryError("ETag mismatch", statusCode, { + headers, + count: this.retryCount + }) + ); + return false; + } + const { start, size, end = size } = contentRange; + assert(this.start === start, "content-range mismatch"); + assert(this.end == null || this.end === end, "content-range mismatch"); + this.resume = resume; + return true; + } + if (this.end == null) { + if (statusCode === 206) { + const range = parseRangeHeader(headers["content-range"]); + if (range == null) { + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const { start, size, end = size } = range; + assert( + start != null && Number.isFinite(start) && this.start !== start, + "content-range mismatch" + ); + assert(Number.isFinite(start)); + assert( + end != null && Number.isFinite(end) && this.end !== end, + "invalid content-length" + ); + this.start = start; + this.end = end; + } + if (this.end == null) { + const contentLength = headers["content-length"]; + this.end = contentLength != null ? Number(contentLength) : null; + } + assert(Number.isFinite(this.start)); + assert( + this.end == null || Number.isFinite(this.end), + "invalid content-length" + ); + this.resume = resume; + this.etag = headers.etag != null ? headers.etag : null; + return this.handler.onHeaders( + statusCode, + rawHeaders, + resume, + statusMessage + ); + } + const err = new RequestRetryError("Request failed", statusCode, { + headers, + count: this.retryCount + }); + this.abort(err); + return false; + } + onData(chunk) { + this.start += chunk.length; + return this.handler.onData(chunk); + } + onComplete(rawTrailers) { + this.retryCount = 0; + return this.handler.onComplete(rawTrailers); + } + onError(err) { + if (this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err); + } + this.retryOpts.retry( + err, + { + state: { counter: this.retryCount++, currentTimeout: this.retryAfter }, + opts: { retryOptions: this.retryOpts, ...this.opts } + }, + onRetry.bind(this) + ); + function onRetry(err2) { + if (err2 != null || this.aborted || isDisturbed(this.opts.body)) { + return this.handler.onError(err2); + } + if (this.start !== 0) { + this.opts = { + ...this.opts, + headers: { + ...this.opts.headers, + range: `bytes=${this.start}-${this.end ?? ""}` + } + }; + } + try { + this.dispatch(this.opts, this); + } catch (err3) { + this.handler.onError(err3); + } + } + } + }; + module2.exports = RetryHandler; + } +}); + +// node_modules/undici/lib/global.js +var require_global2 = __commonJS({ + "node_modules/undici/lib/global.js"(exports2, module2) { + "use strict"; + var globalDispatcher = Symbol.for("undici.globalDispatcher.1"); + var { InvalidArgumentError } = require_errors(); + var Agent = require_agent(); + if (getGlobalDispatcher() === void 0) { + setGlobalDispatcher(new Agent()); + } + function setGlobalDispatcher(agent) { + if (!agent || typeof agent.dispatch !== "function") { + throw new InvalidArgumentError("Argument agent must implement Agent"); + } + Object.defineProperty(globalThis, globalDispatcher, { + value: agent, + writable: true, + enumerable: false, + configurable: false + }); + } + function getGlobalDispatcher() { + return globalThis[globalDispatcher]; + } + module2.exports = { + setGlobalDispatcher, + getGlobalDispatcher + }; + } +}); + +// node_modules/undici/lib/handler/DecoratorHandler.js +var require_DecoratorHandler = __commonJS({ + "node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module2) { + "use strict"; + module2.exports = class DecoratorHandler { + constructor(handler) { + this.handler = handler; + } + onConnect(...args) { + return this.handler.onConnect(...args); + } + onError(...args) { + return this.handler.onError(...args); + } + onUpgrade(...args) { + return this.handler.onUpgrade(...args); + } + onHeaders(...args) { + return this.handler.onHeaders(...args); + } + onData(...args) { + return this.handler.onData(...args); + } + onComplete(...args) { + return this.handler.onComplete(...args); + } + onBodySent(...args) { + return this.handler.onBodySent(...args); + } + }; + } +}); + +// node_modules/undici/lib/fetch/headers.js +var require_headers = __commonJS({ + "node_modules/undici/lib/fetch/headers.js"(exports2, module2) { + "use strict"; + var { kHeadersList, kConstruct } = require_symbols(); + var { kGuard } = require_symbols2(); + var { kEnumerableProperty } = require_util(); + var { + makeIterator, + isValidHeaderName, + isValidHeaderValue + } = require_util2(); + var util = require("util"); + var { webidl } = require_webidl(); + var assert = require("assert"); + var kHeadersMap = Symbol("headers map"); + var kHeadersSortedMap = Symbol("headers map sorted"); + function isHTTPWhiteSpaceCharCode(code) { + return code === 10 || code === 13 || code === 9 || code === 32; + } + function headerValueNormalize(potentialValue) { + let i = 0; + let j = potentialValue.length; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j; + while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i; + return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j); + } + function fill(headers, object) { + if (Array.isArray(object)) { + for (let i = 0; i < object.length; ++i) { + const header = object[i]; + if (header.length !== 2) { + throw webidl.errors.exception({ + header: "Headers constructor", + message: `expected name/value pair to be length 2, found ${header.length}.` + }); + } + appendHeader(headers, header[0], header[1]); + } + } else if (typeof object === "object" && object !== null) { + const keys = Object.keys(object); + for (let i = 0; i < keys.length; ++i) { + appendHeader(headers, keys[i], object[keys[i]]); + } + } else { + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + } + } + function appendHeader(headers, name, value) { + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.append", + value, + type: "header value" + }); + } + if (headers[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (headers[kGuard] === "request-no-cors") { + } + return headers[kHeadersList].append(name, value); + } + var HeadersList = class _HeadersList { + /** @type {[string, string][]|null} */ + cookies = null; + constructor(init) { + if (init instanceof _HeadersList) { + this[kHeadersMap] = new Map(init[kHeadersMap]); + this[kHeadersSortedMap] = init[kHeadersSortedMap]; + this.cookies = init.cookies === null ? null : [...init.cookies]; + } else { + this[kHeadersMap] = new Map(init); + this[kHeadersSortedMap] = null; + } + } + // https://fetch.spec.whatwg.org/#header-list-contains + contains(name) { + name = name.toLowerCase(); + return this[kHeadersMap].has(name); + } + clear() { + this[kHeadersMap].clear(); + this[kHeadersSortedMap] = null; + this.cookies = null; + } + // https://fetch.spec.whatwg.org/#concept-header-list-append + append(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + const exists = this[kHeadersMap].get(lowercaseName); + if (exists) { + const delimiter = lowercaseName === "cookie" ? "; " : ", "; + this[kHeadersMap].set(lowercaseName, { + name: exists.name, + value: `${exists.value}${delimiter}${value}` + }); + } else { + this[kHeadersMap].set(lowercaseName, { name, value }); + } + if (lowercaseName === "set-cookie") { + this.cookies ??= []; + this.cookies.push(value); + } + } + // https://fetch.spec.whatwg.org/#concept-header-list-set + set(name, value) { + this[kHeadersSortedMap] = null; + const lowercaseName = name.toLowerCase(); + if (lowercaseName === "set-cookie") { + this.cookies = [value]; + } + this[kHeadersMap].set(lowercaseName, { name, value }); + } + // https://fetch.spec.whatwg.org/#concept-header-list-delete + delete(name) { + this[kHeadersSortedMap] = null; + name = name.toLowerCase(); + if (name === "set-cookie") { + this.cookies = null; + } + this[kHeadersMap].delete(name); + } + // https://fetch.spec.whatwg.org/#concept-header-list-get + get(name) { + const value = this[kHeadersMap].get(name.toLowerCase()); + return value === void 0 ? null : value.value; + } + *[Symbol.iterator]() { + for (const [name, { value }] of this[kHeadersMap]) { + yield [name, value]; + } + } + get entries() { + const headers = {}; + if (this[kHeadersMap].size) { + for (const { name, value } of this[kHeadersMap].values()) { + headers[name] = value; + } + } + return headers; + } + }; + var Headers2 = class _Headers { + constructor(init = void 0) { + if (init === kConstruct) { + return; + } + this[kHeadersList] = new HeadersList(); + this[kGuard] = "none"; + if (init !== void 0) { + init = webidl.converters.HeadersInit(init); + fill(this, init); + } + } + // https://fetch.spec.whatwg.org/#dom-headers-append + append(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + return appendHeader(this, name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-delete + delete(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.delete", + value: name, + type: "header name" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + if (!this[kHeadersList].contains(name)) { + return; + } + this[kHeadersList].delete(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-get + get(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.get", + value: name, + type: "header name" + }); + } + return this[kHeadersList].get(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-has + has(name) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" }); + name = webidl.converters.ByteString(name); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.has", + value: name, + type: "header name" + }); + } + return this[kHeadersList].contains(name); + } + // https://fetch.spec.whatwg.org/#dom-headers-set + set(name, value) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" }); + name = webidl.converters.ByteString(name); + value = webidl.converters.ByteString(value); + value = headerValueNormalize(value); + if (!isValidHeaderName(name)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value: name, + type: "header name" + }); + } else if (!isValidHeaderValue(value)) { + throw webidl.errors.invalidArgument({ + prefix: "Headers.set", + value, + type: "header value" + }); + } + if (this[kGuard] === "immutable") { + throw new TypeError("immutable"); + } else if (this[kGuard] === "request-no-cors") { + } + this[kHeadersList].set(name, value); + } + // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie + getSetCookie() { + webidl.brandCheck(this, _Headers); + const list = this[kHeadersList].cookies; + if (list) { + return [...list]; + } + return []; + } + // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine + get [kHeadersSortedMap]() { + if (this[kHeadersList][kHeadersSortedMap]) { + return this[kHeadersList][kHeadersSortedMap]; + } + const headers = []; + const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1); + const cookies = this[kHeadersList].cookies; + for (let i = 0; i < names.length; ++i) { + const [name, value] = names[i]; + if (name === "set-cookie") { + for (let j = 0; j < cookies.length; ++j) { + headers.push([name, cookies[j]]); + } + } else { + assert(value !== null); + headers.push([name, value]); + } + } + this[kHeadersList][kHeadersSortedMap] = headers; + return headers; + } + keys() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key" + ); + } + values() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "value" + ); + } + entries() { + webidl.brandCheck(this, _Headers); + if (this[kGuard] === "immutable") { + const value = this[kHeadersSortedMap]; + return makeIterator( + () => value, + "Headers", + "key+value" + ); + } + return makeIterator( + () => [...this[kHeadersSortedMap].values()], + "Headers", + "key+value" + ); + } + /** + * @param {(value: string, key: string, self: Headers) => void} callbackFn + * @param {unknown} thisArg + */ + forEach(callbackFn, thisArg = globalThis) { + webidl.brandCheck(this, _Headers); + webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" }); + if (typeof callbackFn !== "function") { + throw new TypeError( + "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'." + ); + } + for (const [key, value] of this) { + callbackFn.apply(thisArg, [value, key, this]); + } + } + [Symbol.for("nodejs.util.inspect.custom")]() { + webidl.brandCheck(this, _Headers); + return this[kHeadersList]; + } + }; + Headers2.prototype[Symbol.iterator] = Headers2.prototype.entries; + Object.defineProperties(Headers2.prototype, { + append: kEnumerableProperty, + delete: kEnumerableProperty, + get: kEnumerableProperty, + has: kEnumerableProperty, + set: kEnumerableProperty, + getSetCookie: kEnumerableProperty, + keys: kEnumerableProperty, + values: kEnumerableProperty, + entries: kEnumerableProperty, + forEach: kEnumerableProperty, + [Symbol.iterator]: { enumerable: false }, + [Symbol.toStringTag]: { + value: "Headers", + configurable: true + }, + [util.inspect.custom]: { + enumerable: false + } + }); + webidl.converters.HeadersInit = function(V) { + if (webidl.util.Type(V) === "Object") { + if (V[Symbol.iterator]) { + return webidl.converters["sequence>"](V); + } + return webidl.converters["record"](V); + } + throw webidl.errors.conversionFailed({ + prefix: "Headers constructor", + argument: "Argument 1", + types: ["sequence>", "record"] + }); + }; + module2.exports = { + fill, + Headers: Headers2, + HeadersList + }; + } +}); + +// node_modules/undici/lib/fetch/response.js +var require_response = __commonJS({ + "node_modules/undici/lib/fetch/response.js"(exports2, module2) { + "use strict"; + var { Headers: Headers2, HeadersList, fill } = require_headers(); + var { extractBody, cloneBody, mixinBody } = require_body(); + var util = require_util(); + var { kEnumerableProperty } = util; + var { + isValidReasonPhrase, + isCancelled, + isAborted, + isBlobLike: isBlobLike2, + serializeJavascriptValueToJSONString, + isErrorLike, + isomorphicEncode + } = require_util2(); + var { + redirectStatusSet, + nullBodyStatus, + DOMException: DOMException2 + } = require_constants2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { FormData: FormData2 } = require_formdata(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { types } = require("util"); + var ReadableStream = globalThis.ReadableStream || require("stream/web").ReadableStream; + var textEncoder = new TextEncoder("utf-8"); + var Response2 = class _Response { + // Creates network error Response. + static error() { + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kState] = makeNetworkError(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response-json + static json(data, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" }); + if (init !== null) { + init = webidl.converters.ResponseInit(init); + } + const bytes = textEncoder.encode( + serializeJavascriptValueToJSONString(data) + ); + const body = extractBody(bytes); + const relevantRealm = { settingsObject: {} }; + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "response"; + responseObject[kHeaders][kRealm] = relevantRealm; + initializeResponse(responseObject, init, { body: body[0], type: "application/json" }); + return responseObject; + } + // Creates a redirect Response that redirects to url with status status. + static redirect(url, status = 302) { + const relevantRealm = { settingsObject: {} }; + webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" }); + url = webidl.converters.USVString(url); + status = webidl.converters["unsigned short"](status); + let parsedURL; + try { + parsedURL = new URL(url, getGlobalOrigin()); + } catch (err) { + throw Object.assign(new TypeError("Failed to parse URL from " + url), { + cause: err + }); + } + if (!redirectStatusSet.has(status)) { + throw new RangeError("Invalid status code " + status); + } + const responseObject = new _Response(); + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + responseObject[kState].status = status; + const value = isomorphicEncode(URLSerializer(parsedURL)); + responseObject[kState].headersList.append("location", value); + return responseObject; + } + // https://fetch.spec.whatwg.org/#dom-response + constructor(body = null, init = {}) { + if (body !== null) { + body = webidl.converters.BodyInit(body); + } + init = webidl.converters.ResponseInit(init); + this[kRealm] = { settingsObject: {} }; + this[kState] = makeResponse({}); + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kGuard] = "response"; + this[kHeaders][kHeadersList] = this[kState].headersList; + this[kHeaders][kRealm] = this[kRealm]; + let bodyWithType = null; + if (body != null) { + const [extractedBody, type] = extractBody(body); + bodyWithType = { body: extractedBody, type }; + } + initializeResponse(this, init, bodyWithType); + } + // Returns response’s type, e.g., "cors". + get type() { + webidl.brandCheck(this, _Response); + return this[kState].type; + } + // Returns response’s URL, if it has one; otherwise the empty string. + get url() { + webidl.brandCheck(this, _Response); + const urlList = this[kState].urlList; + const url = urlList[urlList.length - 1] ?? null; + if (url === null) { + return ""; + } + return URLSerializer(url, true); + } + // Returns whether response was obtained through a redirect. + get redirected() { + webidl.brandCheck(this, _Response); + return this[kState].urlList.length > 1; + } + // Returns response’s status. + get status() { + webidl.brandCheck(this, _Response); + return this[kState].status; + } + // Returns whether response’s status is an ok status. + get ok() { + webidl.brandCheck(this, _Response); + return this[kState].status >= 200 && this[kState].status <= 299; + } + // Returns response’s status message. + get statusText() { + webidl.brandCheck(this, _Response); + return this[kState].statusText; + } + // Returns response’s headers as Headers. + get headers() { + webidl.brandCheck(this, _Response); + return this[kHeaders]; + } + get body() { + webidl.brandCheck(this, _Response); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Response); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + // Returns a clone of response. + clone() { + webidl.brandCheck(this, _Response); + if (this.bodyUsed || this.body && this.body.locked) { + throw webidl.errors.exception({ + header: "Response.clone", + message: "Body has already been consumed." + }); + } + const clonedResponse = cloneResponse(this[kState]); + const clonedResponseObject = new _Response(); + clonedResponseObject[kState] = clonedResponse; + clonedResponseObject[kRealm] = this[kRealm]; + clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList; + clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + return clonedResponseObject; + } + }; + mixinBody(Response2); + Object.defineProperties(Response2.prototype, { + type: kEnumerableProperty, + url: kEnumerableProperty, + status: kEnumerableProperty, + ok: kEnumerableProperty, + redirected: kEnumerableProperty, + statusText: kEnumerableProperty, + headers: kEnumerableProperty, + clone: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Response", + configurable: true + } + }); + Object.defineProperties(Response2, { + json: kEnumerableProperty, + redirect: kEnumerableProperty, + error: kEnumerableProperty + }); + function cloneResponse(response) { + if (response.internalResponse) { + return filterResponse( + cloneResponse(response.internalResponse), + response.type + ); + } + const newResponse = makeResponse({ ...response, body: null }); + if (response.body != null) { + newResponse.body = cloneBody(response.body); + } + return newResponse; + } + function makeResponse(init) { + return { + aborted: false, + rangeRequested: false, + timingAllowPassed: false, + requestIncludesCredentials: false, + type: "default", + status: 200, + timingInfo: null, + cacheState: "", + statusText: "", + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList(), + urlList: init.urlList ? [...init.urlList] : [] + }; + } + function makeNetworkError(reason) { + const isError = isErrorLike(reason); + return makeResponse({ + type: "error", + status: 0, + error: isError ? reason : new Error(reason ? String(reason) : reason), + aborted: reason && reason.name === "AbortError" + }); + } + function makeFilteredResponse(response, state) { + state = { + internalResponse: response, + ...state + }; + return new Proxy(response, { + get(target, p) { + return p in state ? state[p] : target[p]; + }, + set(target, p, value) { + assert(!(p in state)); + target[p] = value; + return true; + } + }); + } + function filterResponse(response, type) { + if (type === "basic") { + return makeFilteredResponse(response, { + type: "basic", + headersList: response.headersList + }); + } else if (type === "cors") { + return makeFilteredResponse(response, { + type: "cors", + headersList: response.headersList + }); + } else if (type === "opaque") { + return makeFilteredResponse(response, { + type: "opaque", + urlList: Object.freeze([]), + status: 0, + statusText: "", + body: null + }); + } else if (type === "opaqueredirect") { + return makeFilteredResponse(response, { + type: "opaqueredirect", + status: 0, + statusText: "", + headersList: [], + body: null + }); + } else { + assert(false); + } + } + function makeAppropriateNetworkError(fetchParams, err = null) { + assert(isCancelled(fetchParams)); + return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException2("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException2("Request was cancelled."), { cause: err })); + } + function initializeResponse(response, init, body) { + if (init.status !== null && (init.status < 200 || init.status > 599)) { + throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.'); + } + if ("statusText" in init && init.statusText != null) { + if (!isValidReasonPhrase(String(init.statusText))) { + throw new TypeError("Invalid statusText"); + } + } + if ("status" in init && init.status != null) { + response[kState].status = init.status; + } + if ("statusText" in init && init.statusText != null) { + response[kState].statusText = init.statusText; + } + if ("headers" in init && init.headers != null) { + fill(response[kHeaders], init.headers); + } + if (body) { + if (nullBodyStatus.includes(response.status)) { + throw webidl.errors.exception({ + header: "Response constructor", + message: "Invalid response status code " + response.status + }); + } + response[kState].body = body.body; + if (body.type != null && !response[kState].headersList.contains("Content-Type")) { + response[kState].headersList.append("content-type", body.type); + } + } + } + webidl.converters.ReadableStream = webidl.interfaceConverter( + ReadableStream + ); + webidl.converters.FormData = webidl.interfaceConverter( + FormData2 + ); + webidl.converters.URLSearchParams = webidl.interfaceConverter( + URLSearchParams + ); + webidl.converters.XMLHttpRequestBodyInit = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (types.isArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) { + return webidl.converters.BufferSource(V); + } + if (util.isFormDataLike(V)) { + return webidl.converters.FormData(V, { strict: false }); + } + if (V instanceof URLSearchParams) { + return webidl.converters.URLSearchParams(V); + } + return webidl.converters.DOMString(V); + }; + webidl.converters.BodyInit = function(V) { + if (V instanceof ReadableStream) { + return webidl.converters.ReadableStream(V); + } + if (V?.[Symbol.asyncIterator]) { + return V; + } + return webidl.converters.XMLHttpRequestBodyInit(V); + }; + webidl.converters.ResponseInit = webidl.dictionaryConverter([ + { + key: "status", + converter: webidl.converters["unsigned short"], + defaultValue: 200 + }, + { + key: "statusText", + converter: webidl.converters.ByteString, + defaultValue: "" + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + } + ]); + module2.exports = { + makeNetworkError, + makeResponse, + makeAppropriateNetworkError, + filterResponse, + Response: Response2, + cloneResponse + }; + } +}); + +// node_modules/undici/lib/fetch/request.js +var require_request2 = __commonJS({ + "node_modules/undici/lib/fetch/request.js"(exports2, module2) { + "use strict"; + var { extractBody, mixinBody, cloneBody } = require_body(); + var { Headers: Headers2, fill: fillHeaders, HeadersList } = require_headers(); + var { FinalizationRegistry } = require_dispatcher_weakref()(); + var util = require_util(); + var { + isValidHTTPToken, + sameOrigin, + normalizeMethod, + makePolicyContainer, + normalizeMethodRecord + } = require_util2(); + var { + forbiddenMethodsSet, + corsSafeListedMethodsSet, + referrerPolicy, + requestRedirect, + requestMode, + requestCredentials, + requestCache, + requestDuplex + } = require_constants2(); + var { kEnumerableProperty } = util; + var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2(); + var { webidl } = require_webidl(); + var { getGlobalOrigin } = require_global(); + var { URLSerializer } = require_dataURL(); + var { kHeadersList, kConstruct } = require_symbols(); + var assert = require("assert"); + var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events"); + var TransformStream = globalThis.TransformStream; + var kAbortController = Symbol("abortController"); + var requestFinalizer = new FinalizationRegistry(({ signal, abort }) => { + signal.removeEventListener("abort", abort); + }); + var Request = class _Request { + // https://fetch.spec.whatwg.org/#dom-request + constructor(input, init = {}) { + if (input === kConstruct) { + return; + } + webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" }); + input = webidl.converters.RequestInfo(input); + init = webidl.converters.RequestInit(init); + this[kRealm] = { + settingsObject: { + baseUrl: getGlobalOrigin(), + get origin() { + return this.baseUrl?.origin; + }, + policyContainer: makePolicyContainer() + } + }; + let request = null; + let fallbackMode = null; + const baseUrl = this[kRealm].settingsObject.baseUrl; + let signal = null; + if (typeof input === "string") { + let parsedURL; + try { + parsedURL = new URL(input, baseUrl); + } catch (err) { + throw new TypeError("Failed to parse URL from " + input, { cause: err }); + } + if (parsedURL.username || parsedURL.password) { + throw new TypeError( + "Request cannot be constructed from a URL that includes credentials: " + input + ); + } + request = makeRequest({ urlList: [parsedURL] }); + fallbackMode = "cors"; + } else { + assert(input instanceof _Request); + request = input[kState]; + signal = input[kSignal]; + } + const origin = this[kRealm].settingsObject.origin; + let window2 = "client"; + if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) { + window2 = request.window; + } + if (init.window != null) { + throw new TypeError(`'window' option '${window2}' must be null`); + } + if ("window" in init) { + window2 = "no-window"; + } + request = makeRequest({ + // URL request’s URL. + // undici implementation note: this is set as the first item in request's urlList in makeRequest + // method request’s method. + method: request.method, + // header list A copy of request’s header list. + // undici implementation note: headersList is cloned in makeRequest + headersList: request.headersList, + // unsafe-request flag Set. + unsafeRequest: request.unsafeRequest, + // client This’s relevant settings object. + client: this[kRealm].settingsObject, + // window window. + window: window2, + // priority request’s priority. + priority: request.priority, + // origin request’s origin. The propagation of the origin is only significant for navigation requests + // being handled by a service worker. In this scenario a request can have an origin that is different + // from the current client. + origin: request.origin, + // referrer request’s referrer. + referrer: request.referrer, + // referrer policy request’s referrer policy. + referrerPolicy: request.referrerPolicy, + // mode request’s mode. + mode: request.mode, + // credentials mode request’s credentials mode. + credentials: request.credentials, + // cache mode request’s cache mode. + cache: request.cache, + // redirect mode request’s redirect mode. + redirect: request.redirect, + // integrity metadata request’s integrity metadata. + integrity: request.integrity, + // keepalive request’s keepalive. + keepalive: request.keepalive, + // reload-navigation flag request’s reload-navigation flag. + reloadNavigation: request.reloadNavigation, + // history-navigation flag request’s history-navigation flag. + historyNavigation: request.historyNavigation, + // URL list A clone of request’s URL list. + urlList: [...request.urlList] + }); + const initHasKey = Object.keys(init).length !== 0; + if (initHasKey) { + if (request.mode === "navigate") { + request.mode = "same-origin"; + } + request.reloadNavigation = false; + request.historyNavigation = false; + request.origin = "client"; + request.referrer = "client"; + request.referrerPolicy = ""; + request.url = request.urlList[request.urlList.length - 1]; + request.urlList = [request.url]; + } + if (init.referrer !== void 0) { + const referrer = init.referrer; + if (referrer === "") { + request.referrer = "no-referrer"; + } else { + let parsedReferrer; + try { + parsedReferrer = new URL(referrer, baseUrl); + } catch (err) { + throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err }); + } + if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) { + request.referrer = "client"; + } else { + request.referrer = parsedReferrer; + } + } + } + if (init.referrerPolicy !== void 0) { + request.referrerPolicy = init.referrerPolicy; + } + let mode; + if (init.mode !== void 0) { + mode = init.mode; + } else { + mode = fallbackMode; + } + if (mode === "navigate") { + throw webidl.errors.exception({ + header: "Request constructor", + message: "invalid request mode navigate." + }); + } + if (mode != null) { + request.mode = mode; + } + if (init.credentials !== void 0) { + request.credentials = init.credentials; + } + if (init.cache !== void 0) { + request.cache = init.cache; + } + if (request.cache === "only-if-cached" && request.mode !== "same-origin") { + throw new TypeError( + "'only-if-cached' can be set only with 'same-origin' mode" + ); + } + if (init.redirect !== void 0) { + request.redirect = init.redirect; + } + if (init.integrity != null) { + request.integrity = String(init.integrity); + } + if (init.keepalive !== void 0) { + request.keepalive = Boolean(init.keepalive); + } + if (init.method !== void 0) { + let method = init.method; + if (!isValidHTTPToken(method)) { + throw new TypeError(`'${method}' is not a valid HTTP method.`); + } + if (forbiddenMethodsSet.has(method.toUpperCase())) { + throw new TypeError(`'${method}' HTTP method is unsupported.`); + } + method = normalizeMethodRecord[method] ?? normalizeMethod(method); + request.method = method; + } + if (init.signal !== void 0) { + signal = init.signal; + } + this[kState] = request; + const ac = new AbortController(); + this[kSignal] = ac.signal; + this[kSignal][kRealm] = this[kRealm]; + if (signal != null) { + if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") { + throw new TypeError( + "Failed to construct 'Request': member signal is not of type AbortSignal." + ); + } + if (signal.aborted) { + ac.abort(signal.reason); + } else { + this[kAbortController] = ac; + const acRef = new WeakRef(ac); + const abort = function() { + const ac2 = acRef.deref(); + if (ac2 !== void 0) { + ac2.abort(this.reason); + } + }; + try { + if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) { + setMaxListeners(100, signal); + } else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) { + setMaxListeners(100, signal); + } + } catch { + } + util.addAbortListener(signal, abort); + requestFinalizer.register(ac, { signal, abort }); + } + } + this[kHeaders] = new Headers2(kConstruct); + this[kHeaders][kHeadersList] = request.headersList; + this[kHeaders][kGuard] = "request"; + this[kHeaders][kRealm] = this[kRealm]; + if (mode === "no-cors") { + if (!corsSafeListedMethodsSet.has(request.method)) { + throw new TypeError( + `'${request.method} is unsupported in no-cors mode.` + ); + } + this[kHeaders][kGuard] = "request-no-cors"; + } + if (initHasKey) { + const headersList = this[kHeaders][kHeadersList]; + const headers = init.headers !== void 0 ? init.headers : new HeadersList(headersList); + headersList.clear(); + if (headers instanceof HeadersList) { + for (const [key, val] of headers) { + headersList.append(key, val); + } + headersList.cookies = headers.cookies; + } else { + fillHeaders(this[kHeaders], headers); + } + } + const inputBody = input instanceof _Request ? input[kState].body : null; + if ((init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) { + throw new TypeError("Request with GET/HEAD method cannot have body."); + } + let initBody = null; + if (init.body != null) { + const [extractedBody, contentType] = extractBody( + init.body, + request.keepalive + ); + initBody = extractedBody; + if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) { + this[kHeaders].append("content-type", contentType); + } + } + const inputOrInitBody = initBody ?? inputBody; + if (inputOrInitBody != null && inputOrInitBody.source == null) { + if (initBody != null && init.duplex == null) { + throw new TypeError("RequestInit: duplex option is required when sending a body."); + } + if (request.mode !== "same-origin" && request.mode !== "cors") { + throw new TypeError( + 'If request is made from ReadableStream, mode should be "same-origin" or "cors"' + ); + } + request.useCORSPreflightFlag = true; + } + let finalBody = inputOrInitBody; + if (initBody == null && inputBody != null) { + if (util.isDisturbed(inputBody.stream) || inputBody.stream.locked) { + throw new TypeError( + "Cannot construct a Request with a Request object that has already been used." + ); + } + if (!TransformStream) { + TransformStream = require("stream/web").TransformStream; + } + const identityTransform = new TransformStream(); + inputBody.stream.pipeThrough(identityTransform); + finalBody = { + source: inputBody.source, + length: inputBody.length, + stream: identityTransform.readable + }; + } + this[kState].body = finalBody; + } + // Returns request’s HTTP method, which is "GET" by default. + get method() { + webidl.brandCheck(this, _Request); + return this[kState].method; + } + // Returns the URL of request as a string. + get url() { + webidl.brandCheck(this, _Request); + return URLSerializer(this[kState].url); + } + // Returns a Headers object consisting of the headers associated with request. + // Note that headers added in the network layer by the user agent will not + // be accounted for in this object, e.g., the "Host" header. + get headers() { + webidl.brandCheck(this, _Request); + return this[kHeaders]; + } + // Returns the kind of resource requested by request, e.g., "document" + // or "script". + get destination() { + webidl.brandCheck(this, _Request); + return this[kState].destination; + } + // Returns the referrer of request. Its value can be a same-origin URL if + // explicitly set in init, the empty string to indicate no referrer, and + // "about:client" when defaulting to the global’s default. This is used + // during fetching to determine the value of the `Referer` header of the + // request being made. + get referrer() { + webidl.brandCheck(this, _Request); + if (this[kState].referrer === "no-referrer") { + return ""; + } + if (this[kState].referrer === "client") { + return "about:client"; + } + return this[kState].referrer.toString(); + } + // Returns the referrer policy associated with request. + // This is used during fetching to compute the value of the request’s + // referrer. + get referrerPolicy() { + webidl.brandCheck(this, _Request); + return this[kState].referrerPolicy; + } + // Returns the mode associated with request, which is a string indicating + // whether the request will use CORS, or will be restricted to same-origin + // URLs. + get mode() { + webidl.brandCheck(this, _Request); + return this[kState].mode; + } + // Returns the credentials mode associated with request, + // which is a string indicating whether credentials will be sent with the + // request always, never, or only when sent to a same-origin URL. + get credentials() { + return this[kState].credentials; + } + // Returns the cache mode associated with request, + // which is a string indicating how the request will + // interact with the browser’s cache when fetching. + get cache() { + webidl.brandCheck(this, _Request); + return this[kState].cache; + } + // Returns the redirect mode associated with request, + // which is a string indicating how redirects for the + // request will be handled during fetching. A request + // will follow redirects by default. + get redirect() { + webidl.brandCheck(this, _Request); + return this[kState].redirect; + } + // Returns request’s subresource integrity metadata, which is a + // cryptographic hash of the resource being fetched. Its value + // consists of multiple hashes separated by whitespace. [SRI] + get integrity() { + webidl.brandCheck(this, _Request); + return this[kState].integrity; + } + // Returns a boolean indicating whether or not request can outlive the + // global in which it was created. + get keepalive() { + webidl.brandCheck(this, _Request); + return this[kState].keepalive; + } + // Returns a boolean indicating whether or not request is for a reload + // navigation. + get isReloadNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].reloadNavigation; + } + // Returns a boolean indicating whether or not request is for a history + // navigation (a.k.a. back-foward navigation). + get isHistoryNavigation() { + webidl.brandCheck(this, _Request); + return this[kState].historyNavigation; + } + // Returns the signal associated with request, which is an AbortSignal + // object indicating whether or not request has been aborted, and its + // abort event handler. + get signal() { + webidl.brandCheck(this, _Request); + return this[kSignal]; + } + get body() { + webidl.brandCheck(this, _Request); + return this[kState].body ? this[kState].body.stream : null; + } + get bodyUsed() { + webidl.brandCheck(this, _Request); + return !!this[kState].body && util.isDisturbed(this[kState].body.stream); + } + get duplex() { + webidl.brandCheck(this, _Request); + return "half"; + } + // Returns a clone of request. + clone() { + webidl.brandCheck(this, _Request); + if (this.bodyUsed || this.body?.locked) { + throw new TypeError("unusable"); + } + const clonedRequest = cloneRequest(this[kState]); + const clonedRequestObject = new _Request(kConstruct); + clonedRequestObject[kState] = clonedRequest; + clonedRequestObject[kRealm] = this[kRealm]; + clonedRequestObject[kHeaders] = new Headers2(kConstruct); + clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList; + clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard]; + clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm]; + const ac = new AbortController(); + if (this.signal.aborted) { + ac.abort(this.signal.reason); + } else { + util.addAbortListener( + this.signal, + () => { + ac.abort(this.signal.reason); + } + ); + } + clonedRequestObject[kSignal] = ac.signal; + return clonedRequestObject; + } + }; + mixinBody(Request); + function makeRequest(init) { + const request = { + method: "GET", + localURLsOnly: false, + unsafeRequest: false, + body: null, + client: null, + reservedClient: null, + replacesClientId: "", + window: "client", + keepalive: false, + serviceWorkers: "all", + initiator: "", + destination: "", + priority: null, + origin: "client", + policyContainer: "client", + referrer: "client", + referrerPolicy: "", + mode: "no-cors", + useCORSPreflightFlag: false, + credentials: "same-origin", + useCredentials: false, + cache: "default", + redirect: "follow", + integrity: "", + cryptoGraphicsNonceMetadata: "", + parserMetadata: "", + reloadNavigation: false, + historyNavigation: false, + userActivation: false, + taintedOrigin: false, + redirectCount: 0, + responseTainting: "basic", + preventNoCacheCacheControlHeaderModification: false, + done: false, + timingAllowFailed: false, + ...init, + headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList() + }; + request.url = request.urlList[0]; + return request; + } + function cloneRequest(request) { + const newRequest = makeRequest({ ...request, body: null }); + if (request.body != null) { + newRequest.body = cloneBody(request.body); + } + return newRequest; + } + Object.defineProperties(Request.prototype, { + method: kEnumerableProperty, + url: kEnumerableProperty, + headers: kEnumerableProperty, + redirect: kEnumerableProperty, + clone: kEnumerableProperty, + signal: kEnumerableProperty, + duplex: kEnumerableProperty, + destination: kEnumerableProperty, + body: kEnumerableProperty, + bodyUsed: kEnumerableProperty, + isHistoryNavigation: kEnumerableProperty, + isReloadNavigation: kEnumerableProperty, + keepalive: kEnumerableProperty, + integrity: kEnumerableProperty, + cache: kEnumerableProperty, + credentials: kEnumerableProperty, + attribute: kEnumerableProperty, + referrerPolicy: kEnumerableProperty, + referrer: kEnumerableProperty, + mode: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "Request", + configurable: true + } + }); + webidl.converters.Request = webidl.interfaceConverter( + Request + ); + webidl.converters.RequestInfo = function(V) { + if (typeof V === "string") { + return webidl.converters.USVString(V); + } + if (V instanceof Request) { + return webidl.converters.Request(V); + } + return webidl.converters.USVString(V); + }; + webidl.converters.AbortSignal = webidl.interfaceConverter( + AbortSignal + ); + webidl.converters.RequestInit = webidl.dictionaryConverter([ + { + key: "method", + converter: webidl.converters.ByteString + }, + { + key: "headers", + converter: webidl.converters.HeadersInit + }, + { + key: "body", + converter: webidl.nullableConverter( + webidl.converters.BodyInit + ) + }, + { + key: "referrer", + converter: webidl.converters.USVString + }, + { + key: "referrerPolicy", + converter: webidl.converters.DOMString, + // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy + allowedValues: referrerPolicy + }, + { + key: "mode", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#concept-request-mode + allowedValues: requestMode + }, + { + key: "credentials", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcredentials + allowedValues: requestCredentials + }, + { + key: "cache", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestcache + allowedValues: requestCache + }, + { + key: "redirect", + converter: webidl.converters.DOMString, + // https://fetch.spec.whatwg.org/#requestredirect + allowedValues: requestRedirect + }, + { + key: "integrity", + converter: webidl.converters.DOMString + }, + { + key: "keepalive", + converter: webidl.converters.boolean + }, + { + key: "signal", + converter: webidl.nullableConverter( + (signal) => webidl.converters.AbortSignal( + signal, + { strict: false } + ) + ) + }, + { + key: "window", + converter: webidl.converters.any + }, + { + key: "duplex", + converter: webidl.converters.DOMString, + allowedValues: requestDuplex + } + ]); + module2.exports = { Request, makeRequest }; + } +}); + +// node_modules/undici/lib/fetch/index.js +var require_fetch = __commonJS({ + "node_modules/undici/lib/fetch/index.js"(exports2, module2) { + "use strict"; + var { + Response: Response2, + makeNetworkError, + makeAppropriateNetworkError, + filterResponse, + makeResponse + } = require_response(); + var { Headers: Headers2 } = require_headers(); + var { Request, makeRequest } = require_request2(); + var zlib = require("zlib"); + var { + bytesMatch, + makePolicyContainer, + clonePolicyContainer, + requestBadPort, + TAOCheck, + appendRequestOriginHeader, + responseLocationURL, + requestCurrentURL, + setRequestReferrerPolicyOnRedirect, + tryUpgradeRequestToAPotentiallyTrustworthyURL, + createOpaqueTimingInfo, + appendFetchMetadata, + corsCheck, + crossOriginResourcePolicyCheck, + determineRequestsReferrer, + coarsenedSharedCurrentTime, + createDeferredPromise, + isBlobLike: isBlobLike2, + sameOrigin, + isCancelled, + isAborted, + isErrorLike, + fullyReadBody, + readableStreamClose, + isomorphicEncode, + urlIsLocal, + urlIsHttpHttpsScheme, + urlHasHttpsScheme + } = require_util2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var assert = require("assert"); + var { safelyExtractBody } = require_body(); + var { + redirectStatusSet, + nullBodyStatus, + safeMethodsSet, + requestBodyHeader, + subresourceSet, + DOMException: DOMException2 + } = require_constants2(); + var { kHeadersList } = require_symbols(); + var EE = require("events"); + var { Readable, pipeline } = require("stream"); + var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util(); + var { dataURLProcessor, serializeAMimeType } = require_dataURL(); + var { TransformStream } = require("stream/web"); + var { getGlobalDispatcher } = require_global2(); + var { webidl } = require_webidl(); + var { STATUS_CODES } = require("http"); + var GET_OR_HEAD = ["GET", "HEAD"]; + var resolveObjectURL; + var ReadableStream = globalThis.ReadableStream; + var Fetch = class extends EE { + constructor(dispatcher) { + super(); + this.dispatcher = dispatcher; + this.connection = null; + this.dump = false; + this.state = "ongoing"; + this.setMaxListeners(21); + } + terminate(reason) { + if (this.state !== "ongoing") { + return; + } + this.state = "terminated"; + this.connection?.destroy(reason); + this.emit("terminated", reason); + } + // https://fetch.spec.whatwg.org/#fetch-controller-abort + abort(error) { + if (this.state !== "ongoing") { + return; + } + this.state = "aborted"; + if (!error) { + error = new DOMException2("The operation was aborted.", "AbortError"); + } + this.serializedAbortReason = error; + this.connection?.destroy(error); + this.emit("terminated", error); + } + }; + function fetch2(input, init = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" }); + const p = createDeferredPromise(); + let requestObject; + try { + requestObject = new Request(input, init); + } catch (e) { + p.reject(e); + return p.promise; + } + const request = requestObject[kState]; + if (requestObject.signal.aborted) { + abortFetch(p, request, null, requestObject.signal.reason); + return p.promise; + } + const globalObject = request.client.globalObject; + if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") { + request.serviceWorkers = "none"; + } + let responseObject = null; + const relevantRealm = null; + let locallyAborted = false; + let controller = null; + addAbortListener( + requestObject.signal, + () => { + locallyAborted = true; + assert(controller != null); + controller.abort(requestObject.signal.reason); + abortFetch(p, request, responseObject, requestObject.signal.reason); + } + ); + const handleFetchDone = (response) => finalizeAndReportTiming(response, "fetch"); + const processResponse = (response) => { + if (locallyAborted) { + return Promise.resolve(); + } + if (response.aborted) { + abortFetch(p, request, responseObject, controller.serializedAbortReason); + return Promise.resolve(); + } + if (response.type === "error") { + p.reject( + Object.assign(new TypeError("fetch failed"), { cause: response.error }) + ); + return Promise.resolve(); + } + responseObject = new Response2(); + responseObject[kState] = response; + responseObject[kRealm] = relevantRealm; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseObject[kHeaders][kRealm] = relevantRealm; + p.resolve(responseObject); + }; + controller = fetching({ + request, + processResponseEndOfBody: handleFetchDone, + processResponse, + dispatcher: init.dispatcher ?? getGlobalDispatcher() + // undici + }); + return p.promise; + } + function finalizeAndReportTiming(response, initiatorType = "other") { + if (response.type === "error" && response.aborted) { + return; + } + if (!response.urlList?.length) { + return; + } + const originalURL = response.urlList[0]; + let timingInfo = response.timingInfo; + let cacheState = response.cacheState; + if (!urlIsHttpHttpsScheme(originalURL)) { + return; + } + if (timingInfo === null) { + return; + } + if (!response.timingAllowPassed) { + timingInfo = createOpaqueTimingInfo({ + startTime: timingInfo.startTime + }); + cacheState = ""; + } + timingInfo.endTime = coarsenedSharedCurrentTime(); + response.timingInfo = timingInfo; + markResourceTiming( + timingInfo, + originalURL, + initiatorType, + globalThis, + cacheState + ); + } + function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) { + if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) { + performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState); + } + } + function abortFetch(p, request, responseObject, error) { + if (!error) { + error = new DOMException2("The operation was aborted.", "AbortError"); + } + p.reject(error); + if (request.body != null && isReadable(request.body?.stream)) { + request.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + if (responseObject == null) { + return; + } + const response = responseObject[kState]; + if (response.body != null && isReadable(response.body?.stream)) { + response.body.stream.cancel(error).catch((err) => { + if (err.code === "ERR_INVALID_STATE") { + return; + } + throw err; + }); + } + } + function fetching({ + request, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseEndOfBody, + processResponseConsumeBody, + useParallelQueue = false, + dispatcher + // undici + }) { + let taskDestination = null; + let crossOriginIsolatedCapability = false; + if (request.client != null) { + taskDestination = request.client.globalObject; + crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability; + } + const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability); + const timingInfo = createOpaqueTimingInfo({ + startTime: currenTime + }); + const fetchParams = { + controller: new Fetch(dispatcher), + request, + timingInfo, + processRequestBodyChunkLength, + processRequestEndOfBody, + processResponse, + processResponseConsumeBody, + processResponseEndOfBody, + taskDestination, + crossOriginIsolatedCapability + }; + assert(!request.body || request.body.stream); + if (request.window === "client") { + request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window"; + } + if (request.origin === "client") { + request.origin = request.client?.origin; + } + if (request.policyContainer === "client") { + if (request.client != null) { + request.policyContainer = clonePolicyContainer( + request.client.policyContainer + ); + } else { + request.policyContainer = makePolicyContainer(); + } + } + if (!request.headersList.contains("accept")) { + const value = "*/*"; + request.headersList.append("accept", value); + } + if (!request.headersList.contains("accept-language")) { + request.headersList.append("accept-language", "*"); + } + if (request.priority === null) { + } + if (subresourceSet.has(request.destination)) { + } + mainFetch(fetchParams).catch((err) => { + fetchParams.controller.terminate(err); + }); + return fetchParams.controller; + } + async function mainFetch(fetchParams, recursive = false) { + const request = fetchParams.request; + let response = null; + if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) { + response = makeNetworkError("local URLs only"); + } + tryUpgradeRequestToAPotentiallyTrustworthyURL(request); + if (requestBadPort(request) === "blocked") { + response = makeNetworkError("bad port"); + } + if (request.referrerPolicy === "") { + request.referrerPolicy = request.policyContainer.referrerPolicy; + } + if (request.referrer !== "no-referrer") { + request.referrer = determineRequestsReferrer(request); + } + if (response === null) { + response = await (async () => { + const currentURL = requestCurrentURL(request); + if ( + // - request’s current URL’s origin is same origin with request’s origin, + // and request’s response tainting is "basic" + sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data" + currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket" + (request.mode === "navigate" || request.mode === "websocket") + ) { + request.responseTainting = "basic"; + return await schemeFetch(fetchParams); + } + if (request.mode === "same-origin") { + return makeNetworkError('request mode cannot be "same-origin"'); + } + if (request.mode === "no-cors") { + if (request.redirect !== "follow") { + return makeNetworkError( + 'redirect mode cannot be "follow" for "no-cors" request' + ); + } + request.responseTainting = "opaque"; + return await schemeFetch(fetchParams); + } + if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) { + return makeNetworkError("URL scheme must be a HTTP(S) scheme"); + } + request.responseTainting = "cors"; + return await httpFetch(fetchParams); + })(); + } + if (recursive) { + return response; + } + if (response.status !== 0 && !response.internalResponse) { + if (request.responseTainting === "cors") { + } + if (request.responseTainting === "basic") { + response = filterResponse(response, "basic"); + } else if (request.responseTainting === "cors") { + response = filterResponse(response, "cors"); + } else if (request.responseTainting === "opaque") { + response = filterResponse(response, "opaque"); + } else { + assert(false); + } + } + let internalResponse = response.status === 0 ? response : response.internalResponse; + if (internalResponse.urlList.length === 0) { + internalResponse.urlList.push(...request.urlList); + } + if (!request.timingAllowFailed) { + response.timingAllowPassed = true; + } + if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range")) { + response = internalResponse = makeNetworkError(); + } + if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) { + internalResponse.body = null; + fetchParams.controller.dump = true; + } + if (request.integrity) { + const processBodyError = (reason) => fetchFinale(fetchParams, makeNetworkError(reason)); + if (request.responseTainting === "opaque" || response.body == null) { + processBodyError(response.error); + return; + } + const processBody = (bytes) => { + if (!bytesMatch(bytes, request.integrity)) { + processBodyError("integrity mismatch"); + return; + } + response.body = safelyExtractBody(bytes)[0]; + fetchFinale(fetchParams, response); + }; + await fullyReadBody(response.body, processBody, processBodyError); + } else { + fetchFinale(fetchParams, response); + } + } + function schemeFetch(fetchParams) { + if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) { + return Promise.resolve(makeAppropriateNetworkError(fetchParams)); + } + const { request } = fetchParams; + const { protocol: scheme } = requestCurrentURL(request); + switch (scheme) { + case "about:": { + return Promise.resolve(makeNetworkError("about scheme is not supported")); + } + case "blob:": { + if (!resolveObjectURL) { + resolveObjectURL = require("buffer").resolveObjectURL; + } + const blobURLEntry = requestCurrentURL(request); + if (blobURLEntry.search.length !== 0) { + return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource.")); + } + const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString()); + if (request.method !== "GET" || !isBlobLike2(blobURLEntryObject)) { + return Promise.resolve(makeNetworkError("invalid method")); + } + const bodyWithType = safelyExtractBody(blobURLEntryObject); + const body = bodyWithType[0]; + const length = isomorphicEncode(`${body.length}`); + const type = bodyWithType[1] ?? ""; + const response = makeResponse({ + statusText: "OK", + headersList: [ + ["content-length", { name: "Content-Length", value: length }], + ["content-type", { name: "Content-Type", value: type }] + ] + }); + response.body = body; + return Promise.resolve(response); + } + case "data:": { + const currentURL = requestCurrentURL(request); + const dataURLStruct = dataURLProcessor(currentURL); + if (dataURLStruct === "failure") { + return Promise.resolve(makeNetworkError("failed to fetch the data URL")); + } + const mimeType = serializeAMimeType(dataURLStruct.mimeType); + return Promise.resolve(makeResponse({ + statusText: "OK", + headersList: [ + ["content-type", { name: "Content-Type", value: mimeType }] + ], + body: safelyExtractBody(dataURLStruct.body)[0] + })); + } + case "file:": { + return Promise.resolve(makeNetworkError("not implemented... yet...")); + } + case "http:": + case "https:": { + return httpFetch(fetchParams).catch((err) => makeNetworkError(err)); + } + default: { + return Promise.resolve(makeNetworkError("unknown scheme")); + } + } + } + function finalizeResponse(fetchParams, response) { + fetchParams.request.done = true; + if (fetchParams.processResponseDone != null) { + queueMicrotask(() => fetchParams.processResponseDone(response)); + } + } + function fetchFinale(fetchParams, response) { + if (response.type === "error") { + response.urlList = [fetchParams.request.urlList[0]]; + response.timingInfo = createOpaqueTimingInfo({ + startTime: fetchParams.timingInfo.startTime + }); + } + const processResponseEndOfBody = () => { + fetchParams.request.done = true; + if (fetchParams.processResponseEndOfBody != null) { + queueMicrotask(() => fetchParams.processResponseEndOfBody(response)); + } + }; + if (fetchParams.processResponse != null) { + queueMicrotask(() => fetchParams.processResponse(response)); + } + if (response.body == null) { + processResponseEndOfBody(); + } else { + const identityTransformAlgorithm = (chunk, controller) => { + controller.enqueue(chunk); + }; + const transformStream = new TransformStream({ + start() { + }, + transform: identityTransformAlgorithm, + flush: processResponseEndOfBody + }, { + size() { + return 1; + } + }, { + size() { + return 1; + } + }); + response.body = { stream: response.body.stream.pipeThrough(transformStream) }; + } + if (fetchParams.processResponseConsumeBody != null) { + const processBody = (nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes); + const processBodyError = (failure) => fetchParams.processResponseConsumeBody(response, failure); + if (response.body == null) { + queueMicrotask(() => processBody(null)); + } else { + return fullyReadBody(response.body, processBody, processBodyError); + } + return Promise.resolve(); + } + } + async function httpFetch(fetchParams) { + const request = fetchParams.request; + let response = null; + let actualResponse = null; + const timingInfo = fetchParams.timingInfo; + if (request.serviceWorkers === "all") { + } + if (response === null) { + if (request.redirect === "follow") { + request.serviceWorkers = "none"; + } + actualResponse = response = await httpNetworkOrCacheFetch(fetchParams); + if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") { + return makeNetworkError("cors failure"); + } + if (TAOCheck(request, response) === "failure") { + request.timingAllowFailed = true; + } + } + if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck( + request.origin, + request.client, + request.destination, + actualResponse + ) === "blocked") { + return makeNetworkError("blocked"); + } + if (redirectStatusSet.has(actualResponse.status)) { + if (request.redirect !== "manual") { + fetchParams.controller.connection.destroy(); + } + if (request.redirect === "error") { + response = makeNetworkError("unexpected redirect"); + } else if (request.redirect === "manual") { + response = actualResponse; + } else if (request.redirect === "follow") { + response = await httpRedirectFetch(fetchParams, response); + } else { + assert(false); + } + } + response.timingInfo = timingInfo; + return response; + } + function httpRedirectFetch(fetchParams, response) { + const request = fetchParams.request; + const actualResponse = response.internalResponse ? response.internalResponse : response; + let locationURL; + try { + locationURL = responseLocationURL( + actualResponse, + requestCurrentURL(request).hash + ); + if (locationURL == null) { + return response; + } + } catch (err) { + return Promise.resolve(makeNetworkError(err)); + } + if (!urlIsHttpHttpsScheme(locationURL)) { + return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme")); + } + if (request.redirectCount === 20) { + return Promise.resolve(makeNetworkError("redirect count exceeded")); + } + request.redirectCount += 1; + if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) { + return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"')); + } + if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) { + return Promise.resolve(makeNetworkError( + 'URL cannot contain credentials for request mode "cors"' + )); + } + if (actualResponse.status !== 303 && request.body != null && request.body.source == null) { + return Promise.resolve(makeNetworkError()); + } + if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request.method)) { + request.method = "GET"; + request.body = null; + for (const headerName of requestBodyHeader) { + request.headersList.delete(headerName); + } + } + if (!sameOrigin(requestCurrentURL(request), locationURL)) { + request.headersList.delete("authorization"); + request.headersList.delete("proxy-authorization", true); + request.headersList.delete("cookie"); + request.headersList.delete("host"); + } + if (request.body != null) { + assert(request.body.source != null); + request.body = safelyExtractBody(request.body.source)[0]; + } + const timingInfo = fetchParams.timingInfo; + timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); + if (timingInfo.redirectStartTime === 0) { + timingInfo.redirectStartTime = timingInfo.startTime; + } + request.urlList.push(locationURL); + setRequestReferrerPolicyOnRedirect(request, actualResponse); + return mainFetch(fetchParams, true); + } + async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) { + const request = fetchParams.request; + let httpFetchParams = null; + let httpRequest = null; + let response = null; + const httpCache = null; + const revalidatingFlag = false; + if (request.window === "no-window" && request.redirect === "error") { + httpFetchParams = fetchParams; + httpRequest = request; + } else { + httpRequest = makeRequest(request); + httpFetchParams = { ...fetchParams }; + httpFetchParams.request = httpRequest; + } + const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic"; + const contentLength = httpRequest.body ? httpRequest.body.length : null; + let contentLengthHeaderValue = null; + if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) { + contentLengthHeaderValue = "0"; + } + if (contentLength != null) { + contentLengthHeaderValue = isomorphicEncode(`${contentLength}`); + } + if (contentLengthHeaderValue != null) { + httpRequest.headersList.append("content-length", contentLengthHeaderValue); + } + if (contentLength != null && httpRequest.keepalive) { + } + if (httpRequest.referrer instanceof URL) { + httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href)); + } + appendRequestOriginHeader(httpRequest); + appendFetchMetadata(httpRequest); + if (!httpRequest.headersList.contains("user-agent")) { + httpRequest.headersList.append("user-agent", typeof esbuildDetection === "undefined" ? "undici" : "node"); + } + if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) { + httpRequest.cache = "no-store"; + } + if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "max-age=0"); + } + if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") { + if (!httpRequest.headersList.contains("pragma")) { + httpRequest.headersList.append("pragma", "no-cache"); + } + if (!httpRequest.headersList.contains("cache-control")) { + httpRequest.headersList.append("cache-control", "no-cache"); + } + } + if (httpRequest.headersList.contains("range")) { + httpRequest.headersList.append("accept-encoding", "identity"); + } + if (!httpRequest.headersList.contains("accept-encoding")) { + if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) { + httpRequest.headersList.append("accept-encoding", "br, gzip, deflate"); + } else { + httpRequest.headersList.append("accept-encoding", "gzip, deflate"); + } + } + httpRequest.headersList.delete("host"); + if (includeCredentials) { + } + if (httpCache == null) { + httpRequest.cache = "no-store"; + } + if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") { + } + if (response == null) { + if (httpRequest.mode === "only-if-cached") { + return makeNetworkError("only if cached"); + } + const forwardResponse = await httpNetworkFetch( + httpFetchParams, + includeCredentials, + isNewConnectionFetch + ); + if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) { + } + if (revalidatingFlag && forwardResponse.status === 304) { + } + if (response == null) { + response = forwardResponse; + } + } + response.urlList = [...httpRequest.urlList]; + if (httpRequest.headersList.contains("range")) { + response.rangeRequested = true; + } + response.requestIncludesCredentials = includeCredentials; + if (response.status === 407) { + if (request.window === "no-window") { + return makeNetworkError(); + } + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + return makeNetworkError("proxy authentication required"); + } + if ( + // response’s status is 421 + response.status === 421 && // isNewConnectionFetch is false + !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null + (request.body == null || request.body.source != null) + ) { + if (isCancelled(fetchParams)) { + return makeAppropriateNetworkError(fetchParams); + } + fetchParams.controller.connection.destroy(); + response = await httpNetworkOrCacheFetch( + fetchParams, + isAuthenticationFetch, + true + ); + } + if (isAuthenticationFetch) { + } + return response; + } + async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) { + assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed); + fetchParams.controller.connection = { + abort: null, + destroyed: false, + destroy(err) { + if (!this.destroyed) { + this.destroyed = true; + this.abort?.(err ?? new DOMException2("The operation was aborted.", "AbortError")); + } + } + }; + const request = fetchParams.request; + let response = null; + const timingInfo = fetchParams.timingInfo; + const httpCache = null; + if (httpCache == null) { + request.cache = "no-store"; + } + const newConnection = forceNewConnection ? "yes" : "no"; + if (request.mode === "websocket") { + } else { + } + let requestBody = null; + if (request.body == null && fetchParams.processRequestEndOfBody) { + queueMicrotask(() => fetchParams.processRequestEndOfBody()); + } else if (request.body != null) { + const processBodyChunk = async function* (bytes) { + if (isCancelled(fetchParams)) { + return; + } + yield bytes; + fetchParams.processRequestBodyChunkLength?.(bytes.byteLength); + }; + const processEndOfBody = () => { + if (isCancelled(fetchParams)) { + return; + } + if (fetchParams.processRequestEndOfBody) { + fetchParams.processRequestEndOfBody(); + } + }; + const processBodyError = (e) => { + if (isCancelled(fetchParams)) { + return; + } + if (e.name === "AbortError") { + fetchParams.controller.abort(); + } else { + fetchParams.controller.terminate(e); + } + }; + requestBody = async function* () { + try { + for await (const bytes of request.body.stream) { + yield* processBodyChunk(bytes); + } + processEndOfBody(); + } catch (err) { + processBodyError(err); + } + }(); + } + try { + const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody }); + if (socket) { + response = makeResponse({ status, statusText, headersList, socket }); + } else { + const iterator = body[Symbol.asyncIterator](); + fetchParams.controller.next = () => iterator.next(); + response = makeResponse({ status, statusText, headersList }); + } + } catch (err) { + if (err.name === "AbortError") { + fetchParams.controller.connection.destroy(); + return makeAppropriateNetworkError(fetchParams, err); + } + return makeNetworkError(err); + } + const pullAlgorithm = () => { + fetchParams.controller.resume(); + }; + const cancelAlgorithm = (reason) => { + fetchParams.controller.abort(reason); + }; + if (!ReadableStream) { + ReadableStream = require("stream/web").ReadableStream; + } + const stream = new ReadableStream( + { + async start(controller) { + fetchParams.controller.controller = controller; + }, + async pull(controller) { + await pullAlgorithm(controller); + }, + async cancel(reason) { + await cancelAlgorithm(reason); + } + }, + { + highWaterMark: 0, + size() { + return 1; + } + } + ); + response.body = { stream }; + fetchParams.controller.on("terminated", onAborted); + fetchParams.controller.resume = async () => { + while (true) { + let bytes; + let isFailure; + try { + const { done, value } = await fetchParams.controller.next(); + if (isAborted(fetchParams)) { + break; + } + bytes = done ? void 0 : value; + } catch (err) { + if (fetchParams.controller.ended && !timingInfo.encodedBodySize) { + bytes = void 0; + } else { + bytes = err; + isFailure = true; + } + } + if (bytes === void 0) { + readableStreamClose(fetchParams.controller.controller); + finalizeResponse(fetchParams, response); + return; + } + timingInfo.decodedBodySize += bytes?.byteLength ?? 0; + if (isFailure) { + fetchParams.controller.terminate(bytes); + return; + } + fetchParams.controller.controller.enqueue(new Uint8Array(bytes)); + if (isErrored(stream)) { + fetchParams.controller.terminate(); + return; + } + if (!fetchParams.controller.controller.desiredSize) { + return; + } + } + }; + function onAborted(reason) { + if (isAborted(fetchParams)) { + response.aborted = true; + if (isReadable(stream)) { + fetchParams.controller.controller.error( + fetchParams.controller.serializedAbortReason + ); + } + } else { + if (isReadable(stream)) { + fetchParams.controller.controller.error(new TypeError("terminated", { + cause: isErrorLike(reason) ? reason : void 0 + })); + } + } + fetchParams.controller.connection.destroy(); + } + return response; + async function dispatch({ body }) { + const url = requestCurrentURL(request); + const agent = fetchParams.controller.dispatcher; + return new Promise((resolve, reject) => agent.dispatch( + { + path: url.pathname + url.search, + origin: url.origin, + method: request.method, + body: fetchParams.controller.dispatcher.isMockActive ? request.body && (request.body.source || request.body.stream) : body, + headers: request.headersList.entries, + maxRedirections: 0, + upgrade: request.mode === "websocket" ? "websocket" : void 0 + }, + { + body: null, + abort: null, + onConnect(abort) { + const { connection } = fetchParams.controller; + if (connection.destroyed) { + abort(new DOMException2("The operation was aborted.", "AbortError")); + } else { + fetchParams.controller.on("terminated", abort); + this.abort = connection.abort = abort; + } + }, + onHeaders(status, headersList, resume, statusText) { + if (status < 200) { + return; + } + let codings = []; + let location = ""; + const headers = new Headers2(); + if (Array.isArray(headersList)) { + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } else { + const keys = Object.keys(headersList); + for (const key of keys) { + const val = headersList[key]; + if (key.toLowerCase() === "content-encoding") { + codings = val.toLowerCase().split(",").map((x) => x.trim()).reverse(); + } else if (key.toLowerCase() === "location") { + location = val; + } + headers[kHeadersList].append(key, val); + } + } + this.body = new Readable({ read: resume }); + const decoders = []; + const willFollow = request.redirect === "follow" && location && redirectStatusSet.has(status); + if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) { + for (const coding of codings) { + if (coding === "x-gzip" || coding === "gzip") { + decoders.push(zlib.createGunzip({ + // 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. + flush: zlib.constants.Z_SYNC_FLUSH, + finishFlush: zlib.constants.Z_SYNC_FLUSH + })); + } else if (coding === "deflate") { + decoders.push(zlib.createInflate()); + } else if (coding === "br") { + decoders.push(zlib.createBrotliDecompress()); + } else { + decoders.length = 0; + break; + } + } + } + resolve({ + status, + statusText, + headersList: headers[kHeadersList], + body: decoders.length ? pipeline(this.body, ...decoders, () => { + }) : this.body.on("error", () => { + }) + }); + return true; + }, + onData(chunk) { + if (fetchParams.controller.dump) { + return; + } + const bytes = chunk; + timingInfo.encodedBodySize += bytes.byteLength; + return this.body.push(bytes); + }, + onComplete() { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + fetchParams.controller.ended = true; + this.body.push(null); + }, + onError(error) { + if (this.abort) { + fetchParams.controller.off("terminated", this.abort); + } + this.body?.destroy(error); + fetchParams.controller.terminate(error); + reject(error); + }, + onUpgrade(status, headersList, socket) { + if (status !== 101) { + return; + } + const headers = new Headers2(); + for (let n = 0; n < headersList.length; n += 2) { + const key = headersList[n + 0].toString("latin1"); + const val = headersList[n + 1].toString("latin1"); + headers[kHeadersList].append(key, val); + } + resolve({ + status, + statusText: STATUS_CODES[status], + headersList: headers[kHeadersList], + socket + }); + return true; + } + } + )); + } + } + module2.exports = { + fetch: fetch2, + Fetch, + fetching, + finalizeAndReportTiming + }; + } +}); + +// node_modules/undici/lib/fileapi/symbols.js +var require_symbols3 = __commonJS({ + "node_modules/undici/lib/fileapi/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kState: Symbol("FileReader state"), + kResult: Symbol("FileReader result"), + kError: Symbol("FileReader error"), + kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"), + kEvents: Symbol("FileReader events"), + kAborted: Symbol("FileReader aborted") + }; + } +}); + +// node_modules/undici/lib/fileapi/progressevent.js +var require_progressevent = __commonJS({ + "node_modules/undici/lib/fileapi/progressevent.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var kState = Symbol("ProgressEvent state"); + var ProgressEvent = class _ProgressEvent extends Event { + constructor(type, eventInitDict = {}) { + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {}); + super(type, eventInitDict); + this[kState] = { + lengthComputable: eventInitDict.lengthComputable, + loaded: eventInitDict.loaded, + total: eventInitDict.total + }; + } + get lengthComputable() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].lengthComputable; + } + get loaded() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].loaded; + } + get total() { + webidl.brandCheck(this, _ProgressEvent); + return this[kState].total; + } + }; + webidl.converters.ProgressEventInit = webidl.dictionaryConverter([ + { + key: "lengthComputable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "loaded", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "total", + converter: webidl.converters["unsigned long long"], + defaultValue: 0 + }, + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]); + module2.exports = { + ProgressEvent + }; + } +}); + +// node_modules/undici/lib/fileapi/encoding.js +var require_encoding = __commonJS({ + "node_modules/undici/lib/fileapi/encoding.js"(exports2, module2) { + "use strict"; + function getEncoding(label) { + if (!label) { + return "failure"; + } + switch (label.trim().toLowerCase()) { + case "unicode-1-1-utf-8": + case "unicode11utf8": + case "unicode20utf8": + case "utf-8": + case "utf8": + case "x-unicode20utf8": + return "UTF-8"; + case "866": + case "cp866": + case "csibm866": + case "ibm866": + return "IBM866"; + case "csisolatin2": + case "iso-8859-2": + case "iso-ir-101": + case "iso8859-2": + case "iso88592": + case "iso_8859-2": + case "iso_8859-2:1987": + case "l2": + case "latin2": + return "ISO-8859-2"; + case "csisolatin3": + case "iso-8859-3": + case "iso-ir-109": + case "iso8859-3": + case "iso88593": + case "iso_8859-3": + case "iso_8859-3:1988": + case "l3": + case "latin3": + return "ISO-8859-3"; + case "csisolatin4": + case "iso-8859-4": + case "iso-ir-110": + case "iso8859-4": + case "iso88594": + case "iso_8859-4": + case "iso_8859-4:1988": + case "l4": + case "latin4": + return "ISO-8859-4"; + case "csisolatincyrillic": + case "cyrillic": + case "iso-8859-5": + case "iso-ir-144": + case "iso8859-5": + case "iso88595": + case "iso_8859-5": + case "iso_8859-5:1988": + return "ISO-8859-5"; + case "arabic": + case "asmo-708": + case "csiso88596e": + case "csiso88596i": + case "csisolatinarabic": + case "ecma-114": + case "iso-8859-6": + case "iso-8859-6-e": + case "iso-8859-6-i": + case "iso-ir-127": + case "iso8859-6": + case "iso88596": + case "iso_8859-6": + case "iso_8859-6:1987": + return "ISO-8859-6"; + case "csisolatingreek": + case "ecma-118": + case "elot_928": + case "greek": + case "greek8": + case "iso-8859-7": + case "iso-ir-126": + case "iso8859-7": + case "iso88597": + case "iso_8859-7": + case "iso_8859-7:1987": + case "sun_eu_greek": + return "ISO-8859-7"; + case "csiso88598e": + case "csisolatinhebrew": + case "hebrew": + case "iso-8859-8": + case "iso-8859-8-e": + case "iso-ir-138": + case "iso8859-8": + case "iso88598": + case "iso_8859-8": + case "iso_8859-8:1988": + case "visual": + return "ISO-8859-8"; + case "csiso88598i": + case "iso-8859-8-i": + case "logical": + return "ISO-8859-8-I"; + case "csisolatin6": + case "iso-8859-10": + case "iso-ir-157": + case "iso8859-10": + case "iso885910": + case "l6": + case "latin6": + return "ISO-8859-10"; + case "iso-8859-13": + case "iso8859-13": + case "iso885913": + return "ISO-8859-13"; + case "iso-8859-14": + case "iso8859-14": + case "iso885914": + return "ISO-8859-14"; + case "csisolatin9": + case "iso-8859-15": + case "iso8859-15": + case "iso885915": + case "iso_8859-15": + case "l9": + return "ISO-8859-15"; + case "iso-8859-16": + return "ISO-8859-16"; + case "cskoi8r": + case "koi": + case "koi8": + case "koi8-r": + case "koi8_r": + return "KOI8-R"; + case "koi8-ru": + case "koi8-u": + return "KOI8-U"; + case "csmacintosh": + case "mac": + case "macintosh": + case "x-mac-roman": + return "macintosh"; + case "iso-8859-11": + case "iso8859-11": + case "iso885911": + case "tis-620": + case "windows-874": + return "windows-874"; + case "cp1250": + case "windows-1250": + case "x-cp1250": + return "windows-1250"; + case "cp1251": + case "windows-1251": + case "x-cp1251": + return "windows-1251"; + case "ansi_x3.4-1968": + case "ascii": + case "cp1252": + case "cp819": + case "csisolatin1": + case "ibm819": + case "iso-8859-1": + case "iso-ir-100": + case "iso8859-1": + case "iso88591": + case "iso_8859-1": + case "iso_8859-1:1987": + case "l1": + case "latin1": + case "us-ascii": + case "windows-1252": + case "x-cp1252": + return "windows-1252"; + case "cp1253": + case "windows-1253": + case "x-cp1253": + return "windows-1253"; + case "cp1254": + case "csisolatin5": + case "iso-8859-9": + case "iso-ir-148": + case "iso8859-9": + case "iso88599": + case "iso_8859-9": + case "iso_8859-9:1989": + case "l5": + case "latin5": + case "windows-1254": + case "x-cp1254": + return "windows-1254"; + case "cp1255": + case "windows-1255": + case "x-cp1255": + return "windows-1255"; + case "cp1256": + case "windows-1256": + case "x-cp1256": + return "windows-1256"; + case "cp1257": + case "windows-1257": + case "x-cp1257": + return "windows-1257"; + case "cp1258": + case "windows-1258": + case "x-cp1258": + return "windows-1258"; + case "x-mac-cyrillic": + case "x-mac-ukrainian": + return "x-mac-cyrillic"; + case "chinese": + case "csgb2312": + case "csiso58gb231280": + case "gb2312": + case "gb_2312": + case "gb_2312-80": + case "gbk": + case "iso-ir-58": + case "x-gbk": + return "GBK"; + case "gb18030": + return "gb18030"; + case "big5": + case "big5-hkscs": + case "cn-big5": + case "csbig5": + case "x-x-big5": + return "Big5"; + case "cseucpkdfmtjapanese": + case "euc-jp": + case "x-euc-jp": + return "EUC-JP"; + case "csiso2022jp": + case "iso-2022-jp": + return "ISO-2022-JP"; + case "csshiftjis": + case "ms932": + case "ms_kanji": + case "shift-jis": + case "shift_jis": + case "sjis": + case "windows-31j": + case "x-sjis": + return "Shift_JIS"; + case "cseuckr": + case "csksc56011987": + case "euc-kr": + case "iso-ir-149": + case "korean": + case "ks_c_5601-1987": + case "ks_c_5601-1989": + case "ksc5601": + case "ksc_5601": + case "windows-949": + return "EUC-KR"; + case "csiso2022kr": + case "hz-gb-2312": + case "iso-2022-cn": + case "iso-2022-cn-ext": + case "iso-2022-kr": + case "replacement": + return "replacement"; + case "unicodefffe": + case "utf-16be": + return "UTF-16BE"; + case "csunicode": + case "iso-10646-ucs-2": + case "ucs-2": + case "unicode": + case "unicodefeff": + case "utf-16": + case "utf-16le": + return "UTF-16LE"; + case "x-user-defined": + return "x-user-defined"; + default: + return "failure"; + } + } + module2.exports = { + getEncoding + }; + } +}); + +// node_modules/undici/lib/fileapi/util.js +var require_util4 = __commonJS({ + "node_modules/undici/lib/fileapi/util.js"(exports2, module2) { + "use strict"; + var { + kState, + kError, + kResult, + kAborted, + kLastProgressEventFired + } = require_symbols3(); + var { ProgressEvent } = require_progressevent(); + var { getEncoding } = require_encoding(); + var { DOMException: DOMException2 } = require_constants2(); + var { serializeAMimeType, parseMIMEType } = require_dataURL(); + var { types } = require("util"); + var { StringDecoder } = require("string_decoder"); + var { btoa } = require("buffer"); + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + function readOperation(fr, blob, type, encodingName) { + if (fr[kState] === "loading") { + throw new DOMException2("Invalid state", "InvalidStateError"); + } + fr[kState] = "loading"; + fr[kResult] = null; + fr[kError] = null; + const stream = blob.stream(); + const reader = stream.getReader(); + const bytes = []; + let chunkPromise = reader.read(); + let isFirstChunk = true; + (async () => { + while (!fr[kAborted]) { + try { + const { done, value } = await chunkPromise; + if (isFirstChunk && !fr[kAborted]) { + queueMicrotask(() => { + fireAProgressEvent("loadstart", fr); + }); + } + isFirstChunk = false; + if (!done && types.isUint8Array(value)) { + bytes.push(value); + if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) { + fr[kLastProgressEventFired] = Date.now(); + queueMicrotask(() => { + fireAProgressEvent("progress", fr); + }); + } + chunkPromise = reader.read(); + } else if (done) { + queueMicrotask(() => { + fr[kState] = "done"; + try { + const result = packageData(bytes, type, blob.type, encodingName); + if (fr[kAborted]) { + return; + } + fr[kResult] = result; + fireAProgressEvent("load", fr); + } catch (error) { + fr[kError] = error; + fireAProgressEvent("error", fr); + } + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } catch (error) { + if (fr[kAborted]) { + return; + } + queueMicrotask(() => { + fr[kState] = "done"; + fr[kError] = error; + fireAProgressEvent("error", fr); + if (fr[kState] !== "loading") { + fireAProgressEvent("loadend", fr); + } + }); + break; + } + } + })(); + } + function fireAProgressEvent(e, reader) { + const event = new ProgressEvent(e, { + bubbles: false, + cancelable: false + }); + reader.dispatchEvent(event); + } + function packageData(bytes, type, mimeType, encodingName) { + switch (type) { + case "DataURL": { + let dataURL = "data:"; + const parsed = parseMIMEType(mimeType || "application/octet-stream"); + if (parsed !== "failure") { + dataURL += serializeAMimeType(parsed); + } + dataURL += ";base64,"; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + dataURL += btoa(decoder.write(chunk)); + } + dataURL += btoa(decoder.end()); + return dataURL; + } + case "Text": { + let encoding = "failure"; + if (encodingName) { + encoding = getEncoding(encodingName); + } + if (encoding === "failure" && mimeType) { + const type2 = parseMIMEType(mimeType); + if (type2 !== "failure") { + encoding = getEncoding(type2.parameters.get("charset")); + } + } + if (encoding === "failure") { + encoding = "UTF-8"; + } + return decode(bytes, encoding); + } + case "ArrayBuffer": { + const sequence = combineByteSequences(bytes); + return sequence.buffer; + } + case "BinaryString": { + let binaryString = ""; + const decoder = new StringDecoder("latin1"); + for (const chunk of bytes) { + binaryString += decoder.write(chunk); + } + binaryString += decoder.end(); + return binaryString; + } + } + } + function decode(ioQueue, encoding) { + const bytes = combineByteSequences(ioQueue); + const BOMEncoding = BOMSniffing(bytes); + let slice = 0; + if (BOMEncoding !== null) { + encoding = BOMEncoding; + slice = BOMEncoding === "UTF-8" ? 3 : 2; + } + const sliced = bytes.slice(slice); + return new TextDecoder(encoding).decode(sliced); + } + function BOMSniffing(ioQueue) { + const [a, b, c] = ioQueue; + if (a === 239 && b === 187 && c === 191) { + return "UTF-8"; + } else if (a === 254 && b === 255) { + return "UTF-16BE"; + } else if (a === 255 && b === 254) { + return "UTF-16LE"; + } + return null; + } + function combineByteSequences(sequences) { + const size = sequences.reduce((a, b) => { + return a + b.byteLength; + }, 0); + let offset = 0; + return sequences.reduce((a, b) => { + a.set(b, offset); + offset += b.byteLength; + return a; + }, new Uint8Array(size)); + } + module2.exports = { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + }; + } +}); + +// node_modules/undici/lib/fileapi/filereader.js +var require_filereader = __commonJS({ + "node_modules/undici/lib/fileapi/filereader.js"(exports2, module2) { + "use strict"; + var { + staticPropertyDescriptors, + readOperation, + fireAProgressEvent + } = require_util4(); + var { + kState, + kError, + kResult, + kEvents, + kAborted + } = require_symbols3(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var FileReader = class _FileReader extends EventTarget { + constructor() { + super(); + this[kState] = "empty"; + this[kResult] = null; + this[kError] = null; + this[kEvents] = { + loadend: null, + error: null, + abort: null, + load: null, + progress: null, + loadstart: null + }; + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer + * @param {import('buffer').Blob} blob + */ + readAsArrayBuffer(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "ArrayBuffer"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsBinaryString + * @param {import('buffer').Blob} blob + */ + readAsBinaryString(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "BinaryString"); + } + /** + * @see https://w3c.github.io/FileAPI/#readAsDataText + * @param {import('buffer').Blob} blob + * @param {string?} encoding + */ + readAsText(blob, encoding = void 0) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" }); + blob = webidl.converters.Blob(blob, { strict: false }); + if (encoding !== void 0) { + encoding = webidl.converters.DOMString(encoding); + } + readOperation(this, blob, "Text", encoding); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL + * @param {import('buffer').Blob} blob + */ + readAsDataURL(blob) { + webidl.brandCheck(this, _FileReader); + webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" }); + blob = webidl.converters.Blob(blob, { strict: false }); + readOperation(this, blob, "DataURL"); + } + /** + * @see https://w3c.github.io/FileAPI/#dfn-abort + */ + abort() { + if (this[kState] === "empty" || this[kState] === "done") { + this[kResult] = null; + return; + } + if (this[kState] === "loading") { + this[kState] = "done"; + this[kResult] = null; + } + this[kAborted] = true; + fireAProgressEvent("abort", this); + if (this[kState] !== "loading") { + fireAProgressEvent("loadend", this); + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate + */ + get readyState() { + webidl.brandCheck(this, _FileReader); + switch (this[kState]) { + case "empty": + return this.EMPTY; + case "loading": + return this.LOADING; + case "done": + return this.DONE; + } + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-result + */ + get result() { + webidl.brandCheck(this, _FileReader); + return this[kResult]; + } + /** + * @see https://w3c.github.io/FileAPI/#dom-filereader-error + */ + get error() { + webidl.brandCheck(this, _FileReader); + return this[kError]; + } + get onloadend() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadend; + } + set onloadend(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadend) { + this.removeEventListener("loadend", this[kEvents].loadend); + } + if (typeof fn === "function") { + this[kEvents].loadend = fn; + this.addEventListener("loadend", fn); + } else { + this[kEvents].loadend = null; + } + } + get onerror() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].error; + } + set onerror(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].error) { + this.removeEventListener("error", this[kEvents].error); + } + if (typeof fn === "function") { + this[kEvents].error = fn; + this.addEventListener("error", fn); + } else { + this[kEvents].error = null; + } + } + get onloadstart() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].loadstart; + } + set onloadstart(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].loadstart) { + this.removeEventListener("loadstart", this[kEvents].loadstart); + } + if (typeof fn === "function") { + this[kEvents].loadstart = fn; + this.addEventListener("loadstart", fn); + } else { + this[kEvents].loadstart = null; + } + } + get onprogress() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].progress; + } + set onprogress(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].progress) { + this.removeEventListener("progress", this[kEvents].progress); + } + if (typeof fn === "function") { + this[kEvents].progress = fn; + this.addEventListener("progress", fn); + } else { + this[kEvents].progress = null; + } + } + get onload() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].load; + } + set onload(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].load) { + this.removeEventListener("load", this[kEvents].load); + } + if (typeof fn === "function") { + this[kEvents].load = fn; + this.addEventListener("load", fn); + } else { + this[kEvents].load = null; + } + } + get onabort() { + webidl.brandCheck(this, _FileReader); + return this[kEvents].abort; + } + set onabort(fn) { + webidl.brandCheck(this, _FileReader); + if (this[kEvents].abort) { + this.removeEventListener("abort", this[kEvents].abort); + } + if (typeof fn === "function") { + this[kEvents].abort = fn; + this.addEventListener("abort", fn); + } else { + this[kEvents].abort = null; + } + } + }; + FileReader.EMPTY = FileReader.prototype.EMPTY = 0; + FileReader.LOADING = FileReader.prototype.LOADING = 1; + FileReader.DONE = FileReader.prototype.DONE = 2; + Object.defineProperties(FileReader.prototype, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors, + readAsArrayBuffer: kEnumerableProperty, + readAsBinaryString: kEnumerableProperty, + readAsText: kEnumerableProperty, + readAsDataURL: kEnumerableProperty, + abort: kEnumerableProperty, + readyState: kEnumerableProperty, + result: kEnumerableProperty, + error: kEnumerableProperty, + onloadstart: kEnumerableProperty, + onprogress: kEnumerableProperty, + onload: kEnumerableProperty, + onabort: kEnumerableProperty, + onerror: kEnumerableProperty, + onloadend: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "FileReader", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(FileReader, { + EMPTY: staticPropertyDescriptors, + LOADING: staticPropertyDescriptors, + DONE: staticPropertyDescriptors + }); + module2.exports = { + FileReader + }; + } +}); + +// node_modules/undici/lib/cache/symbols.js +var require_symbols4 = __commonJS({ + "node_modules/undici/lib/cache/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kConstruct: require_symbols().kConstruct + }; + } +}); + +// node_modules/undici/lib/cache/util.js +var require_util5 = __commonJS({ + "node_modules/undici/lib/cache/util.js"(exports2, module2) { + "use strict"; + var assert = require("assert"); + var { URLSerializer } = require_dataURL(); + var { isValidHeaderName } = require_util2(); + function urlEquals(A, B, excludeFragment = false) { + const serializedA = URLSerializer(A, excludeFragment); + const serializedB = URLSerializer(B, excludeFragment); + return serializedA === serializedB; + } + function fieldValues(header) { + assert(header !== null); + const values = []; + for (let value of header.split(",")) { + value = value.trim(); + if (!value.length) { + continue; + } else if (!isValidHeaderName(value)) { + continue; + } + values.push(value); + } + return values; + } + module2.exports = { + urlEquals, + fieldValues + }; + } +}); + +// node_modules/undici/lib/cache/cache.js +var require_cache = __commonJS({ + "node_modules/undici/lib/cache/cache.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { urlEquals, fieldValues: getFieldValues } = require_util5(); + var { kEnumerableProperty, isDisturbed } = require_util(); + var { kHeadersList } = require_symbols(); + var { webidl } = require_webidl(); + var { Response: Response2, cloneResponse } = require_response(); + var { Request } = require_request2(); + var { kState, kHeaders, kGuard, kRealm } = require_symbols2(); + var { fetching } = require_fetch(); + var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util2(); + var assert = require("assert"); + var { getGlobalDispatcher } = require_global2(); + var Cache3 = class _Cache { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list + * @type {requestResponseList} + */ + #relevantRequestResponseList; + constructor() { + if (arguments[0] !== kConstruct) { + webidl.illegalConstructor(); + } + this.#relevantRequestResponseList = arguments[1]; + } + async match(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.match" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + const p = await this.matchAll(request, options); + if (p.length === 0) { + return; + } + return p[0]; + } + async matchAll(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } + } + const responses = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + responses.push(requestResponse[1]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + responses.push(requestResponse[1]); + } + } + const responseList = []; + for (const response of responses) { + const responseObject = new Response2(response.body?.source ?? null); + const body = responseObject[kState].body; + responseObject[kState] = response; + responseObject[kState].body = body; + responseObject[kHeaders][kHeadersList] = response.headersList; + responseObject[kHeaders][kGuard] = "immutable"; + responseList.push(responseObject); + } + return Object.freeze(responseList); + } + async add(request) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.add" }); + request = webidl.converters.RequestInfo(request); + const requests = [request]; + const responseArrayPromise = this.addAll(requests); + return await responseArrayPromise; + } + async addAll(requests) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.addAll" }); + requests = webidl.converters["sequence"](requests); + const responsePromises = []; + const requestList = []; + for (const request of requests) { + if (typeof request === "string") { + continue; + } + const r = request[kState]; + if (!urlIsHttpHttpsScheme(r.url) || r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme when method is not GET." + }); + } + } + const fetchControllers = []; + for (const request of requests) { + const r = new Request(request)[kState]; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.addAll", + message: "Expected http/s scheme." + }); + } + r.initiator = "fetch"; + r.destination = "subresource"; + requestList.push(r); + const responsePromise = createDeferredPromise(); + fetchControllers.push(fetching({ + request: r, + dispatcher: getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "Received an invalid status code or the request failed." + })); + } else if (response.headersList.contains("vary")) { + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + responsePromise.reject(webidl.errors.exception({ + header: "Cache.addAll", + message: "invalid vary field value" + })); + for (const controller of fetchControllers) { + controller.abort(); + } + return; + } + } + } + }, + processResponseEndOfBody(response) { + if (response.aborted) { + responsePromise.reject(new DOMException("aborted", "AbortError")); + return; + } + responsePromise.resolve(response); + } + })); + responsePromises.push(responsePromise.promise); + } + const p = Promise.all(responsePromises); + const responses = await p; + const operations = []; + let index = 0; + for (const response of responses) { + const operation = { + type: "put", + // 7.3.2 + request: requestList[index], + // 7.3.3 + response + // 7.3.4 + }; + operations.push(operation); + index++; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(void 0); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async put(request, response) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 2, { header: "Cache.put" }); + request = webidl.converters.RequestInfo(request); + response = webidl.converters.Response(response); + let innerRequest = null; + if (request instanceof Request) { + innerRequest = request[kState]; + } else { + innerRequest = new Request(request)[kState]; + } + if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Expected an http/s scheme when method is not GET" + }); + } + const innerResponse = response[kState]; + if (innerResponse.status === 206) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got 206 status" + }); + } + if (innerResponse.headersList.contains("vary")) { + const fieldValues = getFieldValues(innerResponse.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Got * vary field value" + }); + } + } + } + if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) { + throw webidl.errors.exception({ + header: "Cache.put", + message: "Response body is locked or disturbed" + }); + } + const clonedResponse = cloneResponse(innerResponse); + const bodyReadPromise = createDeferredPromise(); + if (innerResponse.body != null) { + const stream = innerResponse.body.stream; + const reader = stream.getReader(); + readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject); + } else { + bodyReadPromise.resolve(void 0); + } + const operations = []; + const operation = { + type: "put", + // 14. + request: innerRequest, + // 15. + response: clonedResponse + // 16. + }; + operations.push(operation); + const bytes = await bodyReadPromise.promise; + if (clonedResponse.body != null) { + clonedResponse.body.source = bytes; + } + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + try { + this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + async delete(request, options = {}) { + webidl.brandCheck(this, _Cache); + webidl.argumentLengthCheck(arguments, 1, { header: "Cache.delete" }); + request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return false; + } + } else { + assert(typeof request === "string"); + r = new Request(request)[kState]; + } + const operations = []; + const operation = { + type: "delete", + request: r, + options + }; + operations.push(operation); + const cacheJobPromise = createDeferredPromise(); + let errorData = null; + let requestResponses; + try { + requestResponses = this.#batchCacheOperations(operations); + } catch (e) { + errorData = e; + } + queueMicrotask(() => { + if (errorData === null) { + cacheJobPromise.resolve(!!requestResponses?.length); + } else { + cacheJobPromise.reject(errorData); + } + }); + return cacheJobPromise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys + * @param {any} request + * @param {import('../../types/cache').CacheQueryOptions} options + * @returns {readonly Request[]} + */ + async keys(request = void 0, options = {}) { + webidl.brandCheck(this, _Cache); + if (request !== void 0) request = webidl.converters.RequestInfo(request); + options = webidl.converters.CacheQueryOptions(options); + let r = null; + if (request !== void 0) { + if (request instanceof Request) { + r = request[kState]; + if (r.method !== "GET" && !options.ignoreMethod) { + return []; + } + } else if (typeof request === "string") { + r = new Request(request)[kState]; + } + } + const promise = createDeferredPromise(); + const requests = []; + if (request === void 0) { + for (const requestResponse of this.#relevantRequestResponseList) { + requests.push(requestResponse[0]); + } + } else { + const requestResponses = this.#queryCache(r, options); + for (const requestResponse of requestResponses) { + requests.push(requestResponse[0]); + } + } + queueMicrotask(() => { + const requestList = []; + for (const request2 of requests) { + const requestObject = new Request("https://a"); + requestObject[kState] = request2; + requestObject[kHeaders][kHeadersList] = request2.headersList; + requestObject[kHeaders][kGuard] = "immutable"; + requestObject[kRealm] = request2.client; + requestList.push(requestObject); + } + promise.resolve(Object.freeze(requestList)); + }); + return promise.promise; + } + /** + * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm + * @param {CacheBatchOperation[]} operations + * @returns {requestResponseList} + */ + #batchCacheOperations(operations) { + const cache = this.#relevantRequestResponseList; + const backupCache = [...cache]; + const addedItems = []; + const resultList = []; + try { + for (const operation of operations) { + if (operation.type !== "delete" && operation.type !== "put") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: 'operation type does not match "delete" or "put"' + }); + } + if (operation.type === "delete" && operation.response != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "delete operation should not have an associated response" + }); + } + if (this.#queryCache(operation.request, operation.options, addedItems).length) { + throw new DOMException("???", "InvalidStateError"); + } + let requestResponses; + if (operation.type === "delete") { + requestResponses = this.#queryCache(operation.request, operation.options); + if (requestResponses.length === 0) { + return []; + } + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + } else if (operation.type === "put") { + if (operation.response == null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "put operation should have an associated response" + }); + } + const r = operation.request; + if (!urlIsHttpHttpsScheme(r.url)) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "expected http or https scheme" + }); + } + if (r.method !== "GET") { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "not get method" + }); + } + if (operation.options != null) { + throw webidl.errors.exception({ + header: "Cache.#batchCacheOperations", + message: "options must not be defined" + }); + } + requestResponses = this.#queryCache(operation.request); + for (const requestResponse of requestResponses) { + const idx = cache.indexOf(requestResponse); + assert(idx !== -1); + cache.splice(idx, 1); + } + cache.push([operation.request, operation.response]); + addedItems.push([operation.request, operation.response]); + } + resultList.push([operation.request, operation.response]); + } + return resultList; + } catch (e) { + this.#relevantRequestResponseList.length = 0; + this.#relevantRequestResponseList = backupCache; + throw e; + } + } + /** + * @see https://w3c.github.io/ServiceWorker/#query-cache + * @param {any} requestQuery + * @param {import('../../types/cache').CacheQueryOptions} options + * @param {requestResponseList} targetStorage + * @returns {requestResponseList} + */ + #queryCache(requestQuery, options, targetStorage) { + const resultList = []; + const storage = targetStorage ?? this.#relevantRequestResponseList; + for (const requestResponse of storage) { + const [cachedRequest, cachedResponse] = requestResponse; + if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) { + resultList.push(requestResponse); + } + } + return resultList; + } + /** + * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm + * @param {any} requestQuery + * @param {any} request + * @param {any | null} response + * @param {import('../../types/cache').CacheQueryOptions | undefined} options + * @returns {boolean} + */ + #requestMatchesCachedItem(requestQuery, request, response = null, options) { + const queryURL = new URL(requestQuery.url); + const cachedURL = new URL(request.url); + if (options?.ignoreSearch) { + cachedURL.search = ""; + queryURL.search = ""; + } + if (!urlEquals(queryURL, cachedURL, true)) { + return false; + } + if (response == null || options?.ignoreVary || !response.headersList.contains("vary")) { + return true; + } + const fieldValues = getFieldValues(response.headersList.get("vary")); + for (const fieldValue of fieldValues) { + if (fieldValue === "*") { + return false; + } + const requestValue = request.headersList.get(fieldValue); + const queryValue = requestQuery.headersList.get(fieldValue); + if (requestValue !== queryValue) { + return false; + } + } + return true; + } + }; + Object.defineProperties(Cache3.prototype, { + [Symbol.toStringTag]: { + value: "Cache", + configurable: true + }, + match: kEnumerableProperty, + matchAll: kEnumerableProperty, + add: kEnumerableProperty, + addAll: kEnumerableProperty, + put: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + var cacheQueryOptionConverters = [ + { + key: "ignoreSearch", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreMethod", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "ignoreVary", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters); + webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([ + ...cacheQueryOptionConverters, + { + key: "cacheName", + converter: webidl.converters.DOMString + } + ]); + webidl.converters.Response = webidl.interfaceConverter(Response2); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.RequestInfo + ); + module2.exports = { + Cache: Cache3 + }; + } +}); + +// node_modules/undici/lib/cache/cachestorage.js +var require_cachestorage = __commonJS({ + "node_modules/undici/lib/cache/cachestorage.js"(exports2, module2) { + "use strict"; + var { kConstruct } = require_symbols4(); + var { Cache: Cache3 } = require_cache(); + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var CacheStorage = class _CacheStorage { + /** + * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map + * @type {Map} + */ + async has(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.has" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.has(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open + * @param {string} cacheName + * @returns {Promise} + */ + async open(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.open" }); + cacheName = webidl.converters.DOMString(cacheName); + if (this.#caches.has(cacheName)) { + const cache2 = this.#caches.get(cacheName); + return new Cache3(kConstruct, cache2); + } + const cache = []; + this.#caches.set(cacheName, cache); + return new Cache3(kConstruct, cache); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete + * @param {string} cacheName + * @returns {Promise} + */ + async delete(cacheName) { + webidl.brandCheck(this, _CacheStorage); + webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.delete" }); + cacheName = webidl.converters.DOMString(cacheName); + return this.#caches.delete(cacheName); + } + /** + * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys + * @returns {string[]} + */ + async keys() { + webidl.brandCheck(this, _CacheStorage); + const keys = this.#caches.keys(); + return [...keys]; + } + }; + Object.defineProperties(CacheStorage.prototype, { + [Symbol.toStringTag]: { + value: "CacheStorage", + configurable: true + }, + match: kEnumerableProperty, + has: kEnumerableProperty, + open: kEnumerableProperty, + delete: kEnumerableProperty, + keys: kEnumerableProperty + }); + module2.exports = { + CacheStorage + }; + } +}); + +// node_modules/undici/lib/cookies/constants.js +var require_constants4 = __commonJS({ + "node_modules/undici/lib/cookies/constants.js"(exports2, module2) { + "use strict"; + var maxAttributeValueSize = 1024; + var maxNameValuePairSize = 4096; + module2.exports = { + maxAttributeValueSize, + maxNameValuePairSize + }; + } +}); + +// node_modules/undici/lib/cookies/util.js +var require_util6 = __commonJS({ + "node_modules/undici/lib/cookies/util.js"(exports2, module2) { + "use strict"; + function isCTLExcludingHtab(value) { + if (value.length === 0) { + return false; + } + for (const char of value) { + const code = char.charCodeAt(0); + if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) { + return false; + } + } + } + function validateCookieName(name) { + for (const char of name) { + const code = char.charCodeAt(0); + if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") { + throw new Error("Invalid cookie name"); + } + } + } + function validateCookieValue(value) { + for (const char of value) { + const code = char.charCodeAt(0); + if (code < 33 || // exclude CTLs (0-31) + code === 34 || code === 44 || code === 59 || code === 92 || code > 126) { + throw new Error("Invalid header value"); + } + } + } + function validateCookiePath(path3) { + for (const char of path3) { + const code = char.charCodeAt(0); + if (code < 33 || char === ";") { + throw new Error("Invalid cookie path"); + } + } + } + function validateCookieDomain(domain) { + if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) { + throw new Error("Invalid cookie domain"); + } + } + function toIMFDate(date) { + if (typeof date === "number") { + date = new Date(date); + } + const days = [ + "Sun", + "Mon", + "Tue", + "Wed", + "Thu", + "Fri", + "Sat" + ]; + const months = [ + "Jan", + "Feb", + "Mar", + "Apr", + "May", + "Jun", + "Jul", + "Aug", + "Sep", + "Oct", + "Nov", + "Dec" + ]; + const dayName = days[date.getUTCDay()]; + const day = date.getUTCDate().toString().padStart(2, "0"); + const month = months[date.getUTCMonth()]; + const year = date.getUTCFullYear(); + const hour = date.getUTCHours().toString().padStart(2, "0"); + const minute = date.getUTCMinutes().toString().padStart(2, "0"); + const second = date.getUTCSeconds().toString().padStart(2, "0"); + return `${dayName}, ${day} ${month} ${year} ${hour}:${minute}:${second} GMT`; + } + function validateCookieMaxAge(maxAge) { + if (maxAge < 0) { + throw new Error("Invalid cookie max-age"); + } + } + function stringify3(cookie) { + if (cookie.name.length === 0) { + return null; + } + validateCookieName(cookie.name); + validateCookieValue(cookie.value); + const out = [`${cookie.name}=${cookie.value}`]; + if (cookie.name.startsWith("__Secure-")) { + cookie.secure = true; + } + if (cookie.name.startsWith("__Host-")) { + cookie.secure = true; + cookie.domain = null; + cookie.path = "/"; + } + if (cookie.secure) { + out.push("Secure"); + } + if (cookie.httpOnly) { + out.push("HttpOnly"); + } + if (typeof cookie.maxAge === "number") { + validateCookieMaxAge(cookie.maxAge); + out.push(`Max-Age=${cookie.maxAge}`); + } + if (cookie.domain) { + validateCookieDomain(cookie.domain); + out.push(`Domain=${cookie.domain}`); + } + if (cookie.path) { + validateCookiePath(cookie.path); + out.push(`Path=${cookie.path}`); + } + if (cookie.expires && cookie.expires.toString() !== "Invalid Date") { + out.push(`Expires=${toIMFDate(cookie.expires)}`); + } + if (cookie.sameSite) { + out.push(`SameSite=${cookie.sameSite}`); + } + for (const part of cookie.unparsed) { + if (!part.includes("=")) { + throw new Error("Invalid unparsed"); + } + const [key, ...value] = part.split("="); + out.push(`${key.trim()}=${value.join("=")}`); + } + return out.join("; "); + } + module2.exports = { + isCTLExcludingHtab, + validateCookieName, + validateCookiePath, + validateCookieValue, + toIMFDate, + stringify: stringify3 + }; + } +}); + +// node_modules/undici/lib/cookies/parse.js +var require_parse = __commonJS({ + "node_modules/undici/lib/cookies/parse.js"(exports2, module2) { + "use strict"; + var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4(); + var { isCTLExcludingHtab } = require_util6(); + var { collectASequenceOfCodePointsFast } = require_dataURL(); + var assert = require("assert"); + function parseSetCookie(header) { + if (isCTLExcludingHtab(header)) { + return null; + } + let nameValuePair = ""; + let unparsedAttributes = ""; + let name = ""; + let value = ""; + if (header.includes(";")) { + const position = { position: 0 }; + nameValuePair = collectASequenceOfCodePointsFast(";", header, position); + unparsedAttributes = header.slice(position.position); + } else { + nameValuePair = header; + } + if (!nameValuePair.includes("=")) { + value = nameValuePair; + } else { + const position = { position: 0 }; + name = collectASequenceOfCodePointsFast( + "=", + nameValuePair, + position + ); + value = nameValuePair.slice(position.position + 1); + } + name = name.trim(); + value = value.trim(); + if (name.length + value.length > maxNameValuePairSize) { + return null; + } + return { + name, + value, + ...parseUnparsedAttributes(unparsedAttributes) + }; + } + function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) { + if (unparsedAttributes.length === 0) { + return cookieAttributeList; + } + assert(unparsedAttributes[0] === ";"); + unparsedAttributes = unparsedAttributes.slice(1); + let cookieAv = ""; + if (unparsedAttributes.includes(";")) { + cookieAv = collectASequenceOfCodePointsFast( + ";", + unparsedAttributes, + { position: 0 } + ); + unparsedAttributes = unparsedAttributes.slice(cookieAv.length); + } else { + cookieAv = unparsedAttributes; + unparsedAttributes = ""; + } + let attributeName = ""; + let attributeValue = ""; + if (cookieAv.includes("=")) { + const position = { position: 0 }; + attributeName = collectASequenceOfCodePointsFast( + "=", + cookieAv, + position + ); + attributeValue = cookieAv.slice(position.position + 1); + } else { + attributeName = cookieAv; + } + attributeName = attributeName.trim(); + attributeValue = attributeValue.trim(); + if (attributeValue.length > maxAttributeValueSize) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const attributeNameLowercase = attributeName.toLowerCase(); + if (attributeNameLowercase === "expires") { + const expiryTime = new Date(attributeValue); + cookieAttributeList.expires = expiryTime; + } else if (attributeNameLowercase === "max-age") { + const charCode = attributeValue.charCodeAt(0); + if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + if (!/^\d+$/.test(attributeValue)) { + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + const deltaSeconds = Number(attributeValue); + cookieAttributeList.maxAge = deltaSeconds; + } else if (attributeNameLowercase === "domain") { + let cookieDomain = attributeValue; + if (cookieDomain[0] === ".") { + cookieDomain = cookieDomain.slice(1); + } + cookieDomain = cookieDomain.toLowerCase(); + cookieAttributeList.domain = cookieDomain; + } else if (attributeNameLowercase === "path") { + let cookiePath = ""; + if (attributeValue.length === 0 || attributeValue[0] !== "/") { + cookiePath = "/"; + } else { + cookiePath = attributeValue; + } + cookieAttributeList.path = cookiePath; + } else if (attributeNameLowercase === "secure") { + cookieAttributeList.secure = true; + } else if (attributeNameLowercase === "httponly") { + cookieAttributeList.httpOnly = true; + } else if (attributeNameLowercase === "samesite") { + let enforcement = "Default"; + const attributeValueLowercase = attributeValue.toLowerCase(); + if (attributeValueLowercase.includes("none")) { + enforcement = "None"; + } + if (attributeValueLowercase.includes("strict")) { + enforcement = "Strict"; + } + if (attributeValueLowercase.includes("lax")) { + enforcement = "Lax"; + } + cookieAttributeList.sameSite = enforcement; + } else { + cookieAttributeList.unparsed ??= []; + cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`); + } + return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList); + } + module2.exports = { + parseSetCookie, + parseUnparsedAttributes + }; + } +}); + +// node_modules/undici/lib/cookies/index.js +var require_cookies = __commonJS({ + "node_modules/undici/lib/cookies/index.js"(exports2, module2) { + "use strict"; + var { parseSetCookie } = require_parse(); + var { stringify: stringify3 } = require_util6(); + var { webidl } = require_webidl(); + var { Headers: Headers2 } = require_headers(); + function getCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookie = headers.get("cookie"); + const out = {}; + if (!cookie) { + return out; + } + for (const piece of cookie.split(";")) { + const [name, ...value] = piece.split("="); + out[name.trim()] = value.join("="); + } + return out; + } + function deleteCookie(headers, name, attributes) { + webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + name = webidl.converters.DOMString(name); + attributes = webidl.converters.DeleteCookieAttributes(attributes); + setCookie(headers, { + name, + value: "", + expires: /* @__PURE__ */ new Date(0), + ...attributes + }); + } + function getSetCookies(headers) { + webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + const cookies = headers.getSetCookie(); + if (!cookies) { + return []; + } + return cookies.map((pair) => parseSetCookie(pair)); + } + function setCookie(headers, cookie) { + webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" }); + webidl.brandCheck(headers, Headers2, { strict: false }); + cookie = webidl.converters.Cookie(cookie); + const str = stringify3(cookie); + if (str) { + headers.append("Set-Cookie", stringify3(cookie)); + } + } + webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([ + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + } + ]); + webidl.converters.Cookie = webidl.dictionaryConverter([ + { + converter: webidl.converters.DOMString, + key: "name" + }, + { + converter: webidl.converters.DOMString, + key: "value" + }, + { + converter: webidl.nullableConverter((value) => { + if (typeof value === "number") { + return webidl.converters["unsigned long long"](value); + } + return new Date(value); + }), + key: "expires", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters["long long"]), + key: "maxAge", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "domain", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.DOMString), + key: "path", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "secure", + defaultValue: null + }, + { + converter: webidl.nullableConverter(webidl.converters.boolean), + key: "httpOnly", + defaultValue: null + }, + { + converter: webidl.converters.USVString, + key: "sameSite", + allowedValues: ["Strict", "Lax", "None"] + }, + { + converter: webidl.sequenceConverter(webidl.converters.DOMString), + key: "unparsed", + defaultValue: [] + } + ]); + module2.exports = { + getCookies, + deleteCookie, + getSetCookies, + setCookie + }; + } +}); + +// node_modules/undici/lib/websocket/constants.js +var require_constants5 = __commonJS({ + "node_modules/undici/lib/websocket/constants.js"(exports2, module2) { + "use strict"; + var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + var staticPropertyDescriptors = { + enumerable: true, + writable: false, + configurable: false + }; + var states = { + CONNECTING: 0, + OPEN: 1, + CLOSING: 2, + CLOSED: 3 + }; + var opcodes = { + CONTINUATION: 0, + TEXT: 1, + BINARY: 2, + CLOSE: 8, + PING: 9, + PONG: 10 + }; + var maxUnsigned16Bit = 2 ** 16 - 1; + var parserStates = { + INFO: 0, + PAYLOADLENGTH_16: 2, + PAYLOADLENGTH_64: 3, + READ_DATA: 4 + }; + var emptyBuffer = Buffer.allocUnsafe(0); + module2.exports = { + uid, + staticPropertyDescriptors, + states, + opcodes, + maxUnsigned16Bit, + parserStates, + emptyBuffer + }; + } +}); + +// node_modules/undici/lib/websocket/symbols.js +var require_symbols5 = __commonJS({ + "node_modules/undici/lib/websocket/symbols.js"(exports2, module2) { + "use strict"; + module2.exports = { + kWebSocketURL: Symbol("url"), + kReadyState: Symbol("ready state"), + kController: Symbol("controller"), + kResponse: Symbol("response"), + kBinaryType: Symbol("binary type"), + kSentClose: Symbol("sent close"), + kReceivedClose: Symbol("received close"), + kByteParser: Symbol("byte parser") + }; + } +}); + +// node_modules/undici/lib/websocket/events.js +var require_events = __commonJS({ + "node_modules/undici/lib/websocket/events.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { kEnumerableProperty } = require_util(); + var { MessagePort } = require("worker_threads"); + var MessageEvent = class _MessageEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.MessageEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get data() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.data; + } + get origin() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.origin; + } + get lastEventId() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.lastEventId; + } + get source() { + webidl.brandCheck(this, _MessageEvent); + return this.#eventInit.source; + } + get ports() { + webidl.brandCheck(this, _MessageEvent); + if (!Object.isFrozen(this.#eventInit.ports)) { + Object.freeze(this.#eventInit.ports); + } + return this.#eventInit.ports; + } + initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) { + webidl.brandCheck(this, _MessageEvent); + webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" }); + return new _MessageEvent(type, { + bubbles, + cancelable, + data, + origin, + lastEventId, + source, + ports + }); + } + }; + var CloseEvent = class _CloseEvent extends Event { + #eventInit; + constructor(type, eventInitDict = {}) { + webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" }); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.CloseEventInit(eventInitDict); + super(type, eventInitDict); + this.#eventInit = eventInitDict; + } + get wasClean() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.wasClean; + } + get code() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.code; + } + get reason() { + webidl.brandCheck(this, _CloseEvent); + return this.#eventInit.reason; + } + }; + var ErrorEvent = class _ErrorEvent extends Event { + #eventInit; + constructor(type, eventInitDict) { + webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" }); + super(type, eventInitDict); + type = webidl.converters.DOMString(type); + eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {}); + this.#eventInit = eventInitDict; + } + get message() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.message; + } + get filename() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.filename; + } + get lineno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.lineno; + } + get colno() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.colno; + } + get error() { + webidl.brandCheck(this, _ErrorEvent); + return this.#eventInit.error; + } + }; + Object.defineProperties(MessageEvent.prototype, { + [Symbol.toStringTag]: { + value: "MessageEvent", + configurable: true + }, + data: kEnumerableProperty, + origin: kEnumerableProperty, + lastEventId: kEnumerableProperty, + source: kEnumerableProperty, + ports: kEnumerableProperty, + initMessageEvent: kEnumerableProperty + }); + Object.defineProperties(CloseEvent.prototype, { + [Symbol.toStringTag]: { + value: "CloseEvent", + configurable: true + }, + reason: kEnumerableProperty, + code: kEnumerableProperty, + wasClean: kEnumerableProperty + }); + Object.defineProperties(ErrorEvent.prototype, { + [Symbol.toStringTag]: { + value: "ErrorEvent", + configurable: true + }, + message: kEnumerableProperty, + filename: kEnumerableProperty, + lineno: kEnumerableProperty, + colno: kEnumerableProperty, + error: kEnumerableProperty + }); + webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.MessagePort + ); + var eventInit = [ + { + key: "bubbles", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "cancelable", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "composed", + converter: webidl.converters.boolean, + defaultValue: false + } + ]; + webidl.converters.MessageEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "data", + converter: webidl.converters.any, + defaultValue: null + }, + { + key: "origin", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lastEventId", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "source", + // Node doesn't implement WindowProxy or ServiceWorker, so the only + // valid value for source is a MessagePort. + converter: webidl.nullableConverter(webidl.converters.MessagePort), + defaultValue: null + }, + { + key: "ports", + converter: webidl.converters["sequence"], + get defaultValue() { + return []; + } + } + ]); + webidl.converters.CloseEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "wasClean", + converter: webidl.converters.boolean, + defaultValue: false + }, + { + key: "code", + converter: webidl.converters["unsigned short"], + defaultValue: 0 + }, + { + key: "reason", + converter: webidl.converters.USVString, + defaultValue: "" + } + ]); + webidl.converters.ErrorEventInit = webidl.dictionaryConverter([ + ...eventInit, + { + key: "message", + converter: webidl.converters.DOMString, + defaultValue: "" + }, + { + key: "filename", + converter: webidl.converters.USVString, + defaultValue: "" + }, + { + key: "lineno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "colno", + converter: webidl.converters["unsigned long"], + defaultValue: 0 + }, + { + key: "error", + converter: webidl.converters.any + } + ]); + module2.exports = { + MessageEvent, + CloseEvent, + ErrorEvent + }; + } +}); + +// node_modules/undici/lib/websocket/util.js +var require_util7 = __commonJS({ + "node_modules/undici/lib/websocket/util.js"(exports2, module2) { + "use strict"; + var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5(); + var { states, opcodes } = require_constants5(); + var { MessageEvent, ErrorEvent } = require_events(); + function isEstablished(ws) { + return ws[kReadyState] === states.OPEN; + } + function isClosing(ws) { + return ws[kReadyState] === states.CLOSING; + } + function isClosed(ws) { + return ws[kReadyState] === states.CLOSED; + } + function fireEvent(e, target, eventConstructor = Event, eventInitDict) { + const event = new eventConstructor(e, eventInitDict); + target.dispatchEvent(event); + } + function websocketMessageReceived(ws, type, data) { + if (ws[kReadyState] !== states.OPEN) { + return; + } + let dataForEvent; + if (type === opcodes.TEXT) { + try { + dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data); + } catch { + failWebsocketConnection(ws, "Received invalid UTF-8 in text frame."); + return; + } + } else if (type === opcodes.BINARY) { + if (ws[kBinaryType] === "blob") { + dataForEvent = new Blob([data]); + } else { + dataForEvent = new Uint8Array(data).buffer; + } + } + fireEvent("message", ws, MessageEvent, { + origin: ws[kWebSocketURL].origin, + data: dataForEvent + }); + } + function isValidSubprotocol(protocol) { + if (protocol.length === 0) { + return false; + } + for (const char of protocol) { + const code = char.charCodeAt(0); + if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP + code === 9) { + return false; + } + } + return true; + } + function isValidStatusCode(code) { + if (code >= 1e3 && code < 1015) { + return code !== 1004 && // reserved + code !== 1005 && // "MUST NOT be set as a status code" + code !== 1006; + } + return code >= 3e3 && code <= 4999; + } + function failWebsocketConnection(ws, reason) { + const { [kController]: controller, [kResponse]: response } = ws; + controller.abort(); + if (response?.socket && !response.socket.destroyed) { + response.socket.destroy(); + } + if (reason) { + fireEvent("error", ws, ErrorEvent, { + error: new Error(reason) + }); + } + } + module2.exports = { + isEstablished, + isClosing, + isClosed, + fireEvent, + isValidSubprotocol, + isValidStatusCode, + failWebsocketConnection, + websocketMessageReceived + }; + } +}); + +// node_modules/undici/lib/websocket/connection.js +var require_connection = __commonJS({ + "node_modules/undici/lib/websocket/connection.js"(exports2, module2) { + "use strict"; + var diagnosticsChannel = require("diagnostics_channel"); + var { uid, states } = require_constants5(); + var { + kReadyState, + kSentClose, + kByteParser, + kReceivedClose + } = require_symbols5(); + var { fireEvent, failWebsocketConnection } = require_util7(); + var { CloseEvent } = require_events(); + var { makeRequest } = require_request2(); + var { fetching } = require_fetch(); + var { Headers: Headers2 } = require_headers(); + var { getGlobalDispatcher } = require_global2(); + var { kHeadersList } = require_symbols(); + var channels = {}; + channels.open = diagnosticsChannel.channel("undici:websocket:open"); + channels.close = diagnosticsChannel.channel("undici:websocket:close"); + channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error"); + var crypto; + try { + crypto = require("crypto"); + } catch { + } + function establishWebSocketConnection(url, protocols, ws, onEstablish, options) { + const requestURL = url; + requestURL.protocol = url.protocol === "ws:" ? "http:" : "https:"; + const request = makeRequest({ + urlList: [requestURL], + serviceWorkers: "none", + referrer: "no-referrer", + mode: "websocket", + credentials: "include", + cache: "no-store", + redirect: "error" + }); + if (options.headers) { + const headersList = new Headers2(options.headers)[kHeadersList]; + request.headersList = headersList; + } + const keyValue = crypto.randomBytes(16).toString("base64"); + request.headersList.append("sec-websocket-key", keyValue); + request.headersList.append("sec-websocket-version", "13"); + for (const protocol of protocols) { + request.headersList.append("sec-websocket-protocol", protocol); + } + const permessageDeflate = ""; + const controller = fetching({ + request, + useParallelQueue: true, + dispatcher: options.dispatcher ?? getGlobalDispatcher(), + processResponse(response) { + if (response.type === "error" || response.status !== 101) { + failWebsocketConnection(ws, "Received network error or non-101 status code."); + return; + } + if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Server did not respond with sent protocols."); + return; + } + if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") { + failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".'); + return; + } + if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") { + failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".'); + return; + } + const secWSAccept = response.headersList.get("Sec-WebSocket-Accept"); + const digest = crypto.createHash("sha1").update(keyValue + uid).digest("base64"); + if (secWSAccept !== digest) { + failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header."); + return; + } + const secExtension = response.headersList.get("Sec-WebSocket-Extensions"); + if (secExtension !== null && secExtension !== permessageDeflate) { + failWebsocketConnection(ws, "Received different permessage-deflate than the one set."); + return; + } + const secProtocol = response.headersList.get("Sec-WebSocket-Protocol"); + if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) { + failWebsocketConnection(ws, "Protocol was not set in the opening handshake."); + return; + } + response.socket.on("data", onSocketData); + response.socket.on("close", onSocketClose); + response.socket.on("error", onSocketError); + if (channels.open.hasSubscribers) { + channels.open.publish({ + address: response.socket.address(), + protocol: secProtocol, + extensions: secExtension + }); + } + onEstablish(response); + } + }); + return controller; + } + function onSocketData(chunk) { + if (!this.ws[kByteParser].write(chunk)) { + this.pause(); + } + } + function onSocketClose() { + const { ws } = this; + const wasClean = ws[kSentClose] && ws[kReceivedClose]; + let code = 1005; + let reason = ""; + const result = ws[kByteParser].closingInfo; + if (result) { + code = result.code ?? 1005; + reason = result.reason; + } else if (!ws[kSentClose]) { + code = 1006; + } + ws[kReadyState] = states.CLOSED; + fireEvent("close", ws, CloseEvent, { + wasClean, + code, + reason + }); + if (channels.close.hasSubscribers) { + channels.close.publish({ + websocket: ws, + code, + reason + }); + } + } + function onSocketError(error) { + const { ws } = this; + ws[kReadyState] = states.CLOSING; + if (channels.socketError.hasSubscribers) { + channels.socketError.publish(error); + } + this.destroy(); + } + module2.exports = { + establishWebSocketConnection + }; + } +}); + +// node_modules/undici/lib/websocket/frame.js +var require_frame = __commonJS({ + "node_modules/undici/lib/websocket/frame.js"(exports2, module2) { + "use strict"; + var { maxUnsigned16Bit } = require_constants5(); + var crypto; + try { + crypto = require("crypto"); + } catch { + } + var WebsocketFrameSend = class { + /** + * @param {Buffer|undefined} data + */ + constructor(data) { + this.frameData = data; + this.maskKey = crypto.randomBytes(4); + } + createFrame(opcode) { + const bodyLength = this.frameData?.byteLength ?? 0; + let payloadLength = bodyLength; + let offset = 6; + if (bodyLength > maxUnsigned16Bit) { + offset += 8; + payloadLength = 127; + } else if (bodyLength > 125) { + offset += 2; + payloadLength = 126; + } + const buffer = Buffer.allocUnsafe(bodyLength + offset); + buffer[0] = buffer[1] = 0; + buffer[0] |= 128; + buffer[0] = (buffer[0] & 240) + opcode; + buffer[offset - 4] = this.maskKey[0]; + buffer[offset - 3] = this.maskKey[1]; + buffer[offset - 2] = this.maskKey[2]; + buffer[offset - 1] = this.maskKey[3]; + buffer[1] = payloadLength; + if (payloadLength === 126) { + buffer.writeUInt16BE(bodyLength, 2); + } else if (payloadLength === 127) { + buffer[2] = buffer[3] = 0; + buffer.writeUIntBE(bodyLength, 4, 6); + } + buffer[1] |= 128; + for (let i = 0; i < bodyLength; i++) { + buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4]; + } + return buffer; + } + }; + module2.exports = { + WebsocketFrameSend + }; + } +}); + +// node_modules/undici/lib/websocket/receiver.js +var require_receiver = __commonJS({ + "node_modules/undici/lib/websocket/receiver.js"(exports2, module2) { + "use strict"; + var { Writable } = require("stream"); + var diagnosticsChannel = require("diagnostics_channel"); + var { parserStates, opcodes, states, emptyBuffer } = require_constants5(); + var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5(); + var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util7(); + var { WebsocketFrameSend } = require_frame(); + var channels = {}; + channels.ping = diagnosticsChannel.channel("undici:websocket:ping"); + channels.pong = diagnosticsChannel.channel("undici:websocket:pong"); + var ByteParser = class extends Writable { + #buffers = []; + #byteOffset = 0; + #state = parserStates.INFO; + #info = {}; + #fragments = []; + constructor(ws) { + super(); + this.ws = ws; + } + /** + * @param {Buffer} chunk + * @param {() => void} callback + */ + _write(chunk, _, callback) { + this.#buffers.push(chunk); + this.#byteOffset += chunk.length; + this.run(callback); + } + /** + * Runs whenever a new chunk is received. + * Callback is called whenever there are no more chunks buffering, + * or not enough bytes are buffered to parse. + */ + run(callback) { + while (true) { + if (this.#state === parserStates.INFO) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.fin = (buffer[0] & 128) !== 0; + this.#info.opcode = buffer[0] & 15; + this.#info.originalOpcode ??= this.#info.opcode; + this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION; + if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) { + failWebsocketConnection(this.ws, "Invalid frame type was fragmented."); + return; + } + const payloadLength = buffer[1] & 127; + if (payloadLength <= 125) { + this.#info.payloadLength = payloadLength; + this.#state = parserStates.READ_DATA; + } else if (payloadLength === 126) { + this.#state = parserStates.PAYLOADLENGTH_16; + } else if (payloadLength === 127) { + this.#state = parserStates.PAYLOADLENGTH_64; + } + if (this.#info.fragmented && payloadLength > 125) { + failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes."); + return; + } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) { + failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes."); + return; + } else if (this.#info.opcode === opcodes.CLOSE) { + if (payloadLength === 1) { + failWebsocketConnection(this.ws, "Received close frame with a 1-byte body."); + return; + } + const body = this.consume(payloadLength); + this.#info.closeInfo = this.parseCloseBody(false, body); + if (!this.ws[kSentClose]) { + const body2 = Buffer.allocUnsafe(2); + body2.writeUInt16BE(this.#info.closeInfo.code, 0); + const closeFrame = new WebsocketFrameSend(body2); + this.ws[kResponse].socket.write( + closeFrame.createFrame(opcodes.CLOSE), + (err) => { + if (!err) { + this.ws[kSentClose] = true; + } + } + ); + } + this.ws[kReadyState] = states.CLOSING; + this.ws[kReceivedClose] = true; + this.end(); + return; + } else if (this.#info.opcode === opcodes.PING) { + const body = this.consume(payloadLength); + if (!this.ws[kReceivedClose]) { + const frame = new WebsocketFrameSend(body); + this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG)); + if (channels.ping.hasSubscribers) { + channels.ping.publish({ + payload: body + }); + } + } + this.#state = parserStates.INFO; + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } + } else if (this.#info.opcode === opcodes.PONG) { + const body = this.consume(payloadLength); + if (channels.pong.hasSubscribers) { + channels.pong.publish({ + payload: body + }); + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + return; + } + } + } else if (this.#state === parserStates.PAYLOADLENGTH_16) { + if (this.#byteOffset < 2) { + return callback(); + } + const buffer = this.consume(2); + this.#info.payloadLength = buffer.readUInt16BE(0); + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.PAYLOADLENGTH_64) { + if (this.#byteOffset < 8) { + return callback(); + } + const buffer = this.consume(8); + const upper = buffer.readUInt32BE(0); + if (upper > 2 ** 31 - 1) { + failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes."); + return; + } + const lower = buffer.readUInt32BE(4); + this.#info.payloadLength = (upper << 8) + lower; + this.#state = parserStates.READ_DATA; + } else if (this.#state === parserStates.READ_DATA) { + if (this.#byteOffset < this.#info.payloadLength) { + return callback(); + } else if (this.#byteOffset >= this.#info.payloadLength) { + const body = this.consume(this.#info.payloadLength); + this.#fragments.push(body); + if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) { + const fullMessage = Buffer.concat(this.#fragments); + websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage); + this.#info = {}; + this.#fragments.length = 0; + } + this.#state = parserStates.INFO; + } + } + if (this.#byteOffset > 0) { + continue; + } else { + callback(); + break; + } + } + } + /** + * Take n bytes from the buffered Buffers + * @param {number} n + * @returns {Buffer|null} + */ + consume(n) { + if (n > this.#byteOffset) { + return null; + } else if (n === 0) { + return emptyBuffer; + } + if (this.#buffers[0].length === n) { + this.#byteOffset -= this.#buffers[0].length; + return this.#buffers.shift(); + } + const buffer = Buffer.allocUnsafe(n); + let offset = 0; + while (offset !== n) { + const next = this.#buffers[0]; + const { length } = next; + if (length + offset === n) { + buffer.set(this.#buffers.shift(), offset); + break; + } else if (length + offset > n) { + buffer.set(next.subarray(0, n - offset), offset); + this.#buffers[0] = next.subarray(n - offset); + break; + } else { + buffer.set(this.#buffers.shift(), offset); + offset += next.length; + } + } + this.#byteOffset -= n; + return buffer; + } + parseCloseBody(onlyCode, data) { + let code; + if (data.length >= 2) { + code = data.readUInt16BE(0); + } + if (onlyCode) { + if (!isValidStatusCode(code)) { + return null; + } + return { code }; + } + let reason = data.subarray(2); + if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) { + reason = reason.subarray(3); + } + if (code !== void 0 && !isValidStatusCode(code)) { + return null; + } + try { + reason = new TextDecoder("utf-8", { fatal: true }).decode(reason); + } catch { + return null; + } + return { code, reason }; + } + get closingInfo() { + return this.#info.closeInfo; + } + }; + module2.exports = { + ByteParser + }; + } +}); + +// node_modules/undici/lib/websocket/websocket.js +var require_websocket = __commonJS({ + "node_modules/undici/lib/websocket/websocket.js"(exports2, module2) { + "use strict"; + var { webidl } = require_webidl(); + var { DOMException: DOMException2 } = require_constants2(); + var { URLSerializer } = require_dataURL(); + var { getGlobalOrigin } = require_global(); + var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants5(); + var { + kWebSocketURL, + kReadyState, + kController, + kBinaryType, + kResponse, + kSentClose, + kByteParser + } = require_symbols5(); + var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util7(); + var { establishWebSocketConnection } = require_connection(); + var { WebsocketFrameSend } = require_frame(); + var { ByteParser } = require_receiver(); + var { kEnumerableProperty, isBlobLike: isBlobLike2 } = require_util(); + var { getGlobalDispatcher } = require_global2(); + var { types } = require("util"); + var experimentalWarned = false; + var WebSocket = class _WebSocket extends EventTarget { + #events = { + open: null, + error: null, + close: null, + message: null + }; + #bufferedAmount = 0; + #protocol = ""; + #extensions = ""; + /** + * @param {string} url + * @param {string|string[]} protocols + */ + constructor(url, protocols = []) { + super(); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" }); + if (!experimentalWarned) { + experimentalWarned = true; + process.emitWarning("WebSockets are experimental, expect them to change at any time.", { + code: "UNDICI-WS" + }); + } + const options = webidl.converters["DOMString or sequence or WebSocketInit"](protocols); + url = webidl.converters.USVString(url); + protocols = options.protocols; + const baseURL = getGlobalOrigin(); + let urlRecord; + try { + urlRecord = new URL(url, baseURL); + } catch (e) { + throw new DOMException2(e, "SyntaxError"); + } + if (urlRecord.protocol === "http:") { + urlRecord.protocol = "ws:"; + } else if (urlRecord.protocol === "https:") { + urlRecord.protocol = "wss:"; + } + if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") { + throw new DOMException2( + `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, + "SyntaxError" + ); + } + if (urlRecord.hash || urlRecord.href.endsWith("#")) { + throw new DOMException2("Got fragment", "SyntaxError"); + } + if (typeof protocols === "string") { + protocols = [protocols]; + } + if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) { + throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError"); + } + this[kWebSocketURL] = new URL(urlRecord.href); + this[kController] = establishWebSocketConnection( + urlRecord, + protocols, + this, + (response) => this.#onConnectionEstablished(response), + options + ); + this[kReadyState] = _WebSocket.CONNECTING; + this[kBinaryType] = "blob"; + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-close + * @param {number|undefined} code + * @param {string|undefined} reason + */ + close(code = void 0, reason = void 0) { + webidl.brandCheck(this, _WebSocket); + if (code !== void 0) { + code = webidl.converters["unsigned short"](code, { clamp: true }); + } + if (reason !== void 0) { + reason = webidl.converters.USVString(reason); + } + if (code !== void 0) { + if (code !== 1e3 && (code < 3e3 || code > 4999)) { + throw new DOMException2("invalid code", "InvalidAccessError"); + } + } + let reasonByteLength = 0; + if (reason !== void 0) { + reasonByteLength = Buffer.byteLength(reason); + if (reasonByteLength > 123) { + throw new DOMException2( + `Reason must be less than 123 bytes; received ${reasonByteLength}`, + "SyntaxError" + ); + } + } + if (this[kReadyState] === _WebSocket.CLOSING || this[kReadyState] === _WebSocket.CLOSED) { + } else if (!isEstablished(this)) { + failWebsocketConnection(this, "Connection was closed before it was established."); + this[kReadyState] = _WebSocket.CLOSING; + } else if (!isClosing(this)) { + const frame = new WebsocketFrameSend(); + if (code !== void 0 && reason === void 0) { + frame.frameData = Buffer.allocUnsafe(2); + frame.frameData.writeUInt16BE(code, 0); + } else if (code !== void 0 && reason !== void 0) { + frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength); + frame.frameData.writeUInt16BE(code, 0); + frame.frameData.write(reason, 2, "utf-8"); + } else { + frame.frameData = emptyBuffer; + } + const socket = this[kResponse].socket; + socket.write(frame.createFrame(opcodes.CLOSE), (err) => { + if (!err) { + this[kSentClose] = true; + } + }); + this[kReadyState] = states.CLOSING; + } else { + this[kReadyState] = _WebSocket.CLOSING; + } + } + /** + * @see https://websockets.spec.whatwg.org/#dom-websocket-send + * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data + */ + send(data) { + webidl.brandCheck(this, _WebSocket); + webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" }); + data = webidl.converters.WebSocketSendData(data); + if (this[kReadyState] === _WebSocket.CONNECTING) { + throw new DOMException2("Sent before connected.", "InvalidStateError"); + } + if (!isEstablished(this) || isClosing(this)) { + return; + } + const socket = this[kResponse].socket; + if (typeof data === "string") { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.TEXT); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (types.isArrayBuffer(data)) { + const value = Buffer.from(data); + const frame = new WebsocketFrameSend(value); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + } else if (ArrayBuffer.isView(data)) { + const ab = Buffer.from(data, data.byteOffset, data.byteLength); + const frame = new WebsocketFrameSend(ab); + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += ab.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= ab.byteLength; + }); + } else if (isBlobLike2(data)) { + const frame = new WebsocketFrameSend(); + data.arrayBuffer().then((ab) => { + const value = Buffer.from(ab); + frame.frameData = value; + const buffer = frame.createFrame(opcodes.BINARY); + this.#bufferedAmount += value.byteLength; + socket.write(buffer, () => { + this.#bufferedAmount -= value.byteLength; + }); + }); + } + } + get readyState() { + webidl.brandCheck(this, _WebSocket); + return this[kReadyState]; + } + get bufferedAmount() { + webidl.brandCheck(this, _WebSocket); + return this.#bufferedAmount; + } + get url() { + webidl.brandCheck(this, _WebSocket); + return URLSerializer(this[kWebSocketURL]); + } + get extensions() { + webidl.brandCheck(this, _WebSocket); + return this.#extensions; + } + get protocol() { + webidl.brandCheck(this, _WebSocket); + return this.#protocol; + } + get onopen() { + webidl.brandCheck(this, _WebSocket); + return this.#events.open; + } + set onopen(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.open) { + this.removeEventListener("open", this.#events.open); + } + if (typeof fn === "function") { + this.#events.open = fn; + this.addEventListener("open", fn); + } else { + this.#events.open = null; + } + } + get onerror() { + webidl.brandCheck(this, _WebSocket); + return this.#events.error; + } + set onerror(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.error) { + this.removeEventListener("error", this.#events.error); + } + if (typeof fn === "function") { + this.#events.error = fn; + this.addEventListener("error", fn); + } else { + this.#events.error = null; + } + } + get onclose() { + webidl.brandCheck(this, _WebSocket); + return this.#events.close; + } + set onclose(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.close) { + this.removeEventListener("close", this.#events.close); + } + if (typeof fn === "function") { + this.#events.close = fn; + this.addEventListener("close", fn); + } else { + this.#events.close = null; + } + } + get onmessage() { + webidl.brandCheck(this, _WebSocket); + return this.#events.message; + } + set onmessage(fn) { + webidl.brandCheck(this, _WebSocket); + if (this.#events.message) { + this.removeEventListener("message", this.#events.message); + } + if (typeof fn === "function") { + this.#events.message = fn; + this.addEventListener("message", fn); + } else { + this.#events.message = null; + } + } + get binaryType() { + webidl.brandCheck(this, _WebSocket); + return this[kBinaryType]; + } + set binaryType(type) { + webidl.brandCheck(this, _WebSocket); + if (type !== "blob" && type !== "arraybuffer") { + this[kBinaryType] = "blob"; + } else { + this[kBinaryType] = type; + } + } + /** + * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol + */ + #onConnectionEstablished(response) { + this[kResponse] = response; + const parser = new ByteParser(this); + parser.on("drain", function onParserDrain() { + this.ws[kResponse].socket.resume(); + }); + response.socket.ws = this; + this[kByteParser] = parser; + this[kReadyState] = states.OPEN; + const extensions = response.headersList.get("sec-websocket-extensions"); + if (extensions !== null) { + this.#extensions = extensions; + } + const protocol = response.headersList.get("sec-websocket-protocol"); + if (protocol !== null) { + this.#protocol = protocol; + } + fireEvent("open", this); + } + }; + WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING; + WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN; + WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING; + WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED; + Object.defineProperties(WebSocket.prototype, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors, + url: kEnumerableProperty, + readyState: kEnumerableProperty, + bufferedAmount: kEnumerableProperty, + onopen: kEnumerableProperty, + onerror: kEnumerableProperty, + onclose: kEnumerableProperty, + close: kEnumerableProperty, + onmessage: kEnumerableProperty, + binaryType: kEnumerableProperty, + send: kEnumerableProperty, + extensions: kEnumerableProperty, + protocol: kEnumerableProperty, + [Symbol.toStringTag]: { + value: "WebSocket", + writable: false, + enumerable: false, + configurable: true + } + }); + Object.defineProperties(WebSocket, { + CONNECTING: staticPropertyDescriptors, + OPEN: staticPropertyDescriptors, + CLOSING: staticPropertyDescriptors, + CLOSED: staticPropertyDescriptors + }); + webidl.converters["sequence"] = webidl.sequenceConverter( + webidl.converters.DOMString + ); + webidl.converters["DOMString or sequence"] = function(V) { + if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) { + return webidl.converters["sequence"](V); + } + return webidl.converters.DOMString(V); + }; + webidl.converters.WebSocketInit = webidl.dictionaryConverter([ + { + key: "protocols", + converter: webidl.converters["DOMString or sequence"], + get defaultValue() { + return []; + } + }, + { + key: "dispatcher", + converter: (V) => V, + get defaultValue() { + return getGlobalDispatcher(); + } + }, + { + key: "headers", + converter: webidl.nullableConverter(webidl.converters.HeadersInit) + } + ]); + webidl.converters["DOMString or sequence or WebSocketInit"] = function(V) { + if (webidl.util.Type(V) === "Object" && !(Symbol.iterator in V)) { + return webidl.converters.WebSocketInit(V); + } + return { protocols: webidl.converters["DOMString or sequence"](V) }; + }; + webidl.converters.WebSocketSendData = function(V) { + if (webidl.util.Type(V) === "Object") { + if (isBlobLike2(V)) { + return webidl.converters.Blob(V, { strict: false }); + } + if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { + return webidl.converters.BufferSource(V); + } + } + return webidl.converters.USVString(V); + }; + module2.exports = { + WebSocket + }; + } +}); + +// node_modules/undici/index.js +var require_undici = __commonJS({ + "node_modules/undici/index.js"(exports2, module2) { + "use strict"; + var Client = require_client(); + var Dispatcher = require_dispatcher(); + var errors = require_errors(); + var Pool = require_pool(); + var BalancedPool = require_balanced_pool(); + var Agent = require_agent(); + var util = require_util(); + var { InvalidArgumentError } = errors; + var api = require_api(); + var buildConnector = require_connect(); + var MockClient = require_mock_client(); + var MockAgent = require_mock_agent(); + var MockPool = require_mock_pool(); + var mockErrors = require_mock_errors(); + var ProxyAgent = require_proxy_agent(); + var RetryHandler = require_RetryHandler(); + var { getGlobalDispatcher, setGlobalDispatcher } = require_global2(); + var DecoratorHandler = require_DecoratorHandler(); + var RedirectHandler = require_RedirectHandler(); + var createRedirectInterceptor = require_redirectInterceptor(); + var hasCrypto; + try { + require("crypto"); + hasCrypto = true; + } catch { + hasCrypto = false; + } + Object.assign(Dispatcher.prototype, api); + module2.exports.Dispatcher = Dispatcher; + module2.exports.Client = Client; + module2.exports.Pool = Pool; + module2.exports.BalancedPool = BalancedPool; + module2.exports.Agent = Agent; + module2.exports.ProxyAgent = ProxyAgent; + module2.exports.RetryHandler = RetryHandler; + module2.exports.DecoratorHandler = DecoratorHandler; + module2.exports.RedirectHandler = RedirectHandler; + module2.exports.createRedirectInterceptor = createRedirectInterceptor; + module2.exports.buildConnector = buildConnector; + module2.exports.errors = errors; + function makeDispatcher(fn) { + return (url, opts, handler) => { + if (typeof opts === "function") { + handler = opts; + opts = null; + } + if (!url || typeof url !== "string" && typeof url !== "object" && !(url instanceof URL)) { + throw new InvalidArgumentError("invalid url"); + } + if (opts != null && typeof opts !== "object") { + throw new InvalidArgumentError("invalid opts"); + } + if (opts && opts.path != null) { + if (typeof opts.path !== "string") { + throw new InvalidArgumentError("invalid opts.path"); + } + let path3 = opts.path; + if (!opts.path.startsWith("/")) { + path3 = `/${path3}`; + } + url = new URL(util.parseOrigin(url).origin + path3); + } else { + if (!opts) { + opts = typeof url === "object" ? url : {}; + } + url = util.parseURL(url); + } + const { agent, dispatcher = getGlobalDispatcher() } = opts; + if (agent) { + throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?"); + } + return fn.call(dispatcher, { + ...opts, + origin: url.origin, + path: url.search ? `${url.pathname}${url.search}` : url.pathname, + method: opts.method || (opts.body ? "PUT" : "GET") + }, handler); + }; + } + module2.exports.setGlobalDispatcher = setGlobalDispatcher; + module2.exports.getGlobalDispatcher = getGlobalDispatcher; + if (util.nodeMajor > 16 || util.nodeMajor === 16 && util.nodeMinor >= 8) { + let fetchImpl = null; + module2.exports.fetch = async function fetch2(resource) { + if (!fetchImpl) { + fetchImpl = require_fetch().fetch; + } + try { + return await fetchImpl(...arguments); + } catch (err) { + if (typeof err === "object") { + Error.captureStackTrace(err, this); + } + throw err; + } + }; + module2.exports.Headers = require_headers().Headers; + module2.exports.Response = require_response().Response; + module2.exports.Request = require_request2().Request; + module2.exports.FormData = require_formdata().FormData; + module2.exports.File = require_file().File; + module2.exports.FileReader = require_filereader().FileReader; + const { setGlobalOrigin, getGlobalOrigin } = require_global(); + module2.exports.setGlobalOrigin = setGlobalOrigin; + module2.exports.getGlobalOrigin = getGlobalOrigin; + const { CacheStorage } = require_cachestorage(); + const { kConstruct } = require_symbols4(); + module2.exports.caches = new CacheStorage(kConstruct); + } + if (util.nodeMajor >= 16) { + const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies(); + module2.exports.deleteCookie = deleteCookie; + module2.exports.getCookies = getCookies; + module2.exports.getSetCookies = getSetCookies; + module2.exports.setCookie = setCookie; + const { parseMIMEType, serializeAMimeType } = require_dataURL(); + module2.exports.parseMIMEType = parseMIMEType; + module2.exports.serializeAMimeType = serializeAMimeType; + } + if (util.nodeMajor >= 18 && hasCrypto) { + const { WebSocket } = require_websocket(); + module2.exports.WebSocket = WebSocket; + } + module2.exports.request = makeDispatcher(api.request); + module2.exports.stream = makeDispatcher(api.stream); + module2.exports.pipeline = makeDispatcher(api.pipeline); + module2.exports.connect = makeDispatcher(api.connect); + module2.exports.upgrade = makeDispatcher(api.upgrade); + module2.exports.MockClient = MockClient; + module2.exports.MockPool = MockPool; + module2.exports.MockAgent = MockAgent; + module2.exports.mockErrors = mockErrors; + } +}); + +// node_modules/@actions/http-client/lib/index.js +var require_lib = __commonJS({ + "node_modules/@actions/http-client/lib/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.HttpClient = exports2.isHttps = exports2.HttpClientResponse = exports2.HttpClientError = exports2.getProxyUrl = exports2.MediaTypes = exports2.Headers = exports2.HttpCodes = void 0; + var http = __importStar(require("http")); + var https = __importStar(require("https")); + var pm = __importStar(require_proxy()); + var tunnel = __importStar(require_tunnel2()); + var undici_1 = require_undici(); + var HttpCodes; + (function(HttpCodes2) { + HttpCodes2[HttpCodes2["OK"] = 200] = "OK"; + HttpCodes2[HttpCodes2["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes2[HttpCodes2["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes2[HttpCodes2["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes2[HttpCodes2["SeeOther"] = 303] = "SeeOther"; + HttpCodes2[HttpCodes2["NotModified"] = 304] = "NotModified"; + HttpCodes2[HttpCodes2["UseProxy"] = 305] = "UseProxy"; + HttpCodes2[HttpCodes2["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes2[HttpCodes2["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes2[HttpCodes2["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes2[HttpCodes2["BadRequest"] = 400] = "BadRequest"; + HttpCodes2[HttpCodes2["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes2[HttpCodes2["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes2[HttpCodes2["Forbidden"] = 403] = "Forbidden"; + HttpCodes2[HttpCodes2["NotFound"] = 404] = "NotFound"; + HttpCodes2[HttpCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes2[HttpCodes2["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes2[HttpCodes2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes2[HttpCodes2["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes2[HttpCodes2["Conflict"] = 409] = "Conflict"; + HttpCodes2[HttpCodes2["Gone"] = 410] = "Gone"; + HttpCodes2[HttpCodes2["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes2[HttpCodes2["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes2[HttpCodes2["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes2[HttpCodes2["BadGateway"] = 502] = "BadGateway"; + HttpCodes2[HttpCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes2[HttpCodes2["GatewayTimeout"] = 504] = "GatewayTimeout"; + })(HttpCodes || (exports2.HttpCodes = HttpCodes = {})); + var Headers2; + (function(Headers3) { + Headers3["Accept"] = "accept"; + Headers3["ContentType"] = "content-type"; + })(Headers2 || (exports2.Headers = Headers2 = {})); + var MediaTypes; + (function(MediaTypes2) { + MediaTypes2["ApplicationJson"] = "application/json"; + })(MediaTypes || (exports2.MediaTypes = MediaTypes = {})); + function getProxyUrl(serverUrl) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ""; + } + exports2.getProxyUrl = getProxyUrl; + var HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect + ]; + var HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout + ]; + var RetryableHttpVerbs = ["OPTIONS", "GET", "DELETE", "HEAD"]; + var ExponentialBackoffCeiling = 10; + var ExponentialBackoffTimeSlice = 5; + var HttpClientError = class _HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = "HttpClientError"; + this.statusCode = statusCode; + Object.setPrototypeOf(this, _HttpClientError.prototype); + } + }; + exports2.HttpClientError = HttpClientError; + var HttpClientResponse = class { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + let output = Buffer.alloc(0); + this.message.on("data", (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on("end", () => { + resolve(output.toString()); + }); + })); + }); + } + readBodyBuffer() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + const chunks = []; + this.message.on("data", (chunk) => { + chunks.push(chunk); + }); + this.message.on("end", () => { + resolve(Buffer.concat(chunks)); + }); + })); + }); + } + }; + exports2.HttpClientResponse = HttpClientResponse; + function isHttps(requestUrl) { + const parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === "https:"; + } + exports2.isHttps = isHttps; + var HttpClient = class { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("OPTIONS", requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("GET", requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("DELETE", requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("POST", requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PATCH", requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("PUT", requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request("HEAD", requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request(verb, requestUrl, stream, additionalHeaders); + }); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + getJson(requestUrl, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl, obj, additionalHeaders = {}) { + return __awaiter(this, void 0, void 0, function* () { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers2.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers2.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers2.ContentType, MediaTypes.ApplicationJson); + const res = yield this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error("Client has already been disposed."); + } + const parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info, data); + if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) { + if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } else { + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) { + const redirectUrl = response.message.headers["location"]; + if (!redirectUrl) { + break; + } + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade) { + throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true."); + } + yield response.readBody(); + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) { + if (header.toLowerCase() === "authorization") { + delete headers[header]; + } + } + } + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode)) { + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) { + reject(err); + } else if (!res) { + reject(new Error("Unknown error")); + } else { + resolve(res); + } + } + this.requestRawWithCallback(info, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + if (typeof data === "string") { + if (!info.options.headers) { + info.options.headers = {}; + } + info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8"); + } + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + } + const req = info.httpModule.request(info.options, (msg) => { + const res = new HttpClientResponse(msg); + handleResult(void 0, res); + }); + let socket; + req.on("socket", (sock) => { + socket = sock; + }); + req.setTimeout(this._socketTimeout || 3 * 6e4, () => { + if (socket) { + socket.end(); + } + handleResult(new Error(`Request timeout: ${info.options.path}`)); + }); + req.on("error", function(err) { + handleResult(err); + }); + if (data && typeof data === "string") { + req.write(data, "utf8"); + } + if (data && typeof data !== "string") { + data.on("close", function() { + req.end(); + }); + data.pipe(req); + } else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + getAgentDispatcher(serverUrl) { + const parsedUrl = new URL(serverUrl); + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (!useProxy) { + return; + } + return this._getProxyAgentDispatcher(parsedUrl, proxyUrl); + } + _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); + if (this.handlers) { + for (const handler of this.handlers) { + handler.prepareRequest(info.options); + } + } + return info; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (!useProxy) { + agent = this._agent; + } + if (agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === "https:"; + let maxSockets = 100; + if (this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + }), { host: proxyUrl.hostname, port: proxyUrl.port }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === "https:"; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + if (!agent) { + const options = { keepAlive: this._keepAlive, maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + if (usingSsl && this._ignoreSslError) { + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _getProxyAgentDispatcher(parsedUrl, proxyUrl) { + let proxyAgent; + if (this._keepAlive) { + proxyAgent = this._proxyAgentDispatcher; + } + if (proxyAgent) { + return proxyAgent; + } + const usingSsl = parsedUrl.protocol === "https:"; + proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, (proxyUrl.username || proxyUrl.password) && { + token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString("base64")}` + })); + this._proxyAgentDispatcher = proxyAgent; + if (usingSsl && this._ignoreSslError) { + proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { + rejectUnauthorized: false + }); + } + return proxyAgent; + } + _performExponentialBackoff(retryNumber) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise((resolve) => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + if (statusCode === HttpCodes.NotFound) { + resolve(response); + } + function dateTimeDeserializer(key, value) { + if (typeof value === "string") { + const a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, dateTimeDeserializer); + } else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } catch (err) { + } + if (statusCode > 299) { + let msg; + if (obj && obj.message) { + msg = obj.message; + } else if (contents && contents.length > 0) { + msg = contents; + } else { + msg = `Failed request: (${statusCode})`; + } + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } else { + resolve(response); + } + })); + }); + } + }; + exports2.HttpClient = HttpClient; + var lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {}); + } +}); + +// node_modules/@actions/http-client/lib/auth.js +var require_auth = __commonJS({ + "node_modules/@actions/http-client/lib/auth.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.PersonalAccessTokenCredentialHandler = exports2.BearerCredentialHandler = exports2.BasicCredentialHandler = void 0; + var BasicCredentialHandler = class { + constructor(username, password) { + this.username = username; + this.password = password; + } + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BasicCredentialHandler = BasicCredentialHandler; + var BearerCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Bearer ${this.token}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.BearerCredentialHandler = BearerCredentialHandler; + var PersonalAccessTokenCredentialHandler = class { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error("The request has no headers"); + } + options.headers["Authorization"] = `Basic ${Buffer.from(`PAT:${this.token}`).toString("base64")}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error("not implemented"); + }); + } + }; + exports2.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; + } +}); + +// node_modules/@actions/core/lib/oidc-utils.js +var require_oidc_utils = __commonJS({ + "node_modules/@actions/core/lib/oidc-utils.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.OidcClient = void 0; + var http_client_1 = require_lib(); + var auth_1 = require_auth(); + var core_1 = require_core(); + var OidcClient = class _OidcClient { + static createHttpClient(allowRetry = true, maxRetry = 10) { + const requestOptions = { + allowRetries: allowRetry, + maxRetries: maxRetry + }; + return new http_client_1.HttpClient("actions/oidc-client", [new auth_1.BearerCredentialHandler(_OidcClient.getRequestToken())], requestOptions); + } + static getRequestToken() { + const token = process.env["ACTIONS_ID_TOKEN_REQUEST_TOKEN"]; + if (!token) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable"); + } + return token; + } + static getIDTokenUrl() { + const runtimeUrl = process.env["ACTIONS_ID_TOKEN_REQUEST_URL"]; + if (!runtimeUrl) { + throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable"); + } + return runtimeUrl; + } + static getCall(id_token_url) { + var _a2; + return __awaiter(this, void 0, void 0, function* () { + const httpclient = _OidcClient.createHttpClient(); + const res = yield httpclient.getJson(id_token_url).catch((error) => { + throw new Error(`Failed to get ID Token. + + Error Code : ${error.statusCode} + + Error Message: ${error.message}`); + }); + const id_token = (_a2 = res.result) === null || _a2 === void 0 ? void 0 : _a2.value; + if (!id_token) { + throw new Error("Response json body do not have ID Token field"); + } + return id_token; + }); + } + static getIDToken(audience) { + return __awaiter(this, void 0, void 0, function* () { + try { + let id_token_url = _OidcClient.getIDTokenUrl(); + if (audience) { + const encodedAudience = encodeURIComponent(audience); + id_token_url = `${id_token_url}&audience=${encodedAudience}`; + } + (0, core_1.debug)(`ID token url is ${id_token_url}`); + const id_token = yield _OidcClient.getCall(id_token_url); + (0, core_1.setSecret)(id_token); + return id_token; + } catch (error) { + throw new Error(`Error message: ${error.message}`); + } + }); + } + }; + exports2.OidcClient = OidcClient; + } +}); + +// node_modules/@actions/core/lib/summary.js +var require_summary = __commonJS({ + "node_modules/@actions/core/lib/summary.js"(exports2) { + "use strict"; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.summary = exports2.markdownSummary = exports2.SUMMARY_DOCS_URL = exports2.SUMMARY_ENV_VAR = void 0; + var os_1 = require("os"); + var fs_1 = require("fs"); + var { access, appendFile, writeFile } = fs_1.promises; + exports2.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY"; + exports2.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary"; + var Summary = class { + constructor() { + this._buffer = ""; + } + /** + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path + */ + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[exports2.SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${exports2.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); + } catch (_a2) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); + } + /** + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element + */ + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join(""); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } + /** + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance + */ + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: "utf8" }); + return this.emptyBuffer(); + }); + } + /** + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance + */ + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } + /** + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer + */ + stringify() { + return this._buffer; + } + /** + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty + */ + isEmptyBuffer() { + return this._buffer.length === 0; + } + /** + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance + */ + emptyBuffer() { + this._buffer = ""; + return this; + } + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; + } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(os_1.EOL); + } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, lang && { lang }); + const element = this.wrap("pre", this.wrap("code", code), attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? "ol" : "ul"; + const listItems = items.map((item) => this.wrap("li", item)).join(""); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows.map((row) => { + const cells = row.map((cell) => { + if (typeof cell === "string") { + return this.wrap("td", cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? "th" : "td"; + const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan }); + return this.wrap(tag, data, attrs); + }).join(""); + return this.wrap("tr", cells); + }).join(""); + const element = this.wrap("table", tableBody); + return this.addRaw(element).addEOL(); + } + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap("details", this.wrap("summary", label) + content); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, width && { width }), height && { height }); + const element = this.wrap("img", null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) ? tag : "h1"; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap("hr", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap("br", null); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, cite && { cite }); + const element = this.wrap("blockquote", text, attrs); + return this.addRaw(element).addEOL(); + } + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap("a", text, { href }); + return this.addRaw(element).addEOL(); + } + }; + var _summary = new Summary(); + exports2.markdownSummary = _summary; + exports2.summary = _summary; + } +}); + +// node_modules/@actions/core/lib/path-utils.js +var require_path_utils = __commonJS({ + "node_modules/@actions/core/lib/path-utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = void 0; + var path3 = __importStar(require("path")); + function toPosixPath(pth) { + return pth.replace(/[\\]/g, "/"); + } + exports2.toPosixPath = toPosixPath; + function toWin32Path(pth) { + return pth.replace(/[/]/g, "\\"); + } + exports2.toWin32Path = toWin32Path; + function toPlatformPath(pth) { + return pth.replace(/[/\\]/g, path3.sep); + } + exports2.toPlatformPath = toPlatformPath; + } +}); + +// node_modules/@actions/io/lib/io-util.js +var require_io_util = __commonJS({ + "node_modules/@actions/io/lib/io-util.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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 _a2; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getCmdPath = exports2.tryGetExecutablePath = exports2.isRooted = exports2.isDirectory = exports2.exists = exports2.READONLY = exports2.UV_FS_O_EXLOCK = exports2.IS_WINDOWS = exports2.unlink = exports2.symlink = exports2.stat = exports2.rmdir = exports2.rm = exports2.rename = exports2.readlink = exports2.readdir = exports2.open = exports2.mkdir = exports2.lstat = exports2.copyFile = exports2.chmod = void 0; + var fs2 = __importStar(require("fs")); + var path3 = __importStar(require("path")); + _a2 = fs2.promises, exports2.chmod = _a2.chmod, exports2.copyFile = _a2.copyFile, exports2.lstat = _a2.lstat, exports2.mkdir = _a2.mkdir, exports2.open = _a2.open, exports2.readdir = _a2.readdir, exports2.readlink = _a2.readlink, exports2.rename = _a2.rename, exports2.rm = _a2.rm, exports2.rmdir = _a2.rmdir, exports2.stat = _a2.stat, exports2.symlink = _a2.symlink, exports2.unlink = _a2.unlink; + exports2.IS_WINDOWS = process.platform === "win32"; + exports2.UV_FS_O_EXLOCK = 268435456; + exports2.READONLY = fs2.constants.O_RDONLY; + function exists(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + try { + yield exports2.stat(fsPath); + } catch (err) { + if (err.code === "ENOENT") { + return false; + } + throw err; + } + return true; + }); + } + exports2.exists = exists; + function isDirectory(fsPath, useStat = false) { + return __awaiter(this, void 0, void 0, function* () { + const stats = useStat ? yield exports2.stat(fsPath) : yield exports2.lstat(fsPath); + return stats.isDirectory(); + }); + } + exports2.isDirectory = isDirectory; + function isRooted(p) { + p = normalizeSeparators(p); + if (!p) { + throw new Error('isRooted() parameter "p" cannot be empty'); + } + if (exports2.IS_WINDOWS) { + return p.startsWith("\\") || /^[A-Z]:/i.test(p); + } + return p.startsWith("/"); + } + exports2.isRooted = isRooted; + function tryGetExecutablePath(filePath, extensions) { + return __awaiter(this, void 0, void 0, function* () { + let stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + const upperExt = path3.extname(filePath).toUpperCase(); + if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) { + return filePath; + } + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + const originalFilePath = filePath; + for (const extension of extensions) { + filePath = originalFilePath + extension; + stats = void 0; + try { + stats = yield exports2.stat(filePath); + } catch (err) { + if (err.code !== "ENOENT") { + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports2.IS_WINDOWS) { + try { + const directory = path3.dirname(filePath); + const upperName = path3.basename(filePath).toUpperCase(); + for (const actualName of yield exports2.readdir(directory)) { + if (upperName === actualName.toUpperCase()) { + filePath = path3.join(directory, actualName); + break; + } + } + } catch (err) { + console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); + } + return filePath; + } else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + } + return ""; + }); + } + exports2.tryGetExecutablePath = tryGetExecutablePath; + function normalizeSeparators(p) { + p = p || ""; + if (exports2.IS_WINDOWS) { + p = p.replace(/\//g, "\\"); + return p.replace(/\\\\+/g, "\\"); + } + return p.replace(/\/\/+/g, "/"); + } + function isUnixExecutable(stats) { + return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid(); + } + function getCmdPath() { + var _a3; + return (_a3 = process.env["COMSPEC"]) !== null && _a3 !== void 0 ? _a3 : `cmd.exe`; + } + exports2.getCmdPath = getCmdPath; + } +}); + +// node_modules/@actions/io/lib/io.js +var require_io = __commonJS({ + "node_modules/@actions/io/lib/io.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.findInPath = exports2.which = exports2.mkdirP = exports2.rmRF = exports2.mv = exports2.cp = void 0; + var assert_1 = require("assert"); + var path3 = __importStar(require("path")); + var ioUtil = __importStar(require_io_util()); + function cp(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + const { force, recursive, copySourceDirectory } = readCopyOptions(options); + const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; + if (destStat && destStat.isFile() && !force) { + return; + } + const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path3.join(dest, path3.basename(source)) : dest; + if (!(yield ioUtil.exists(source))) { + throw new Error(`no such file or directory: ${source}`); + } + const sourceStat = yield ioUtil.stat(source); + if (sourceStat.isDirectory()) { + if (!recursive) { + throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); + } else { + yield cpDirRecursive(source, newDest, 0, force); + } + } else { + if (path3.relative(source, newDest) === "") { + throw new Error(`'${newDest}' and '${source}' are the same file`); + } + yield copyFile(source, newDest, force); + } + }); + } + exports2.cp = cp; + function mv(source, dest, options = {}) { + return __awaiter(this, void 0, void 0, function* () { + if (yield ioUtil.exists(dest)) { + let destExists = true; + if (yield ioUtil.isDirectory(dest)) { + dest = path3.join(dest, path3.basename(source)); + destExists = yield ioUtil.exists(dest); + } + if (destExists) { + if (options.force == null || options.force) { + yield rmRF(dest); + } else { + throw new Error("Destination already exists"); + } + } + } + yield mkdirP(path3.dirname(dest)); + yield ioUtil.rename(source, dest); + }); + } + exports2.mv = mv; + function rmRF(inputPath) { + return __awaiter(this, void 0, void 0, function* () { + if (ioUtil.IS_WINDOWS) { + if (/[*"<>|]/.test(inputPath)) { + throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows'); + } + } + try { + yield ioUtil.rm(inputPath, { + force: true, + maxRetries: 3, + recursive: true, + retryDelay: 300 + }); + } catch (err) { + throw new Error(`File was unable to be removed ${err}`); + } + }); + } + exports2.rmRF = rmRF; + function mkdirP(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + assert_1.ok(fsPath, "a path argument must be provided"); + yield ioUtil.mkdir(fsPath, { recursive: true }); + }); + } + exports2.mkdirP = mkdirP; + function which(tool, check) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + if (check) { + const result = yield which(tool, false); + if (!result) { + if (ioUtil.IS_WINDOWS) { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); + } else { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); + } + } + return result; + } + const matches = yield findInPath(tool); + if (matches && matches.length > 0) { + return matches[0]; + } + return ""; + }); + } + exports2.which = which; + function findInPath(tool) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + const extensions = []; + if (ioUtil.IS_WINDOWS && process.env["PATHEXT"]) { + for (const extension of process.env["PATHEXT"].split(path3.delimiter)) { + if (extension) { + extensions.push(extension); + } + } + } + if (ioUtil.isRooted(tool)) { + const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); + if (filePath) { + return [filePath]; + } + return []; + } + if (tool.includes(path3.sep)) { + return []; + } + const directories = []; + if (process.env.PATH) { + for (const p of process.env.PATH.split(path3.delimiter)) { + if (p) { + directories.push(p); + } + } + } + const matches = []; + for (const directory of directories) { + const filePath = yield ioUtil.tryGetExecutablePath(path3.join(directory, tool), extensions); + if (filePath) { + matches.push(filePath); + } + } + return matches; + }); + } + exports2.findInPath = findInPath; + function readCopyOptions(options) { + const force = options.force == null ? true : options.force; + const recursive = Boolean(options.recursive); + const copySourceDirectory = options.copySourceDirectory == null ? true : Boolean(options.copySourceDirectory); + return { force, recursive, copySourceDirectory }; + } + function cpDirRecursive(sourceDir, destDir, currentDepth, force) { + return __awaiter(this, void 0, void 0, function* () { + if (currentDepth >= 255) + return; + currentDepth++; + yield mkdirP(destDir); + const files = yield ioUtil.readdir(sourceDir); + for (const fileName of files) { + const srcFile = `${sourceDir}/${fileName}`; + const destFile = `${destDir}/${fileName}`; + const srcFileStat = yield ioUtil.lstat(srcFile); + if (srcFileStat.isDirectory()) { + yield cpDirRecursive(srcFile, destFile, currentDepth, force); + } else { + yield copyFile(srcFile, destFile, force); + } + } + yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); + }); + } + function copyFile(srcFile, destFile, force) { + return __awaiter(this, void 0, void 0, function* () { + if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { + try { + yield ioUtil.lstat(destFile); + yield ioUtil.unlink(destFile); + } catch (e) { + if (e.code === "EPERM") { + yield ioUtil.chmod(destFile, "0666"); + yield ioUtil.unlink(destFile); + } + } + const symlinkFull = yield ioUtil.readlink(srcFile); + yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? "junction" : null); + } else if (!(yield ioUtil.exists(destFile)) || force) { + yield ioUtil.copyFile(srcFile, destFile); + } + }); + } + } +}); + +// node_modules/@actions/exec/lib/toolrunner.js +var require_toolrunner = __commonJS({ + "node_modules/@actions/exec/lib/toolrunner.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.argStringToArray = exports2.ToolRunner = void 0; + var os = __importStar(require("os")); + var events = __importStar(require("events")); + var child = __importStar(require("child_process")); + var path3 = __importStar(require("path")); + var io = __importStar(require_io()); + var ioUtil = __importStar(require_io_util()); + var timers_1 = require("timers"); + var IS_WINDOWS = process.platform === "win32"; + var ToolRunner = class extends events.EventEmitter { + constructor(toolPath, args, options) { + super(); + if (!toolPath) { + throw new Error("Parameter 'toolPath' cannot be null or empty."); + } + this.toolPath = toolPath; + this.args = args || []; + this.options = options || {}; + } + _debug(message) { + if (this.options.listeners && this.options.listeners.debug) { + this.options.listeners.debug(message); + } + } + _getCommandString(options, noPrefix) { + const toolPath = this._getSpawnFileName(); + const args = this._getSpawnArgs(options); + let cmd = noPrefix ? "" : "[command]"; + if (IS_WINDOWS) { + if (this._isCmdFile()) { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } else if (options.windowsVerbatimArguments) { + cmd += `"${toolPath}"`; + for (const a of args) { + cmd += ` ${a}`; + } + } else { + cmd += this._windowsQuoteCmdArg(toolPath); + for (const a of args) { + cmd += ` ${this._windowsQuoteCmdArg(a)}`; + } + } + } else { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } + return cmd; + } + _processLineBuffer(data, strBuffer, onLine) { + try { + let s = strBuffer + data.toString(); + let n = s.indexOf(os.EOL); + while (n > -1) { + const line = s.substring(0, n); + onLine(line); + s = s.substring(n + os.EOL.length); + n = s.indexOf(os.EOL); + } + return s; + } catch (err) { + this._debug(`error processing line. Failed with error ${err}`); + return ""; + } + } + _getSpawnFileName() { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + return process.env["COMSPEC"] || "cmd.exe"; + } + } + return this.toolPath; + } + _getSpawnArgs(options) { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; + for (const a of this.args) { + argline += " "; + argline += options.windowsVerbatimArguments ? a : this._windowsQuoteCmdArg(a); + } + argline += '"'; + return [argline]; + } + } + return this.args; + } + _endsWith(str, end) { + return str.endsWith(end); + } + _isCmdFile() { + const upperToolPath = this.toolPath.toUpperCase(); + return this._endsWith(upperToolPath, ".CMD") || this._endsWith(upperToolPath, ".BAT"); + } + _windowsQuoteCmdArg(arg) { + if (!this._isCmdFile()) { + return this._uvQuoteCmdArg(arg); + } + if (!arg) { + return '""'; + } + const cmdSpecialChars = [ + " ", + " ", + "&", + "(", + ")", + "[", + "]", + "{", + "}", + "^", + "=", + ";", + "!", + "'", + "+", + ",", + "`", + "~", + "|", + "<", + ">", + '"' + ]; + let needsQuotes = false; + for (const char of arg) { + if (cmdSpecialChars.some((x) => x === char)) { + needsQuotes = true; + break; + } + } + if (!needsQuotes) { + return arg; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += '"'; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _uvQuoteCmdArg(arg) { + if (!arg) { + return '""'; + } + if (!arg.includes(" ") && !arg.includes(" ") && !arg.includes('"')) { + return arg; + } + if (!arg.includes('"') && !arg.includes("\\")) { + return `"${arg}"`; + } + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === "\\") { + reverse += "\\"; + } else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += "\\"; + } else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split("").reverse().join(""); + } + _cloneExecOptions(options) { + options = options || {}; + const result = { + cwd: options.cwd || process.cwd(), + env: options.env || process.env, + silent: options.silent || false, + windowsVerbatimArguments: options.windowsVerbatimArguments || false, + failOnStdErr: options.failOnStdErr || false, + ignoreReturnCode: options.ignoreReturnCode || false, + delay: options.delay || 1e4 + }; + result.outStream = options.outStream || process.stdout; + result.errStream = options.errStream || process.stderr; + return result; + } + _getSpawnOptions(options, toolPath) { + options = options || {}; + const result = {}; + result.cwd = options.cwd; + result.env = options.env; + result["windowsVerbatimArguments"] = options.windowsVerbatimArguments || this._isCmdFile(); + if (options.windowsVerbatimArguments) { + result.argv0 = `"${toolPath}"`; + } + return result; + } + /** + * Exec a tool. + * Output will be streamed to the live console. + * Returns promise with return code + * + * @param tool path to tool to exec + * @param options optional exec options. See ExecOptions + * @returns number + */ + exec() { + return __awaiter(this, void 0, void 0, function* () { + if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\"))) { + this.toolPath = path3.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); + } + this.toolPath = yield io.which(this.toolPath, true); + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + this._debug(`exec tool: ${this.toolPath}`); + this._debug("arguments:"); + for (const arg of this.args) { + this._debug(` ${arg}`); + } + const optionsNonNull = this._cloneExecOptions(this.options); + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); + } + const state = new ExecState(optionsNonNull, this.toolPath); + state.on("debug", (message) => { + this._debug(message); + }); + if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) { + return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); + } + const fileName = this._getSpawnFileName(); + const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); + let stdbuffer = ""; + if (cp.stdout) { + cp.stdout.on("data", (data) => { + if (this.options.listeners && this.options.listeners.stdout) { + this.options.listeners.stdout(data); + } + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(data); + } + stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { + if (this.options.listeners && this.options.listeners.stdline) { + this.options.listeners.stdline(line); + } + }); + }); + } + let errbuffer = ""; + if (cp.stderr) { + cp.stderr.on("data", (data) => { + state.processStderr = true; + if (this.options.listeners && this.options.listeners.stderr) { + this.options.listeners.stderr(data); + } + if (!optionsNonNull.silent && optionsNonNull.errStream && optionsNonNull.outStream) { + const s = optionsNonNull.failOnStdErr ? optionsNonNull.errStream : optionsNonNull.outStream; + s.write(data); + } + errbuffer = this._processLineBuffer(data, errbuffer, (line) => { + if (this.options.listeners && this.options.listeners.errline) { + this.options.listeners.errline(line); + } + }); + }); + } + cp.on("error", (err) => { + state.processError = err.message; + state.processExited = true; + state.processClosed = true; + state.CheckComplete(); + }); + cp.on("exit", (code) => { + state.processExitCode = code; + state.processExited = true; + this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); + state.CheckComplete(); + }); + cp.on("close", (code) => { + state.processExitCode = code; + state.processExited = true; + state.processClosed = true; + this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); + state.CheckComplete(); + }); + state.on("done", (error, exitCode) => { + if (stdbuffer.length > 0) { + this.emit("stdline", stdbuffer); + } + if (errbuffer.length > 0) { + this.emit("errline", errbuffer); + } + cp.removeAllListeners(); + if (error) { + reject(error); + } else { + resolve(exitCode); + } + }); + if (this.options.input) { + if (!cp.stdin) { + throw new Error("child process missing stdin"); + } + cp.stdin.end(this.options.input); + } + })); + }); + } + }; + exports2.ToolRunner = ToolRunner; + function argStringToArray(argString) { + const args = []; + let inQuotes = false; + let escaped = false; + let arg = ""; + function append(c) { + if (escaped && c !== '"') { + arg += "\\"; + } + arg += c; + escaped = false; + } + for (let i = 0; i < argString.length; i++) { + const c = argString.charAt(i); + if (c === '"') { + if (!escaped) { + inQuotes = !inQuotes; + } else { + append(c); + } + continue; + } + if (c === "\\" && escaped) { + append(c); + continue; + } + if (c === "\\" && inQuotes) { + escaped = true; + continue; + } + if (c === " " && !inQuotes) { + if (arg.length > 0) { + args.push(arg); + arg = ""; + } + continue; + } + append(c); + } + if (arg.length > 0) { + args.push(arg.trim()); + } + return args; + } + exports2.argStringToArray = argStringToArray; + var ExecState = class _ExecState extends events.EventEmitter { + constructor(options, toolPath) { + super(); + this.processClosed = false; + this.processError = ""; + this.processExitCode = 0; + this.processExited = false; + this.processStderr = false; + this.delay = 1e4; + this.done = false; + this.timeout = null; + if (!toolPath) { + throw new Error("toolPath must not be empty"); + } + this.options = options; + this.toolPath = toolPath; + if (options.delay) { + this.delay = options.delay; + } + } + CheckComplete() { + if (this.done) { + return; + } + if (this.processClosed) { + this._setResult(); + } else if (this.processExited) { + this.timeout = timers_1.setTimeout(_ExecState.HandleTimeout, this.delay, this); + } + } + _debug(message) { + this.emit("debug", message); + } + _setResult() { + let error; + if (this.processExited) { + if (this.processError) { + error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); + } else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { + error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); + } else if (this.processStderr && this.options.failOnStdErr) { + error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); + } + } + if (this.timeout) { + clearTimeout(this.timeout); + this.timeout = null; + } + this.done = true; + this.emit("done", error, this.processExitCode); + } + static HandleTimeout(state) { + if (state.done) { + return; + } + if (!state.processClosed && state.processExited) { + const message = `The STDIO streams did not close within ${state.delay / 1e3} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; + state._debug(message); + } + state._setResult(); + } + }; + } +}); + +// node_modules/@actions/exec/lib/exec.js +var require_exec = __commonJS({ + "node_modules/@actions/exec/lib/exec.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { + return m[k]; + } }); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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 = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getExecOutput = exports2.exec = void 0; + var string_decoder_1 = require("string_decoder"); + var tr = __importStar(require_toolrunner()); + function exec5(commandLine, args, options) { + return __awaiter(this, void 0, void 0, function* () { + const commandArgs = tr.argStringToArray(commandLine); + if (commandArgs.length === 0) { + throw new Error(`Parameter 'commandLine' cannot be null or empty.`); + } + const toolPath = commandArgs[0]; + args = commandArgs.slice(1).concat(args || []); + const runner = new tr.ToolRunner(toolPath, args, options); + return runner.exec(); + }); + } + exports2.exec = exec5; + function getExecOutput3(commandLine, args, options) { + var _a2, _b; + return __awaiter(this, void 0, void 0, function* () { + let stdout = ""; + let stderr = ""; + const stdoutDecoder = new string_decoder_1.StringDecoder("utf8"); + const stderrDecoder = new string_decoder_1.StringDecoder("utf8"); + const originalStdoutListener = (_a2 = options === null || options === void 0 ? void 0 : options.listeners) === null || _a2 === void 0 ? void 0 : _a2.stdout; + const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr; + const stdErrListener = (data) => { + stderr += stderrDecoder.write(data); + if (originalStdErrListener) { + originalStdErrListener(data); + } + }; + const stdOutListener = (data) => { + stdout += stdoutDecoder.write(data); + if (originalStdoutListener) { + originalStdoutListener(data); + } + }; + const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener }); + const exitCode = yield exec5(commandLine, args, Object.assign(Object.assign({}, options), { listeners })); + stdout += stdoutDecoder.end(); + stderr += stderrDecoder.end(); + return { + exitCode, + stdout, + stderr + }; + }); + } + exports2.getExecOutput = getExecOutput3; + } +}); + +// node_modules/@actions/core/lib/platform.js +var require_platform = __commonJS({ + "node_modules/@actions/core/lib/platform.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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 = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getDetails = exports2.isLinux = exports2.isMacOS = exports2.isWindows = exports2.arch = exports2.platform = void 0; + var os_1 = __importDefault(require("os")); + var exec5 = __importStar(require_exec()); + var getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout: version } = yield exec5.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', void 0, { + silent: true + }); + const { stdout: name } = yield exec5.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', void 0, { + silent: true + }); + return { + name: name.trim(), + version: version.trim() + }; + }); + var getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + var _a2, _b, _c, _d; + const { stdout } = yield exec5.getExecOutput("sw_vers", void 0, { + silent: true + }); + const version = (_b = (_a2 = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a2 === void 0 ? void 0 : _a2[1]) !== null && _b !== void 0 ? _b : ""; + const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ""; + return { + name, + version + }; + }); + var getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout } = yield exec5.getExecOutput("lsb_release", ["-i", "-r", "-s"], { + silent: true + }); + const [name, version] = stdout.trim().split("\n"); + return { + name, + version + }; + }); + exports2.platform = os_1.default.platform(); + exports2.arch = os_1.default.arch(); + exports2.isWindows = exports2.platform === "win32"; + exports2.isMacOS = exports2.platform === "darwin"; + exports2.isLinux = exports2.platform === "linux"; + function getDetails2() { + return __awaiter(this, void 0, void 0, function* () { + return Object.assign(Object.assign({}, yield exports2.isWindows ? getWindowsInfo() : exports2.isMacOS ? getMacOsInfo() : getLinuxInfo()), { + platform: exports2.platform, + arch: exports2.arch, + isWindows: exports2.isWindows, + isMacOS: exports2.isMacOS, + isLinux: exports2.isLinux + }); + }); + } + exports2.getDetails = getDetails2; + } +}); + +// node_modules/@actions/core/lib/core.js +var require_core = __commonJS({ + "node_modules/@actions/core/lib/core.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.platform = exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = exports2.markdownSummary = exports2.summary = exports2.getIDToken = exports2.getState = exports2.saveState = exports2.group = exports2.endGroup = exports2.startGroup = exports2.info = exports2.notice = exports2.warning = exports2.error = exports2.debug = exports2.isDebug = exports2.setFailed = exports2.setCommandEcho = exports2.setOutput = exports2.getBooleanInput = exports2.getMultilineInput = exports2.getInput = exports2.addPath = exports2.setSecret = exports2.exportVariable = exports2.ExitCode = void 0; + var command_1 = require_command(); + var file_command_1 = require_file_command(); + var utils_1 = require_utils(); + var os = __importStar(require("os")); + var path3 = __importStar(require("path")); + var oidc_utils_1 = require_oidc_utils(); + var ExitCode; + (function(ExitCode2) { + ExitCode2[ExitCode2["Success"] = 0] = "Success"; + ExitCode2[ExitCode2["Failure"] = 1] = "Failure"; + })(ExitCode || (exports2.ExitCode = ExitCode = {})); + function exportVariable(name, val) { + const convertedVal = (0, utils_1.toCommandValue)(val); + process.env[name] = convertedVal; + const filePath = process.env["GITHUB_ENV"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("ENV", (0, file_command_1.prepareKeyValueMessage)(name, val)); + } + (0, command_1.issueCommand)("set-env", { name }, convertedVal); + } + exports2.exportVariable = exportVariable; + function setSecret(secret) { + (0, command_1.issueCommand)("add-mask", {}, secret); + } + exports2.setSecret = setSecret; + function addPath(inputPath) { + const filePath = process.env["GITHUB_PATH"] || ""; + if (filePath) { + (0, file_command_1.issueFileCommand)("PATH", inputPath); + } else { + (0, command_1.issueCommand)("add-path", {}, inputPath); + } + process.env["PATH"] = `${inputPath}${path3.delimiter}${process.env["PATH"]}`; + } + exports2.addPath = addPath; + function getInput2(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || ""; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); + } + exports2.getInput = getInput2; + function getMultilineInput(name, options) { + const inputs = getInput2(name, options).split("\n").filter((x) => x !== ""); + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map((input) => input.trim()); + } + exports2.getMultilineInput = getMultilineInput; + function getBooleanInput2(name, options) { + const trueValue = ["true", "True", "TRUE"]; + const falseValue = ["false", "False", "FALSE"]; + const val = getInput2(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} +Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); + } + exports2.getBooleanInput = getBooleanInput2; + function setOutput2(name, value) { + const filePath = process.env["GITHUB_OUTPUT"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("OUTPUT", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + process.stdout.write(os.EOL); + (0, command_1.issueCommand)("set-output", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.setOutput = setOutput2; + function setCommandEcho(enabled) { + (0, command_1.issue)("echo", enabled ? "on" : "off"); + } + exports2.setCommandEcho = setCommandEcho; + function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); + } + exports2.setFailed = setFailed; + function isDebug() { + return process.env["RUNNER_DEBUG"] === "1"; + } + exports2.isDebug = isDebug; + function debug(message) { + (0, command_1.issueCommand)("debug", {}, message); + } + exports2.debug = debug; + function error(message, properties = {}) { + (0, command_1.issueCommand)("error", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.error = error; + function warning(message, properties = {}) { + (0, command_1.issueCommand)("warning", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.warning = warning; + function notice(message, properties = {}) { + (0, command_1.issueCommand)("notice", (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); + } + exports2.notice = notice; + function info(message) { + process.stdout.write(message + os.EOL); + } + exports2.info = info; + function startGroup2(name) { + (0, command_1.issue)("group", name); + } + exports2.startGroup = startGroup2; + function endGroup2() { + (0, command_1.issue)("endgroup"); + } + exports2.endGroup = endGroup2; + function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup2(name); + let result; + try { + result = yield fn(); + } finally { + endGroup2(); + } + return result; + }); + } + exports2.group = group; + function saveState(name, value) { + const filePath = process.env["GITHUB_STATE"] || ""; + if (filePath) { + return (0, file_command_1.issueFileCommand)("STATE", (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + (0, command_1.issueCommand)("save-state", { name }, (0, utils_1.toCommandValue)(value)); + } + exports2.saveState = saveState; + function getState(name) { + return process.env[`STATE_${name}`] || ""; + } + exports2.getState = getState; + function getIDToken(aud) { + return __awaiter(this, void 0, void 0, function* () { + return yield oidc_utils_1.OidcClient.getIDToken(aud); + }); + } + exports2.getIDToken = getIDToken; + var summary_1 = require_summary(); + Object.defineProperty(exports2, "summary", { enumerable: true, get: function() { + return summary_1.summary; + } }); + var summary_2 = require_summary(); + Object.defineProperty(exports2, "markdownSummary", { enumerable: true, get: function() { + return summary_2.markdownSummary; + } }); + var path_utils_1 = require_path_utils(); + Object.defineProperty(exports2, "toPosixPath", { enumerable: true, get: function() { + return path_utils_1.toPosixPath; + } }); + Object.defineProperty(exports2, "toWin32Path", { enumerable: true, get: function() { + return path_utils_1.toWin32Path; + } }); + Object.defineProperty(exports2, "toPlatformPath", { enumerable: true, get: function() { + return path_utils_1.toPlatformPath; + } }); + exports2.platform = __importStar(require_platform()); + } +}); + +// node_modules/@actions/github/lib/context.js +var require_context = __commonJS({ + "node_modules/@actions/github/lib/context.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Context = void 0; + var fs_1 = require("fs"); + var os_1 = require("os"); + var Context = class { + /** + * Hydrate the context from the environment + */ + constructor() { + var _a2, _b, _c; + this.payload = {}; + if (process.env.GITHUB_EVENT_PATH) { + if ((0, fs_1.existsSync)(process.env.GITHUB_EVENT_PATH)) { + this.payload = JSON.parse((0, fs_1.readFileSync)(process.env.GITHUB_EVENT_PATH, { encoding: "utf8" })); + } else { + const path3 = process.env.GITHUB_EVENT_PATH; + process.stdout.write(`GITHUB_EVENT_PATH ${path3} 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.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT, 10); + this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10); + this.runId = parseInt(process.env.GITHUB_RUN_ID, 10); + this.apiUrl = (_a2 = process.env.GITHUB_API_URL) !== null && _a2 !== void 0 ? _a2 : `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'"); + } + }; + exports2.Context = Context; + } +}); + +// node_modules/@actions/github/lib/internal/utils.js +var require_utils3 = __commonJS({ + "node_modules/@actions/github/lib/internal/utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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; + }; + var __awaiter = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getApiBaseUrl = exports2.getProxyFetch = exports2.getProxyAgentDispatcher = exports2.getProxyAgent = exports2.getAuthString = void 0; + var httpClient = __importStar(require_lib()); + var undici_1 = require_undici(); + 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}`; + } + exports2.getAuthString = getAuthString; + function getProxyAgent(destinationUrl) { + const hc = new httpClient.HttpClient(); + return hc.getAgent(destinationUrl); + } + exports2.getProxyAgent = getProxyAgent; + function getProxyAgentDispatcher(destinationUrl) { + const hc = new httpClient.HttpClient(); + return hc.getAgentDispatcher(destinationUrl); + } + exports2.getProxyAgentDispatcher = getProxyAgentDispatcher; + function getProxyFetch(destinationUrl) { + const httpDispatcher = getProxyAgentDispatcher(destinationUrl); + const proxyFetch = (url, opts) => __awaiter(this, void 0, void 0, function* () { + return (0, undici_1.fetch)(url, Object.assign(Object.assign({}, opts), { dispatcher: httpDispatcher })); + }); + return proxyFetch; + } + exports2.getProxyFetch = getProxyFetch; + function getApiBaseUrl() { + return process.env["GITHUB_API_URL"] || "https://api.github.com"; + } + exports2.getApiBaseUrl = getApiBaseUrl; + } +}); + +// node_modules/universal-user-agent/dist-node/index.js +var require_dist_node = __commonJS({ + "node_modules/universal-user-agent/dist-node/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + function getUserAgent() { + if (typeof navigator === "object" && "userAgent" in navigator) { + return navigator.userAgent; + } + if (typeof process === "object" && process.version !== void 0) { + return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`; + } + return ""; + } + exports2.getUserAgent = getUserAgent; + } +}); + +// node_modules/before-after-hook/lib/register.js +var require_register = __commonJS({ + "node_modules/before-after-hook/lib/register.js"(exports2, module2) { + module2.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, name2) { + return register.bind(null, state, name2, callback, options); + }, method)(); + } + return Promise.resolve().then(function() { + if (!state.registry[name]) { + return method(options); + } + return state.registry[name].reduce(function(method2, registered) { + return registered.hook.bind(null, method2, options); + }, method)(); + }); + } + } +}); + +// node_modules/before-after-hook/lib/add.js +var require_add = __commonJS({ + "node_modules/before-after-hook/lib/add.js"(exports2, module2) { + module2.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, + orig + }); + } + } +}); + +// node_modules/before-after-hook/lib/remove.js +var require_remove = __commonJS({ + "node_modules/before-after-hook/lib/remove.js"(exports2, module2) { + module2.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); + } + } +}); + +// node_modules/before-after-hook/index.js +var require_before_after_hook = __commonJS({ + "node_modules/before-after-hook/index.js"(exports2, module2) { + var register = require_register(); + var addHook = require_add(); + var removeHook = require_remove(); + 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 Hook2() { + 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(); + } + Hook2.Singular = HookSingular.bind(); + Hook2.Collection = HookCollection.bind(); + module2.exports = Hook2; + module2.exports.Hook = Hook2; + module2.exports.Singular = Hook2.Singular; + module2.exports.Collection = Hook2.Collection; + } +}); + +// node_modules/@octokit/endpoint/dist-node/index.js +var require_dist_node2 = __commonJS({ + "node_modules/@octokit/endpoint/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + endpoint: () => endpoint + }); + module2.exports = __toCommonJS(dist_src_exports); + var import_universal_user_agent = require_dist_node(); + var VERSION3 = "9.0.6"; + var userAgent = `octokit-endpoint.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}`; + var DEFAULTS = { + method: "GET", + baseUrl: "https://api.github.com", + headers: { + accept: "application/vnd.github.v3+json", + "user-agent": userAgent + }, + mediaType: { + format: "" + } + }; + function lowercaseKeys(object) { + if (!object) { + return {}; + } + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); + } + function isPlainObject(value) { + if (typeof value !== "object" || value === null) + return false; + if (Object.prototype.toString.call(value) !== "[object Object]") + return false; + const proto = Object.getPrototypeOf(value); + if (proto === null) + return true; + const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor; + return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value); + } + function mergeDeep(defaults3, options) { + const result = Object.assign({}, defaults3); + Object.keys(options).forEach((key) => { + if (isPlainObject(options[key])) { + if (!(key in defaults3)) + Object.assign(result, { [key]: options[key] }); + else + result[key] = mergeDeep(defaults3[key], options[key]); + } else { + Object.assign(result, { [key]: options[key] }); + } + }); + return result; + } + function removeUndefinedProperties(obj) { + for (const key in obj) { + if (obj[key] === void 0) { + delete obj[key]; + } + } + return obj; + } + function merge(defaults3, 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); + } + options.headers = lowercaseKeys(options.headers); + removeUndefinedProperties(options); + removeUndefinedProperties(options.headers); + const mergedOptions = mergeDeep(defaults3 || {}, options); + if (options.url === "/graphql") { + if (defaults3 && defaults3.mediaType.previews?.length) { + mergedOptions.mediaType.previews = defaults3.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("&"); + } + var urlVariableRegex = /\{[^{}}]+\}/g; + function removeNonChars(variableName) { + return variableName.replace(/(?:^\W+)|(?:(? a.concat(b), []); + } + function omit(object, keysToOmit) { + const result = { __proto__: null }; + for (const key of Object.keys(object)) { + if (keysToOmit.indexOf(key) === -1) { + result[key] = object[key]; + } + } + return result; + } + 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 !== void 0 && value !== null; + } + function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; + } + function getValues(context3, operator, key, modifier) { + var value = context3[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(value2) { + result.push( + encodeValue(operator, value2, 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(value2) { + tmp.push(encodeValue(operator, value2)); + }); + } 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, context3) { + var operators = ["+", "#", ".", "/", ";", "?", "&"]; + template = 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(context3, 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); + } + } + ); + if (template === "/") { + return template; + } else { + return template.replace(/\/$/, ""); + } + } + function parse(options) { + let method = options.method.toUpperCase(); + 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" + ]); + 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) { + headers.accept = headers.accept.split(/,/).map( + (format) => format.replace( + /application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, + `application/vnd$1$2.${options.mediaType.format}` + ) + ).join(","); + } + if (url.endsWith("/graphql")) { + if (options.mediaType.previews?.length) { + const previewsFromAcceptHeader = headers.accept.match(/(? { + const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; + return `application/vnd.github.${preview}-preview${format}`; + }).join(","); + } + } + } + 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; + } + } + } + if (!headers["content-type"] && typeof body !== "undefined") { + headers["content-type"] = "application/json; charset=utf-8"; + } + if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") { + body = ""; + } + return Object.assign( + { method, url, headers }, + typeof body !== "undefined" ? { body } : null, + options.request ? { request: options.request } : null + ); + } + function endpointWithDefaults(defaults3, route, options) { + return parse(merge(defaults3, route, options)); + } + function withDefaults(oldDefaults, newDefaults) { + const DEFAULTS2 = merge(oldDefaults, newDefaults); + const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2); + return Object.assign(endpoint2, { + DEFAULTS: DEFAULTS2, + defaults: withDefaults.bind(null, DEFAULTS2), + merge: merge.bind(null, DEFAULTS2), + parse + }); + } + var endpoint = withDefaults(null, DEFAULTS); + } +}); + +// node_modules/deprecation/dist-node/index.js +var require_dist_node3 = __commonJS({ + "node_modules/deprecation/dist-node/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var Deprecation = class extends Error { + constructor(message) { + super(message); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + this.name = "Deprecation"; + } + }; + exports2.Deprecation = Deprecation; + } +}); + +// node_modules/wrappy/wrappy.js +var require_wrappy = __commonJS({ + "node_modules/wrappy/wrappy.js"(exports2, module2) { + module2.exports = wrappy; + function wrappy(fn, cb) { + if (fn && cb) return wrappy(fn)(cb); + if (typeof fn !== "function") + throw new TypeError("need wrapper function"); + Object.keys(fn).forEach(function(k) { + wrapper[k] = fn[k]; + }); + return wrapper; + function wrapper() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + var ret = fn.apply(this, args); + var cb2 = args[args.length - 1]; + if (typeof ret === "function" && ret !== cb2) { + Object.keys(cb2).forEach(function(k) { + ret[k] = cb2[k]; + }); + } + return ret; + } + } + } +}); + +// node_modules/once/once.js +var require_once = __commonJS({ + "node_modules/once/once.js"(exports2, module2) { + var wrappy = require_wrappy(); + module2.exports = wrappy(once); + module2.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; + } + } +}); + +// node_modules/@octokit/request-error/dist-node/index.js +var require_dist_node4 = __commonJS({ + "node_modules/@octokit/request-error/dist-node/index.js"(exports2, module2) { + "use strict"; + var __create2 = Object.create; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __getProtoOf2 = Object.getPrototypeOf; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target, + mod + )); + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + RequestError: () => RequestError + }); + module2.exports = __toCommonJS(dist_src_exports); + var import_deprecation = require_dist_node3(); + var import_once = __toESM2(require_once()); + var logOnceCode = (0, import_once.default)((deprecation) => console.warn(deprecation)); + var logOnceHeaders = (0, import_once.default)((deprecation) => console.warn(deprecation)); + var RequestError = class extends Error { + constructor(message, statusCode, options) { + super(message); + 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; + } + const requestCopy = Object.assign({}, options.request); + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace( + /(? { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + request: () => request + }); + module2.exports = __toCommonJS(dist_src_exports); + var import_endpoint = require_dist_node2(); + var import_universal_user_agent = require_dist_node(); + var VERSION3 = "8.4.1"; + function isPlainObject(value) { + if (typeof value !== "object" || value === null) + return false; + if (Object.prototype.toString.call(value) !== "[object Object]") + return false; + const proto = Object.getPrototypeOf(value); + if (proto === null) + return true; + const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor; + return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value); + } + var import_request_error = require_dist_node4(); + function getBufferResponse(response) { + return response.arrayBuffer(); + } + function fetchWrapper(requestOptions) { + var _a2, _b, _c, _d; + const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console; + const parseSuccessResponseBody = ((_a2 = requestOptions.request) == null ? void 0 : _a2.parseSuccessResponseBody) !== false; + if (isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { + requestOptions.body = JSON.stringify(requestOptions.body); + } + let headers = {}; + let status; + let url; + let { fetch: fetch2 } = globalThis; + if ((_b = requestOptions.request) == null ? void 0 : _b.fetch) { + fetch2 = requestOptions.request.fetch; + } + if (!fetch2) { + throw new Error( + "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing" + ); + } + return fetch2(requestOptions.url, { + method: requestOptions.method, + body: requestOptions.body, + redirect: (_c = requestOptions.request) == null ? void 0 : _c.redirect, + headers: requestOptions.headers, + signal: (_d = requestOptions.request) == null ? void 0 : _d.signal, + // duplex must be set if request.body is ReadableStream or Async Iterables. + // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex. + ...requestOptions.body && { duplex: "half" } + }).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; + } + if (requestOptions.method === "HEAD") { + if (status < 400) { + return; + } + throw new import_request_error.RequestError(response.statusText, status, { + response: { + url, + status, + headers, + data: void 0 + }, + request: requestOptions + }); + } + if (status === 304) { + throw new import_request_error.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 import_request_error.RequestError(toErrorMessage(data), status, { + response: { + url, + status, + headers, + data + }, + request: requestOptions + }); + throw error; + } + return parseSuccessResponseBody ? await getResponseData(response) : response.body; + }).then((data) => { + return { + status, + url, + headers, + data + }; + }).catch((error) => { + if (error instanceof import_request_error.RequestError) + throw error; + else if (error.name === "AbortError") + throw error; + let message = error.message; + if (error.name === "TypeError" && "cause" in error) { + if (error.cause instanceof Error) { + message = error.cause.message; + } else if (typeof error.cause === "string") { + message = error.cause; + } + } + throw new import_request_error.RequestError(message, 500, { + request: requestOptions + }); + }); + } + async function getResponseData(response) { + const contentType = response.headers.get("content-type"); + if (/application\/json/.test(contentType)) { + return response.json().catch(() => response.text()).catch(() => ""); + } + if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { + return response.text(); + } + return getBufferResponse(response); + } + function toErrorMessage(data) { + if (typeof data === "string") + return data; + let suffix; + if ("documentation_url" in data) { + suffix = ` - ${data.documentation_url}`; + } else { + suffix = ""; + } + if ("message" in data) { + if (Array.isArray(data.errors)) { + return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}${suffix}`; + } + return `${data.message}${suffix}`; + } + return `Unknown error: ${JSON.stringify(data)}`; + } + function withDefaults(oldEndpoint, newDefaults) { + const endpoint2 = oldEndpoint.defaults(newDefaults); + const newApi = function(route, parameters) { + const endpointOptions = endpoint2.merge(route, parameters); + if (!endpointOptions.request || !endpointOptions.request.hook) { + return fetchWrapper(endpoint2.parse(endpointOptions)); + } + const request2 = (route2, parameters2) => { + return fetchWrapper( + endpoint2.parse(endpoint2.merge(route2, parameters2)) + ); + }; + Object.assign(request2, { + endpoint: endpoint2, + defaults: withDefaults.bind(null, endpoint2) + }); + return endpointOptions.request.hook(request2, endpointOptions); + }; + return Object.assign(newApi, { + endpoint: endpoint2, + defaults: withDefaults.bind(null, endpoint2) + }); + } + var request = withDefaults(import_endpoint.endpoint, { + headers: { + "user-agent": `octokit-request.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}` + } + }); + } +}); + +// node_modules/@octokit/graphql/dist-node/index.js +var require_dist_node6 = __commonJS({ + "node_modules/@octokit/graphql/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var index_exports = {}; + __export(index_exports, { + GraphqlResponseError: () => GraphqlResponseError, + graphql: () => graphql2, + withCustomRequest: () => withCustomRequest + }); + module2.exports = __toCommonJS(index_exports); + var import_request3 = require_dist_node5(); + var import_universal_user_agent = require_dist_node(); + var VERSION3 = "7.1.1"; + var import_request2 = require_dist_node5(); + var import_request = require_dist_node5(); + function _buildMessageForResponseErrors(data) { + return `Request failed due to following response errors: +` + data.errors.map((e) => ` - ${e.message}`).join("\n"); + } + var GraphqlResponseError = class extends Error { + constructor(request2, headers, response) { + super(_buildMessageForResponseErrors(response)); + this.request = request2; + this.headers = headers; + this.response = response; + this.name = "GraphqlResponseError"; + this.errors = response.errors; + this.data = response.data; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } + }; + var NON_VARIABLE_OPTIONS = [ + "method", + "baseUrl", + "url", + "headers", + "request", + "query", + "mediaType" + ]; + var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"]; + var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; + function graphql(request2, 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; + }, {}); + const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl; + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { + requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + } + return request2(requestOptions).then((response) => { + if (response.data.errors) { + const headers = {}; + for (const key of Object.keys(response.headers)) { + headers[key] = response.headers[key]; + } + throw new GraphqlResponseError( + requestOptions, + headers, + response.data + ); + } + return response.data.data; + }); + } + function withDefaults(request2, newDefaults) { + const newRequest = request2.defaults(newDefaults); + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + return Object.assign(newApi, { + defaults: withDefaults.bind(null, newRequest), + endpoint: newRequest.endpoint + }); + } + var graphql2 = withDefaults(import_request3.request, { + headers: { + "user-agent": `octokit-graphql.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}` + }, + method: "POST", + url: "/graphql" + }); + function withCustomRequest(customRequest) { + return withDefaults(customRequest, { + method: "POST", + url: "/graphql" + }); + } + } +}); + +// node_modules/@octokit/auth-token/dist-node/index.js +var require_dist_node7 = __commonJS({ + "node_modules/@octokit/auth-token/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + createTokenAuth: () => createTokenAuth + }); + module2.exports = __toCommonJS(dist_src_exports); + var REGEX_IS_INSTALLATION_LEGACY = /^v1\./; + var REGEX_IS_INSTALLATION = /^ghs_/; + var REGEX_IS_USER_TO_SERVER = /^ghu_/; + async function auth(token) { + const isApp = token.split(/\./).length === 3; + const isInstallation = REGEX_IS_INSTALLATION_LEGACY.test(token) || REGEX_IS_INSTALLATION.test(token); + const isUserToServer = REGEX_IS_USER_TO_SERVER.test(token); + const tokenType = isApp ? "app" : isInstallation ? "installation" : isUserToServer ? "user-to-server" : "oauth"; + return { + type: "token", + token, + tokenType + }; + } + 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); + } + var createTokenAuth = function createTokenAuth2(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) + }); + }; + } +}); + +// node_modules/@octokit/core/dist-node/index.js +var require_dist_node8 = __commonJS({ + "node_modules/@octokit/core/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var index_exports = {}; + __export(index_exports, { + Octokit: () => Octokit + }); + module2.exports = __toCommonJS(index_exports); + var import_universal_user_agent = require_dist_node(); + var import_before_after_hook = require_before_after_hook(); + var import_request = require_dist_node5(); + var import_graphql = require_dist_node6(); + var import_auth_token = require_dist_node7(); + var VERSION3 = "5.2.1"; + var noop3 = () => { + }; + var consoleWarn = console.warn.bind(console); + var consoleError = console.error.bind(console); + var userAgentTrail = `octokit-core.js/${VERSION3} ${(0, import_universal_user_agent.getUserAgent)()}`; + var Octokit = class { + static { + this.VERSION = VERSION3; + } + static defaults(defaults3) { + const OctokitWithDefaults = class extends this { + constructor(...args) { + const options = args[0] || {}; + if (typeof defaults3 === "function") { + super(defaults3(options)); + return; + } + super( + Object.assign( + {}, + defaults3, + options, + options.userAgent && defaults3.userAgent ? { + userAgent: `${options.userAgent} ${defaults3.userAgent}` + } : null + ) + ); + } + }; + return OctokitWithDefaults; + } + static { + this.plugins = []; + } + /** + * Attach a plugin (or many) to your Octokit instance. + * + * @example + * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...) + */ + static plugin(...newPlugins) { + const currentPlugins = this.plugins; + const NewOctokit = class extends this { + static { + this.plugins = currentPlugins.concat( + newPlugins.filter((plugin) => !currentPlugins.includes(plugin)) + ); + } + }; + return NewOctokit; + } + constructor(options = {}) { + const hook = new import_before_after_hook.Collection(); + const requestDefaults = { + baseUrl: import_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: "" + } + }; + requestDefaults.headers["user-agent"] = options.userAgent ? `${options.userAgent} ${userAgentTrail}` : userAgentTrail; + 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 = import_request.request.defaults(requestDefaults); + this.graphql = (0, import_graphql.withCustomRequest)(this.request).defaults(requestDefaults); + this.log = Object.assign( + { + debug: noop3, + info: noop3, + warn: consoleWarn, + error: consoleError + }, + options.log + ); + this.hook = hook; + if (!options.authStrategy) { + if (!options.auth) { + this.auth = async () => ({ + type: "unauthenticated" + }); + } else { + const auth = (0, import_auth_token.createTokenAuth)(options.auth); + hook.wrap("request", auth.hook); + this.auth = auth; + } + } else { + const { authStrategy, ...otherOptions } = options; + const auth = authStrategy( + Object.assign( + { + request: this.request, + log: this.log, + // we pass the current octokit instance as well as its constructor options + // to allow for authentication strategies that return a new octokit instance + // that shares the same internal state as the current one. The original + // requirement for this was the "event-octokit" authentication strategy + // of https://github.com/probot/octokit-auth-probot. + octokit: this, + octokitOptions: otherOptions + }, + options.auth + ) + ); + hook.wrap("request", auth.hook); + this.auth = auth; + } + const classConstructor = this.constructor; + for (let i = 0; i < classConstructor.plugins.length; ++i) { + Object.assign(this, classConstructor.plugins[i](this, options)); + } + } + }; + } +}); + +// node_modules/@octokit/plugin-rest-endpoint-methods/dist-node/index.js +var require_dist_node9 = __commonJS({ + "node_modules/@octokit/plugin-rest-endpoint-methods/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + legacyRestEndpointMethods: () => legacyRestEndpointMethods, + restEndpointMethods: () => restEndpointMethods + }); + module2.exports = __toCommonJS(dist_src_exports); + var VERSION3 = "10.4.1"; + var Endpoints = { + actions: { + addCustomLabelsToSelfHostedRunnerForOrg: [ + "POST /orgs/{org}/actions/runners/{runner_id}/labels" + ], + addCustomLabelsToSelfHostedRunnerForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + addSelectedRepoToOrgSecret: [ + "PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}" + ], + addSelectedRepoToOrgVariable: [ + "PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}" + ], + approveWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve" + ], + cancelWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel" + ], + createEnvironmentVariable: [ + "POST /repositories/{repository_id}/environments/{environment_name}/variables" + ], + createOrUpdateEnvironmentSecret: [ + "PUT /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}" + ], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"], + createOrUpdateRepoSecret: [ + "PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}" + ], + createOrgVariable: ["POST /orgs/{org}/actions/variables"], + createRegistrationTokenForOrg: [ + "POST /orgs/{org}/actions/runners/registration-token" + ], + createRegistrationTokenForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/registration-token" + ], + createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"], + createRemoveTokenForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/remove-token" + ], + createRepoVariable: ["POST /repos/{owner}/{repo}/actions/variables"], + createWorkflowDispatch: [ + "POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches" + ], + deleteActionsCacheById: [ + "DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}" + ], + deleteActionsCacheByKey: [ + "DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}" + ], + deleteArtifact: [ + "DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}" + ], + deleteEnvironmentSecret: [ + "DELETE /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}" + ], + deleteEnvironmentVariable: [ + "DELETE /repositories/{repository_id}/environments/{environment_name}/variables/{name}" + ], + deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"], + deleteOrgVariable: ["DELETE /orgs/{org}/actions/variables/{name}"], + deleteRepoSecret: [ + "DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}" + ], + deleteRepoVariable: [ + "DELETE /repos/{owner}/{repo}/actions/variables/{name}" + ], + deleteSelfHostedRunnerFromOrg: [ + "DELETE /orgs/{org}/actions/runners/{runner_id}" + ], + deleteSelfHostedRunnerFromRepo: [ + "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}" + ], + deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"], + deleteWorkflowRunLogs: [ + "DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs" + ], + disableSelectedRepositoryGithubActionsOrganization: [ + "DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}" + ], + disableWorkflow: [ + "PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable" + ], + downloadArtifact: [ + "GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}" + ], + downloadJobLogsForWorkflowRun: [ + "GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs" + ], + downloadWorkflowRunAttemptLogs: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs" + ], + downloadWorkflowRunLogs: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs" + ], + enableSelectedRepositoryGithubActionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/repositories/{repository_id}" + ], + enableWorkflow: [ + "PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable" + ], + forceCancelWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel" + ], + generateRunnerJitconfigForOrg: [ + "POST /orgs/{org}/actions/runners/generate-jitconfig" + ], + generateRunnerJitconfigForRepo: [ + "POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig" + ], + getActionsCacheList: ["GET /repos/{owner}/{repo}/actions/caches"], + getActionsCacheUsage: ["GET /repos/{owner}/{repo}/actions/cache/usage"], + getActionsCacheUsageByRepoForOrg: [ + "GET /orgs/{org}/actions/cache/usage-by-repository" + ], + getActionsCacheUsageForOrg: ["GET /orgs/{org}/actions/cache/usage"], + getAllowedActionsOrganization: [ + "GET /orgs/{org}/actions/permissions/selected-actions" + ], + getAllowedActionsRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions/selected-actions" + ], + getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + getCustomOidcSubClaimForRepo: [ + "GET /repos/{owner}/{repo}/actions/oidc/customization/sub" + ], + getEnvironmentPublicKey: [ + "GET /repositories/{repository_id}/environments/{environment_name}/secrets/public-key" + ], + getEnvironmentSecret: [ + "GET /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}" + ], + getEnvironmentVariable: [ + "GET /repositories/{repository_id}/environments/{environment_name}/variables/{name}" + ], + getGithubActionsDefaultWorkflowPermissionsOrganization: [ + "GET /orgs/{org}/actions/permissions/workflow" + ], + getGithubActionsDefaultWorkflowPermissionsRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions/workflow" + ], + getGithubActionsPermissionsOrganization: [ + "GET /orgs/{org}/actions/permissions" + ], + getGithubActionsPermissionsRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions" + ], + getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"], + getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"], + getOrgVariable: ["GET /orgs/{org}/actions/variables/{name}"], + getPendingDeploymentsForRun: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments" + ], + getRepoPermissions: [ + "GET /repos/{owner}/{repo}/actions/permissions", + {}, + { renamed: ["actions", "getGithubActionsPermissionsRepository"] } + ], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + getRepoVariable: ["GET /repos/{owner}/{repo}/actions/variables/{name}"], + getReviewsForRun: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals" + ], + getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"], + getSelfHostedRunnerForRepo: [ + "GET /repos/{owner}/{repo}/actions/runners/{runner_id}" + ], + getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"], + getWorkflowAccessToRepository: [ + "GET /repos/{owner}/{repo}/actions/permissions/access" + ], + getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], + getWorkflowRunAttempt: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}" + ], + getWorkflowRunUsage: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing" + ], + getWorkflowUsage: [ + "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing" + ], + listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], + listEnvironmentSecrets: [ + "GET /repositories/{repository_id}/environments/{environment_name}/secrets" + ], + listEnvironmentVariables: [ + "GET /repositories/{repository_id}/environments/{environment_name}/variables" + ], + listJobsForWorkflowRun: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs" + ], + listJobsForWorkflowRunAttempt: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs" + ], + listLabelsForSelfHostedRunnerForOrg: [ + "GET /orgs/{org}/actions/runners/{runner_id}/labels" + ], + listLabelsForSelfHostedRunnerForRepo: [ + "GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + listOrgSecrets: ["GET /orgs/{org}/actions/secrets"], + listOrgVariables: ["GET /orgs/{org}/actions/variables"], + listRepoOrganizationSecrets: [ + "GET /repos/{owner}/{repo}/actions/organization-secrets" + ], + listRepoOrganizationVariables: [ + "GET /repos/{owner}/{repo}/actions/organization-variables" + ], + listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"], + listRepoVariables: ["GET /repos/{owner}/{repo}/actions/variables"], + 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" + ], + listSelectedReposForOrgVariable: [ + "GET /orgs/{org}/actions/variables/{name}/repositories" + ], + listSelectedRepositoriesEnabledGithubActionsOrganization: [ + "GET /orgs/{org}/actions/permissions/repositories" + ], + listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"], + listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"], + listWorkflowRunArtifacts: [ + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts" + ], + listWorkflowRuns: [ + "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs" + ], + listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"], + reRunJobForWorkflowRun: [ + "POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun" + ], + reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], + reRunWorkflowFailedJobs: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs" + ], + removeAllCustomLabelsFromSelfHostedRunnerForOrg: [ + "DELETE /orgs/{org}/actions/runners/{runner_id}/labels" + ], + removeAllCustomLabelsFromSelfHostedRunnerForRepo: [ + "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + removeCustomLabelFromSelfHostedRunnerForOrg: [ + "DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}" + ], + removeCustomLabelFromSelfHostedRunnerForRepo: [ + "DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}" + ], + removeSelectedRepoFromOrgSecret: [ + "DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}" + ], + removeSelectedRepoFromOrgVariable: [ + "DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}" + ], + reviewCustomGatesForRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule" + ], + reviewPendingDeploymentsForRun: [ + "POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments" + ], + setAllowedActionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/selected-actions" + ], + setAllowedActionsRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions/selected-actions" + ], + setCustomLabelsForSelfHostedRunnerForOrg: [ + "PUT /orgs/{org}/actions/runners/{runner_id}/labels" + ], + setCustomLabelsForSelfHostedRunnerForRepo: [ + "PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels" + ], + setCustomOidcSubClaimForRepo: [ + "PUT /repos/{owner}/{repo}/actions/oidc/customization/sub" + ], + setGithubActionsDefaultWorkflowPermissionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/workflow" + ], + setGithubActionsDefaultWorkflowPermissionsRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions/workflow" + ], + setGithubActionsPermissionsOrganization: [ + "PUT /orgs/{org}/actions/permissions" + ], + setGithubActionsPermissionsRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions" + ], + setSelectedReposForOrgSecret: [ + "PUT /orgs/{org}/actions/secrets/{secret_name}/repositories" + ], + setSelectedReposForOrgVariable: [ + "PUT /orgs/{org}/actions/variables/{name}/repositories" + ], + setSelectedRepositoriesEnabledGithubActionsOrganization: [ + "PUT /orgs/{org}/actions/permissions/repositories" + ], + setWorkflowAccessToRepository: [ + "PUT /repos/{owner}/{repo}/actions/permissions/access" + ], + updateEnvironmentVariable: [ + "PATCH /repositories/{repository_id}/environments/{environment_name}/variables/{name}" + ], + updateOrgVariable: ["PATCH /orgs/{org}/actions/variables/{name}"], + updateRepoVariable: [ + "PATCH /repos/{owner}/{repo}/actions/variables/{name}" + ] + }, + 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"], + markThreadAsDone: ["DELETE /notifications/threads/{thread_id}"], + markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"], + setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"], + setThreadSubscription: [ + "PUT /notifications/threads/{thread_id}/subscription" + ], + starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"], + unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"] + }, + apps: { + addRepoToInstallation: [ + "PUT /user/installations/{installation_id}/repositories/{repository_id}", + {}, + { renamed: ["apps", "addRepoToInstallationForAuthenticatedUser"] } + ], + addRepoToInstallationForAuthenticatedUser: [ + "PUT /user/installations/{installation_id}/repositories/{repository_id}" + ], + checkToken: ["POST /applications/{client_id}/token"], + createFromManifest: ["POST /app-manifests/{code}/conversions"], + createInstallationAccessToken: [ + "POST /app/installations/{installation_id}/access_tokens" + ], + deleteAuthorization: ["DELETE /applications/{client_id}/grant"], + deleteInstallation: ["DELETE /app/installations/{installation_id}"], + deleteToken: ["DELETE /applications/{client_id}/token"], + getAuthenticated: ["GET /app"], + getBySlug: ["GET /apps/{app_slug}"], + getInstallation: ["GET /app/installations/{installation_id}"], + getOrgInstallation: ["GET /orgs/{org}/installation"], + getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"], + getSubscriptionPlanForAccount: [ + "GET /marketplace_listing/accounts/{account_id}" + ], + getSubscriptionPlanForAccountStubbed: [ + "GET /marketplace_listing/stubbed/accounts/{account_id}" + ], + getUserInstallation: ["GET /users/{username}/installation"], + getWebhookConfigForApp: ["GET /app/hook/config"], + getWebhookDelivery: ["GET /app/hook/deliveries/{delivery_id}"], + listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"], + listAccountsForPlanStubbed: [ + "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts" + ], + listInstallationReposForAuthenticatedUser: [ + "GET /user/installations/{installation_id}/repositories" + ], + listInstallationRequestsForAuthenticatedApp: [ + "GET /app/installation-requests" + ], + listInstallations: ["GET /app/installations"], + listInstallationsForAuthenticatedUser: ["GET /user/installations"], + listPlans: ["GET /marketplace_listing/plans"], + listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"], + listReposAccessibleToInstallation: ["GET /installation/repositories"], + listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"], + listSubscriptionsForAuthenticatedUserStubbed: [ + "GET /user/marketplace_purchases/stubbed" + ], + listWebhookDeliveries: ["GET /app/hook/deliveries"], + redeliverWebhookDelivery: [ + "POST /app/hook/deliveries/{delivery_id}/attempts" + ], + removeRepoFromInstallation: [ + "DELETE /user/installations/{installation_id}/repositories/{repository_id}", + {}, + { renamed: ["apps", "removeRepoFromInstallationForAuthenticatedUser"] } + ], + removeRepoFromInstallationForAuthenticatedUser: [ + "DELETE /user/installations/{installation_id}/repositories/{repository_id}" + ], + resetToken: ["PATCH /applications/{client_id}/token"], + revokeInstallationAccessToken: ["DELETE /installation/token"], + scopeToken: ["POST /applications/{client_id}/token/scoped"], + suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"], + unsuspendInstallation: [ + "DELETE /app/installations/{installation_id}/suspended" + ], + updateWebhookConfigForApp: ["PATCH /app/hook/config"] + }, + billing: { + getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"], + getGithubActionsBillingUser: [ + "GET /users/{username}/settings/billing/actions" + ], + getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"], + getGithubPackagesBillingUser: [ + "GET /users/{username}/settings/billing/packages" + ], + getSharedStorageBillingOrg: [ + "GET /orgs/{org}/settings/billing/shared-storage" + ], + getSharedStorageBillingUser: [ + "GET /users/{username}/settings/billing/shared-storage" + ] + }, + checks: { + create: ["POST /repos/{owner}/{repo}/check-runs"], + createSuite: ["POST /repos/{owner}/{repo}/check-suites"], + get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"], + getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"], + listAnnotations: [ + "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations" + ], + listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"], + listForSuite: [ + "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs" + ], + listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"], + rerequestRun: [ + "POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest" + ], + rerequestSuite: [ + "POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest" + ], + setSuitesPreferences: [ + "PATCH /repos/{owner}/{repo}/check-suites/preferences" + ], + update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"] + }, + codeScanning: { + deleteAnalysis: [ + "DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}" + ], + getAlert: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", + {}, + { renamedParameters: { alert_id: "alert_number" } } + ], + getAnalysis: [ + "GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}" + ], + getCodeqlDatabase: [ + "GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}" + ], + getDefaultSetup: ["GET /repos/{owner}/{repo}/code-scanning/default-setup"], + getSarif: ["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"], + listAlertInstances: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances" + ], + listAlertsForOrg: ["GET /orgs/{org}/code-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"], + listAlertsInstances: [ + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", + {}, + { renamed: ["codeScanning", "listAlertInstances"] } + ], + listCodeqlDatabases: [ + "GET /repos/{owner}/{repo}/code-scanning/codeql/databases" + ], + listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"], + updateAlert: [ + "PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}" + ], + updateDefaultSetup: [ + "PATCH /repos/{owner}/{repo}/code-scanning/default-setup" + ], + uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"] + }, + codesOfConduct: { + getAllCodesOfConduct: ["GET /codes_of_conduct"], + getConductCode: ["GET /codes_of_conduct/{key}"] + }, + codespaces: { + addRepositoryForSecretForAuthenticatedUser: [ + "PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + addSelectedRepoToOrgSecret: [ + "PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + checkPermissionsForDevcontainer: [ + "GET /repos/{owner}/{repo}/codespaces/permissions_check" + ], + codespaceMachinesForAuthenticatedUser: [ + "GET /user/codespaces/{codespace_name}/machines" + ], + createForAuthenticatedUser: ["POST /user/codespaces"], + createOrUpdateOrgSecret: [ + "PUT /orgs/{org}/codespaces/secrets/{secret_name}" + ], + createOrUpdateRepoSecret: [ + "PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}" + ], + createOrUpdateSecretForAuthenticatedUser: [ + "PUT /user/codespaces/secrets/{secret_name}" + ], + createWithPrForAuthenticatedUser: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces" + ], + createWithRepoForAuthenticatedUser: [ + "POST /repos/{owner}/{repo}/codespaces" + ], + deleteForAuthenticatedUser: ["DELETE /user/codespaces/{codespace_name}"], + deleteFromOrganization: [ + "DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}" + ], + deleteOrgSecret: ["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"], + deleteRepoSecret: [ + "DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}" + ], + deleteSecretForAuthenticatedUser: [ + "DELETE /user/codespaces/secrets/{secret_name}" + ], + exportForAuthenticatedUser: [ + "POST /user/codespaces/{codespace_name}/exports" + ], + getCodespacesForUserInOrg: [ + "GET /orgs/{org}/members/{username}/codespaces" + ], + getExportDetailsForAuthenticatedUser: [ + "GET /user/codespaces/{codespace_name}/exports/{export_id}" + ], + getForAuthenticatedUser: ["GET /user/codespaces/{codespace_name}"], + getOrgPublicKey: ["GET /orgs/{org}/codespaces/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/codespaces/secrets/{secret_name}"], + getPublicKeyForAuthenticatedUser: [ + "GET /user/codespaces/secrets/public-key" + ], + getRepoPublicKey: [ + "GET /repos/{owner}/{repo}/codespaces/secrets/public-key" + ], + getRepoSecret: [ + "GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}" + ], + getSecretForAuthenticatedUser: [ + "GET /user/codespaces/secrets/{secret_name}" + ], + listDevcontainersInRepositoryForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces/devcontainers" + ], + listForAuthenticatedUser: ["GET /user/codespaces"], + listInOrganization: [ + "GET /orgs/{org}/codespaces", + {}, + { renamedParameters: { org_id: "org" } } + ], + listInRepositoryForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces" + ], + listOrgSecrets: ["GET /orgs/{org}/codespaces/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/codespaces/secrets"], + listRepositoriesForSecretForAuthenticatedUser: [ + "GET /user/codespaces/secrets/{secret_name}/repositories" + ], + listSecretsForAuthenticatedUser: ["GET /user/codespaces/secrets"], + listSelectedReposForOrgSecret: [ + "GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories" + ], + preFlightWithRepoForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces/new" + ], + publishForAuthenticatedUser: [ + "POST /user/codespaces/{codespace_name}/publish" + ], + removeRepositoryForSecretForAuthenticatedUser: [ + "DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + removeSelectedRepoFromOrgSecret: [ + "DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}" + ], + repoMachinesForAuthenticatedUser: [ + "GET /repos/{owner}/{repo}/codespaces/machines" + ], + setRepositoriesForSecretForAuthenticatedUser: [ + "PUT /user/codespaces/secrets/{secret_name}/repositories" + ], + setSelectedReposForOrgSecret: [ + "PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories" + ], + startForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/start"], + stopForAuthenticatedUser: ["POST /user/codespaces/{codespace_name}/stop"], + stopInOrganization: [ + "POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop" + ], + updateForAuthenticatedUser: ["PATCH /user/codespaces/{codespace_name}"] + }, + copilot: { + addCopilotSeatsForTeams: [ + "POST /orgs/{org}/copilot/billing/selected_teams" + ], + addCopilotSeatsForUsers: [ + "POST /orgs/{org}/copilot/billing/selected_users" + ], + cancelCopilotSeatAssignmentForTeams: [ + "DELETE /orgs/{org}/copilot/billing/selected_teams" + ], + cancelCopilotSeatAssignmentForUsers: [ + "DELETE /orgs/{org}/copilot/billing/selected_users" + ], + getCopilotOrganizationDetails: ["GET /orgs/{org}/copilot/billing"], + getCopilotSeatDetailsForUser: [ + "GET /orgs/{org}/members/{username}/copilot" + ], + listCopilotSeats: ["GET /orgs/{org}/copilot/billing/seats"] + }, + dependabot: { + addSelectedRepoToOrgSecret: [ + "PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}" + ], + createOrUpdateOrgSecret: [ + "PUT /orgs/{org}/dependabot/secrets/{secret_name}" + ], + createOrUpdateRepoSecret: [ + "PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}" + ], + deleteOrgSecret: ["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"], + deleteRepoSecret: [ + "DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}" + ], + getAlert: ["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"], + getOrgPublicKey: ["GET /orgs/{org}/dependabot/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/dependabot/secrets/{secret_name}"], + getRepoPublicKey: [ + "GET /repos/{owner}/{repo}/dependabot/secrets/public-key" + ], + getRepoSecret: [ + "GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}" + ], + listAlertsForEnterprise: [ + "GET /enterprises/{enterprise}/dependabot/alerts" + ], + listAlertsForOrg: ["GET /orgs/{org}/dependabot/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/dependabot/alerts"], + listOrgSecrets: ["GET /orgs/{org}/dependabot/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/dependabot/secrets"], + listSelectedReposForOrgSecret: [ + "GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories" + ], + removeSelectedRepoFromOrgSecret: [ + "DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}" + ], + setSelectedReposForOrgSecret: [ + "PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories" + ], + updateAlert: [ + "PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}" + ] + }, + dependencyGraph: { + createRepositorySnapshot: [ + "POST /repos/{owner}/{repo}/dependency-graph/snapshots" + ], + diffRange: [ + "GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}" + ], + exportSbom: ["GET /repos/{owner}/{repo}/dependency-graph/sbom"] + }, + emojis: { get: ["GET /emojis"] }, + gists: { + checkIsStarred: ["GET /gists/{gist_id}/star"], + create: ["POST /gists"], + createComment: ["POST /gists/{gist_id}/comments"], + delete: ["DELETE /gists/{gist_id}"], + deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"], + fork: ["POST /gists/{gist_id}/forks"], + get: ["GET /gists/{gist_id}"], + getComment: ["GET /gists/{gist_id}/comments/{comment_id}"], + getRevision: ["GET /gists/{gist_id}/{sha}"], + list: ["GET /gists"], + listComments: ["GET /gists/{gist_id}/comments"], + listCommits: ["GET /gists/{gist_id}/commits"], + listForUser: ["GET /users/{username}/gists"], + listForks: ["GET /gists/{gist_id}/forks"], + listPublic: ["GET /gists/public"], + listStarred: ["GET /gists/starred"], + star: ["PUT /gists/{gist_id}/star"], + unstar: ["DELETE /gists/{gist_id}/star"], + update: ["PATCH /gists/{gist_id}"], + updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"] + }, + git: { + createBlob: ["POST /repos/{owner}/{repo}/git/blobs"], + createCommit: ["POST /repos/{owner}/{repo}/git/commits"], + createRef: ["POST /repos/{owner}/{repo}/git/refs"], + createTag: ["POST /repos/{owner}/{repo}/git/tags"], + createTree: ["POST /repos/{owner}/{repo}/git/trees"], + deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"], + getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"], + getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"], + getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"], + getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"], + getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"], + listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"], + updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"] + }, + gitignore: { + getAllTemplates: ["GET /gitignore/templates"], + getTemplate: ["GET /gitignore/templates/{name}"] + }, + interactions: { + getRestrictionsForAuthenticatedUser: ["GET /user/interaction-limits"], + getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"], + getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"], + getRestrictionsForYourPublicRepos: [ + "GET /user/interaction-limits", + {}, + { renamed: ["interactions", "getRestrictionsForAuthenticatedUser"] } + ], + removeRestrictionsForAuthenticatedUser: ["DELETE /user/interaction-limits"], + removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"], + removeRestrictionsForRepo: [ + "DELETE /repos/{owner}/{repo}/interaction-limits" + ], + removeRestrictionsForYourPublicRepos: [ + "DELETE /user/interaction-limits", + {}, + { renamed: ["interactions", "removeRestrictionsForAuthenticatedUser"] } + ], + setRestrictionsForAuthenticatedUser: ["PUT /user/interaction-limits"], + setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"], + setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"], + setRestrictionsForYourPublicRepos: [ + "PUT /user/interaction-limits", + {}, + { renamed: ["interactions", "setRestrictionsForAuthenticatedUser"] } + ] + }, + issues: { + addAssignees: [ + "POST /repos/{owner}/{repo}/issues/{issue_number}/assignees" + ], + addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"], + checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"], + checkUserCanBeAssignedToIssue: [ + "GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}" + ], + create: ["POST /repos/{owner}/{repo}/issues"], + createComment: [ + "POST /repos/{owner}/{repo}/issues/{issue_number}/comments" + ], + createLabel: ["POST /repos/{owner}/{repo}/labels"], + createMilestone: ["POST /repos/{owner}/{repo}/milestones"], + deleteComment: [ + "DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}" + ], + deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"], + deleteMilestone: [ + "DELETE /repos/{owner}/{repo}/milestones/{milestone_number}" + ], + get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"], + getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"], + getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"], + getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"], + getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"], + list: ["GET /issues"], + listAssignees: ["GET /repos/{owner}/{repo}/assignees"], + listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"], + listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"], + listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"], + listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"], + listEventsForTimeline: [ + "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline" + ], + listForAuthenticatedUser: ["GET /user/issues"], + listForOrg: ["GET /orgs/{org}/issues"], + listForRepo: ["GET /repos/{owner}/{repo}/issues"], + listLabelsForMilestone: [ + "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels" + ], + listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], + listLabelsOnIssue: [ + "GET /repos/{owner}/{repo}/issues/{issue_number}/labels" + ], + listMilestones: ["GET /repos/{owner}/{repo}/milestones"], + lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"], + removeAllLabels: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels" + ], + removeAssignees: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees" + ], + removeLabel: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}" + ], + setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"], + unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"], + update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"], + updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"], + updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"], + updateMilestone: [ + "PATCH /repos/{owner}/{repo}/milestones/{milestone_number}" + ] + }, + licenses: { + get: ["GET /licenses/{license}"], + getAllCommonlyUsed: ["GET /licenses"], + getForRepo: ["GET /repos/{owner}/{repo}/license"] + }, + markdown: { + render: ["POST /markdown"], + renderRaw: [ + "POST /markdown/raw", + { headers: { "content-type": "text/plain; charset=utf-8" } } + ] + }, + meta: { + get: ["GET /meta"], + getAllVersions: ["GET /versions"], + getOctocat: ["GET /octocat"], + getZen: ["GET /zen"], + root: ["GET /"] + }, + migrations: { + cancelImport: [ + "DELETE /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.cancelImport() is deprecated, see https://docs.github.com/rest/migrations/source-imports#cancel-an-import" + } + ], + deleteArchiveForAuthenticatedUser: [ + "DELETE /user/migrations/{migration_id}/archive" + ], + deleteArchiveForOrg: [ + "DELETE /orgs/{org}/migrations/{migration_id}/archive" + ], + downloadArchiveForOrg: [ + "GET /orgs/{org}/migrations/{migration_id}/archive" + ], + getArchiveForAuthenticatedUser: [ + "GET /user/migrations/{migration_id}/archive" + ], + getCommitAuthors: [ + "GET /repos/{owner}/{repo}/import/authors", + {}, + { + deprecated: "octokit.rest.migrations.getCommitAuthors() is deprecated, see https://docs.github.com/rest/migrations/source-imports#get-commit-authors" + } + ], + getImportStatus: [ + "GET /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.getImportStatus() is deprecated, see https://docs.github.com/rest/migrations/source-imports#get-an-import-status" + } + ], + getLargeFiles: [ + "GET /repos/{owner}/{repo}/import/large_files", + {}, + { + deprecated: "octokit.rest.migrations.getLargeFiles() is deprecated, see https://docs.github.com/rest/migrations/source-imports#get-large-files" + } + ], + getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}"], + getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}"], + listForAuthenticatedUser: ["GET /user/migrations"], + listForOrg: ["GET /orgs/{org}/migrations"], + listReposForAuthenticatedUser: [ + "GET /user/migrations/{migration_id}/repositories" + ], + listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories"], + listReposForUser: [ + "GET /user/migrations/{migration_id}/repositories", + {}, + { renamed: ["migrations", "listReposForAuthenticatedUser"] } + ], + mapCommitAuthor: [ + "PATCH /repos/{owner}/{repo}/import/authors/{author_id}", + {}, + { + deprecated: "octokit.rest.migrations.mapCommitAuthor() is deprecated, see https://docs.github.com/rest/migrations/source-imports#map-a-commit-author" + } + ], + setLfsPreference: [ + "PATCH /repos/{owner}/{repo}/import/lfs", + {}, + { + deprecated: "octokit.rest.migrations.setLfsPreference() is deprecated, see https://docs.github.com/rest/migrations/source-imports#update-git-lfs-preference" + } + ], + startForAuthenticatedUser: ["POST /user/migrations"], + startForOrg: ["POST /orgs/{org}/migrations"], + startImport: [ + "PUT /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.startImport() is deprecated, see https://docs.github.com/rest/migrations/source-imports#start-an-import" + } + ], + unlockRepoForAuthenticatedUser: [ + "DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock" + ], + unlockRepoForOrg: [ + "DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock" + ], + updateImport: [ + "PATCH /repos/{owner}/{repo}/import", + {}, + { + deprecated: "octokit.rest.migrations.updateImport() is deprecated, see https://docs.github.com/rest/migrations/source-imports#update-an-import" + } + ] + }, + oidc: { + getOidcCustomSubTemplateForOrg: [ + "GET /orgs/{org}/actions/oidc/customization/sub" + ], + updateOidcCustomSubTemplateForOrg: [ + "PUT /orgs/{org}/actions/oidc/customization/sub" + ] + }, + orgs: { + addSecurityManagerTeam: [ + "PUT /orgs/{org}/security-managers/teams/{team_slug}" + ], + assignTeamToOrgRole: [ + "PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}" + ], + assignUserToOrgRole: [ + "PUT /orgs/{org}/organization-roles/users/{username}/{role_id}" + ], + 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}" + ], + createCustomOrganizationRole: ["POST /orgs/{org}/organization-roles"], + createInvitation: ["POST /orgs/{org}/invitations"], + createOrUpdateCustomProperties: ["PATCH /orgs/{org}/properties/schema"], + createOrUpdateCustomPropertiesValuesForRepos: [ + "PATCH /orgs/{org}/properties/values" + ], + createOrUpdateCustomProperty: [ + "PUT /orgs/{org}/properties/schema/{custom_property_name}" + ], + createWebhook: ["POST /orgs/{org}/hooks"], + delete: ["DELETE /orgs/{org}"], + deleteCustomOrganizationRole: [ + "DELETE /orgs/{org}/organization-roles/{role_id}" + ], + deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"], + enableOrDisableSecurityProductOnAllOrgRepos: [ + "POST /orgs/{org}/{security_product}/{enablement}" + ], + get: ["GET /orgs/{org}"], + getAllCustomProperties: ["GET /orgs/{org}/properties/schema"], + getCustomProperty: [ + "GET /orgs/{org}/properties/schema/{custom_property_name}" + ], + getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"], + getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"], + getOrgRole: ["GET /orgs/{org}/organization-roles/{role_id}"], + 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"], + listCustomPropertiesValuesForRepos: ["GET /orgs/{org}/properties/values"], + 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"], + listOrgRoleTeams: ["GET /orgs/{org}/organization-roles/{role_id}/teams"], + listOrgRoleUsers: ["GET /orgs/{org}/organization-roles/{role_id}/users"], + listOrgRoles: ["GET /orgs/{org}/organization-roles"], + listOrganizationFineGrainedPermissions: [ + "GET /orgs/{org}/organization-fine-grained-permissions" + ], + listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"], + listPatGrantRepositories: [ + "GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories" + ], + listPatGrantRequestRepositories: [ + "GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories" + ], + listPatGrantRequests: ["GET /orgs/{org}/personal-access-token-requests"], + listPatGrants: ["GET /orgs/{org}/personal-access-tokens"], + listPendingInvitations: ["GET /orgs/{org}/invitations"], + listPublicMembers: ["GET /orgs/{org}/public_members"], + listSecurityManagerTeams: ["GET /orgs/{org}/security-managers"], + listWebhookDeliveries: ["GET /orgs/{org}/hooks/{hook_id}/deliveries"], + listWebhooks: ["GET /orgs/{org}/hooks"], + patchCustomOrganizationRole: [ + "PATCH /orgs/{org}/organization-roles/{role_id}" + ], + pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: [ + "POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts" + ], + removeCustomProperty: [ + "DELETE /orgs/{org}/properties/schema/{custom_property_name}" + ], + removeMember: ["DELETE /orgs/{org}/members/{username}"], + removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"], + removeOutsideCollaborator: [ + "DELETE /orgs/{org}/outside_collaborators/{username}" + ], + removePublicMembershipForAuthenticatedUser: [ + "DELETE /orgs/{org}/public_members/{username}" + ], + removeSecurityManagerTeam: [ + "DELETE /orgs/{org}/security-managers/teams/{team_slug}" + ], + reviewPatGrantRequest: [ + "POST /orgs/{org}/personal-access-token-requests/{pat_request_id}" + ], + reviewPatGrantRequestsInBulk: [ + "POST /orgs/{org}/personal-access-token-requests" + ], + revokeAllOrgRolesTeam: [ + "DELETE /orgs/{org}/organization-roles/teams/{team_slug}" + ], + revokeAllOrgRolesUser: [ + "DELETE /orgs/{org}/organization-roles/users/{username}" + ], + revokeOrgRoleTeam: [ + "DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}" + ], + revokeOrgRoleUser: [ + "DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}" + ], + 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}" + ], + updatePatAccess: ["POST /orgs/{org}/personal-access-tokens/{pat_id}"], + updatePatAccesses: ["POST /orgs/{org}/personal-access-tokens"], + updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"], + updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"] + }, + packages: { + deletePackageForAuthenticatedUser: [ + "DELETE /user/packages/{package_type}/{package_name}" + ], + deletePackageForOrg: [ + "DELETE /orgs/{org}/packages/{package_type}/{package_name}" + ], + deletePackageForUser: [ + "DELETE /users/{username}/packages/{package_type}/{package_name}" + ], + deletePackageVersionForAuthenticatedUser: [ + "DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + deletePackageVersionForOrg: [ + "DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + deletePackageVersionForUser: [ + "DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + getAllPackageVersionsForAPackageOwnedByAnOrg: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions", + {}, + { renamed: ["packages", "getAllPackageVersionsForPackageOwnedByOrg"] } + ], + getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}/versions", + {}, + { + renamed: [ + "packages", + "getAllPackageVersionsForPackageOwnedByAuthenticatedUser" + ] + } + ], + getAllPackageVersionsForPackageOwnedByAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}/versions" + ], + getAllPackageVersionsForPackageOwnedByOrg: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions" + ], + getAllPackageVersionsForPackageOwnedByUser: [ + "GET /users/{username}/packages/{package_type}/{package_name}/versions" + ], + getPackageForAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}" + ], + getPackageForOrganization: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}" + ], + getPackageForUser: [ + "GET /users/{username}/packages/{package_type}/{package_name}" + ], + getPackageVersionForAuthenticatedUser: [ + "GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + getPackageVersionForOrganization: [ + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + getPackageVersionForUser: [ + "GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}" + ], + listDockerMigrationConflictingPackagesForAuthenticatedUser: [ + "GET /user/docker/conflicts" + ], + listDockerMigrationConflictingPackagesForOrganization: [ + "GET /orgs/{org}/docker/conflicts" + ], + listDockerMigrationConflictingPackagesForUser: [ + "GET /users/{username}/docker/conflicts" + ], + listPackagesForAuthenticatedUser: ["GET /user/packages"], + listPackagesForOrganization: ["GET /orgs/{org}/packages"], + listPackagesForUser: ["GET /users/{username}/packages"], + restorePackageForAuthenticatedUser: [ + "POST /user/packages/{package_type}/{package_name}/restore{?token}" + ], + restorePackageForOrg: [ + "POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}" + ], + restorePackageForUser: [ + "POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}" + ], + restorePackageVersionForAuthenticatedUser: [ + "POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore" + ], + restorePackageVersionForOrg: [ + "POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore" + ], + restorePackageVersionForUser: [ + "POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore" + ] + }, + projects: { + addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}"], + createCard: ["POST /projects/columns/{column_id}/cards"], + createColumn: ["POST /projects/{project_id}/columns"], + createForAuthenticatedUser: ["POST /user/projects"], + createForOrg: ["POST /orgs/{org}/projects"], + createForRepo: ["POST /repos/{owner}/{repo}/projects"], + delete: ["DELETE /projects/{project_id}"], + deleteCard: ["DELETE /projects/columns/cards/{card_id}"], + deleteColumn: ["DELETE /projects/columns/{column_id}"], + get: ["GET /projects/{project_id}"], + getCard: ["GET /projects/columns/cards/{card_id}"], + getColumn: ["GET /projects/columns/{column_id}"], + getPermissionForUser: [ + "GET /projects/{project_id}/collaborators/{username}/permission" + ], + listCards: ["GET /projects/columns/{column_id}/cards"], + listCollaborators: ["GET /projects/{project_id}/collaborators"], + listColumns: ["GET /projects/{project_id}/columns"], + listForOrg: ["GET /orgs/{org}/projects"], + listForRepo: ["GET /repos/{owner}/{repo}/projects"], + listForUser: ["GET /users/{username}/projects"], + moveCard: ["POST /projects/columns/cards/{card_id}/moves"], + moveColumn: ["POST /projects/columns/{column_id}/moves"], + removeCollaborator: [ + "DELETE /projects/{project_id}/collaborators/{username}" + ], + update: ["PATCH /projects/{project_id}"], + updateCard: ["PATCH /projects/columns/cards/{card_id}"], + updateColumn: ["PATCH /projects/columns/{column_id}"] + }, + pulls: { + checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + create: ["POST /repos/{owner}/{repo}/pulls"], + createReplyForReviewComment: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies" + ], + createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + createReviewComment: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/comments" + ], + deletePendingReview: [ + "DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}" + ], + deleteReviewComment: [ + "DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}" + ], + dismissReview: [ + "PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals" + ], + get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"], + getReview: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}" + ], + getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + list: ["GET /repos/{owner}/{repo}/pulls"], + listCommentsForReview: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments" + ], + listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"], + listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"], + listRequestedReviewers: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers" + ], + listReviewComments: [ + "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments" + ], + listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"], + listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + removeRequestedReviewers: [ + "DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers" + ], + requestReviewers: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers" + ], + submitReview: [ + "POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events" + ], + update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"], + updateBranch: [ + "PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch" + ], + updateReview: [ + "PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}" + ], + updateReviewComment: [ + "PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}" + ] + }, + rateLimit: { get: ["GET /rate_limit"] }, + reactions: { + createForCommitComment: [ + "POST /repos/{owner}/{repo}/comments/{comment_id}/reactions" + ], + createForIssue: [ + "POST /repos/{owner}/{repo}/issues/{issue_number}/reactions" + ], + createForIssueComment: [ + "POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions" + ], + createForPullRequestReviewComment: [ + "POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions" + ], + createForRelease: [ + "POST /repos/{owner}/{repo}/releases/{release_id}/reactions" + ], + createForTeamDiscussionCommentInOrg: [ + "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions" + ], + createForTeamDiscussionInOrg: [ + "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions" + ], + deleteForCommitComment: [ + "DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}" + ], + deleteForIssue: [ + "DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}" + ], + deleteForIssueComment: [ + "DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}" + ], + deleteForPullRequestComment: [ + "DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}" + ], + deleteForRelease: [ + "DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}" + ], + deleteForTeamDiscussion: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}" + ], + deleteForTeamDiscussionComment: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}" + ], + listForCommitComment: [ + "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions" + ], + listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"], + listForIssueComment: [ + "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions" + ], + listForPullRequestReviewComment: [ + "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions" + ], + listForRelease: [ + "GET /repos/{owner}/{repo}/releases/{release_id}/reactions" + ], + listForTeamDiscussionCommentInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions" + ], + listForTeamDiscussionInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions" + ] + }, + repos: { + acceptInvitation: [ + "PATCH /user/repository_invitations/{invitation_id}", + {}, + { renamed: ["repos", "acceptInvitationForAuthenticatedUser"] } + ], + acceptInvitationForAuthenticatedUser: [ + "PATCH /user/repository_invitations/{invitation_id}" + ], + addAppAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], + addStatusCheckContexts: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + addTeamAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + addUserAccessRestrictions: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + cancelPagesDeployment: [ + "POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel" + ], + checkAutomatedSecurityFixes: [ + "GET /repos/{owner}/{repo}/automated-security-fixes" + ], + checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], + checkVulnerabilityAlerts: [ + "GET /repos/{owner}/{repo}/vulnerability-alerts" + ], + codeownersErrors: ["GET /repos/{owner}/{repo}/codeowners/errors"], + compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], + compareCommitsWithBasehead: [ + "GET /repos/{owner}/{repo}/compare/{basehead}" + ], + createAutolink: ["POST /repos/{owner}/{repo}/autolinks"], + createCommitComment: [ + "POST /repos/{owner}/{repo}/commits/{commit_sha}/comments" + ], + createCommitSignatureProtection: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures" + ], + createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], + createDeployKey: ["POST /repos/{owner}/{repo}/keys"], + createDeployment: ["POST /repos/{owner}/{repo}/deployments"], + createDeploymentBranchPolicy: [ + "POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies" + ], + createDeploymentProtectionRule: [ + "POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules" + ], + 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"], + createOrUpdateCustomPropertiesValues: [ + "PATCH /repos/{owner}/{repo}/properties/values" + ], + createOrUpdateEnvironment: [ + "PUT /repos/{owner}/{repo}/environments/{environment_name}" + ], + createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"], + createOrgRuleset: ["POST /orgs/{org}/rulesets"], + createPagesDeployment: ["POST /repos/{owner}/{repo}/pages/deployments"], + createPagesSite: ["POST /repos/{owner}/{repo}/pages"], + createRelease: ["POST /repos/{owner}/{repo}/releases"], + createRepoRuleset: ["POST /repos/{owner}/{repo}/rulesets"], + createTagProtection: ["POST /repos/{owner}/{repo}/tags/protection"], + createUsingTemplate: [ + "POST /repos/{template_owner}/{template_repo}/generate" + ], + createWebhook: ["POST /repos/{owner}/{repo}/hooks"], + declineInvitation: [ + "DELETE /user/repository_invitations/{invitation_id}", + {}, + { renamed: ["repos", "declineInvitationForAuthenticatedUser"] } + ], + declineInvitationForAuthenticatedUser: [ + "DELETE /user/repository_invitations/{invitation_id}" + ], + delete: ["DELETE /repos/{owner}/{repo}"], + deleteAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions" + ], + deleteAdminBranchProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins" + ], + deleteAnEnvironment: [ + "DELETE /repos/{owner}/{repo}/environments/{environment_name}" + ], + deleteAutolink: ["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"], + deleteBranchProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection" + ], + deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"], + deleteCommitSignatureProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures" + ], + deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"], + deleteDeployment: [ + "DELETE /repos/{owner}/{repo}/deployments/{deployment_id}" + ], + deleteDeploymentBranchPolicy: [ + "DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}" + ], + deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"], + deleteInvitation: [ + "DELETE /repos/{owner}/{repo}/invitations/{invitation_id}" + ], + deleteOrgRuleset: ["DELETE /orgs/{org}/rulesets/{ruleset_id}"], + deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages"], + deletePullRequestReviewProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews" + ], + deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], + deleteReleaseAsset: [ + "DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}" + ], + deleteRepoRuleset: ["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + deleteTagProtection: [ + "DELETE /repos/{owner}/{repo}/tags/protection/{tag_protection_id}" + ], + deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], + disableAutomatedSecurityFixes: [ + "DELETE /repos/{owner}/{repo}/automated-security-fixes" + ], + disableDeploymentProtectionRule: [ + "DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}" + ], + disablePrivateVulnerabilityReporting: [ + "DELETE /repos/{owner}/{repo}/private-vulnerability-reporting" + ], + disableVulnerabilityAlerts: [ + "DELETE /repos/{owner}/{repo}/vulnerability-alerts" + ], + downloadArchive: [ + "GET /repos/{owner}/{repo}/zipball/{ref}", + {}, + { renamed: ["repos", "downloadZipballArchive"] } + ], + downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"], + downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"], + enableAutomatedSecurityFixes: [ + "PUT /repos/{owner}/{repo}/automated-security-fixes" + ], + enablePrivateVulnerabilityReporting: [ + "PUT /repos/{owner}/{repo}/private-vulnerability-reporting" + ], + enableVulnerabilityAlerts: [ + "PUT /repos/{owner}/{repo}/vulnerability-alerts" + ], + generateReleaseNotes: [ + "POST /repos/{owner}/{repo}/releases/generate-notes" + ], + get: ["GET /repos/{owner}/{repo}"], + getAccessRestrictions: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions" + ], + getAdminBranchProtection: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins" + ], + getAllDeploymentProtectionRules: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules" + ], + getAllEnvironments: ["GET /repos/{owner}/{repo}/environments"], + getAllStatusCheckContexts: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts" + ], + getAllTopics: ["GET /repos/{owner}/{repo}/topics"], + getAppsWithAccessToProtectedBranch: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps" + ], + getAutolink: ["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"], + getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"], + getBranchProtection: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection" + ], + getBranchRules: ["GET /repos/{owner}/{repo}/rules/branches/{branch}"], + getClones: ["GET /repos/{owner}/{repo}/traffic/clones"], + getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"], + getCollaboratorPermissionLevel: [ + "GET /repos/{owner}/{repo}/collaborators/{username}/permission" + ], + getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"], + getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"], + getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"], + getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"], + getCommitSignatureProtection: [ + "GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures" + ], + getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"], + getContent: ["GET /repos/{owner}/{repo}/contents/{path}"], + getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"], + getCustomDeploymentProtectionRule: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}" + ], + getCustomPropertiesValues: ["GET /repos/{owner}/{repo}/properties/values"], + getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"], + getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"], + getDeploymentBranchPolicy: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}" + ], + getDeploymentStatus: [ + "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}" + ], + getEnvironment: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}" + ], + getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"], + getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"], + getOrgRuleSuite: ["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"], + getOrgRuleSuites: ["GET /orgs/{org}/rulesets/rule-suites"], + getOrgRuleset: ["GET /orgs/{org}/rulesets/{ruleset_id}"], + getOrgRulesets: ["GET /orgs/{org}/rulesets"], + getPages: ["GET /repos/{owner}/{repo}/pages"], + getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"], + getPagesDeployment: [ + "GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_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}"], + getRepoRuleSuite: [ + "GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}" + ], + getRepoRuleSuites: ["GET /repos/{owner}/{repo}/rulesets/rule-suites"], + getRepoRuleset: ["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + getRepoRulesets: ["GET /repos/{owner}/{repo}/rulesets"], + 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}" + ], + listActivities: ["GET /repos/{owner}/{repo}/activity"], + listAutolinks: ["GET /repos/{owner}/{repo}/autolinks"], + listBranches: ["GET /repos/{owner}/{repo}/branches"], + listBranchesForHeadCommit: [ + "GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head" + ], + listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"], + listCommentsForCommit: [ + "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments" + ], + listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"], + listCommitStatusesForRef: [ + "GET /repos/{owner}/{repo}/commits/{ref}/statuses" + ], + listCommits: ["GET /repos/{owner}/{repo}/commits"], + listContributors: ["GET /repos/{owner}/{repo}/contributors"], + listCustomDeploymentRuleIntegrations: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps" + ], + listDeployKeys: ["GET /repos/{owner}/{repo}/keys"], + listDeploymentBranchPolicies: [ + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies" + ], + listDeploymentStatuses: [ + "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses" + ], + listDeployments: ["GET /repos/{owner}/{repo}/deployments"], + listForAuthenticatedUser: ["GET /user/repos"], + listForOrg: ["GET /orgs/{org}/repos"], + listForUser: ["GET /users/{username}/repos"], + listForks: ["GET /repos/{owner}/{repo}/forks"], + listInvitations: ["GET /repos/{owner}/{repo}/invitations"], + listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"], + listLanguages: ["GET /repos/{owner}/{repo}/languages"], + listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"], + listPublic: ["GET /repositories"], + listPullRequestsAssociatedWithCommit: [ + "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls" + ], + listReleaseAssets: [ + "GET /repos/{owner}/{repo}/releases/{release_id}/assets" + ], + listReleases: ["GET /repos/{owner}/{repo}/releases"], + listTagProtection: ["GET /repos/{owner}/{repo}/tags/protection"], + listTags: ["GET /repos/{owner}/{repo}/tags"], + listTeams: ["GET /repos/{owner}/{repo}/teams"], + listWebhookDeliveries: [ + "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries" + ], + listWebhooks: ["GET /repos/{owner}/{repo}/hooks"], + merge: ["POST /repos/{owner}/{repo}/merges"], + mergeUpstream: ["POST /repos/{owner}/{repo}/merge-upstream"], + pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"], + redeliverWebhookDelivery: [ + "POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts" + ], + removeAppAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + removeCollaborator: [ + "DELETE /repos/{owner}/{repo}/collaborators/{username}" + ], + removeStatusCheckContexts: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + removeStatusCheckProtection: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks" + ], + removeTeamAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + removeUserAccessRestrictions: [ + "DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + renameBranch: ["POST /repos/{owner}/{repo}/branches/{branch}/rename"], + replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics"], + requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"], + setAdminBranchProtection: [ + "POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins" + ], + setAppAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", + {}, + { mapToData: "apps" } + ], + setStatusCheckContexts: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", + {}, + { mapToData: "contexts" } + ], + setTeamAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", + {}, + { mapToData: "teams" } + ], + setUserAccessRestrictions: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", + {}, + { mapToData: "users" } + ], + testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"], + transfer: ["POST /repos/{owner}/{repo}/transfer"], + update: ["PATCH /repos/{owner}/{repo}"], + updateBranchProtection: [ + "PUT /repos/{owner}/{repo}/branches/{branch}/protection" + ], + updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"], + updateDeploymentBranchPolicy: [ + "PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}" + ], + updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"], + updateInvitation: [ + "PATCH /repos/{owner}/{repo}/invitations/{invitation_id}" + ], + updateOrgRuleset: ["PUT /orgs/{org}/rulesets/{ruleset_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}" + ], + updateRepoRuleset: ["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"], + updateStatusCheckPotection: [ + "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", + {}, + { renamed: ["repos", "updateStatusCheckProtection"] } + ], + updateStatusCheckProtection: [ + "PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks" + ], + updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"], + updateWebhookConfigForRepo: [ + "PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config" + ], + uploadReleaseAsset: [ + "POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", + { baseUrl: "https://uploads.github.com" } + ] + }, + search: { + code: ["GET /search/code"], + commits: ["GET /search/commits"], + issuesAndPullRequests: ["GET /search/issues"], + labels: ["GET /search/labels"], + repos: ["GET /search/repositories"], + topics: ["GET /search/topics"], + users: ["GET /search/users"] + }, + secretScanning: { + getAlert: [ + "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}" + ], + listAlertsForEnterprise: [ + "GET /enterprises/{enterprise}/secret-scanning/alerts" + ], + listAlertsForOrg: ["GET /orgs/{org}/secret-scanning/alerts"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"], + listLocationsForAlert: [ + "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations" + ], + updateAlert: [ + "PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}" + ] + }, + securityAdvisories: { + createFork: [ + "POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks" + ], + createPrivateVulnerabilityReport: [ + "POST /repos/{owner}/{repo}/security-advisories/reports" + ], + createRepositoryAdvisory: [ + "POST /repos/{owner}/{repo}/security-advisories" + ], + createRepositoryAdvisoryCveRequest: [ + "POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve" + ], + getGlobalAdvisory: ["GET /advisories/{ghsa_id}"], + getRepositoryAdvisory: [ + "GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}" + ], + listGlobalAdvisories: ["GET /advisories"], + listOrgRepositoryAdvisories: ["GET /orgs/{org}/security-advisories"], + listRepositoryAdvisories: ["GET /repos/{owner}/{repo}/security-advisories"], + updateRepositoryAdvisory: [ + "PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}" + ] + }, + teams: { + addOrUpdateMembershipForUserInOrg: [ + "PUT /orgs/{org}/teams/{team_slug}/memberships/{username}" + ], + addOrUpdateProjectPermissionsInOrg: [ + "PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}" + ], + addOrUpdateRepoPermissionsInOrg: [ + "PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}" + ], + checkPermissionsForProjectInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/projects/{project_id}" + ], + checkPermissionsForRepoInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}" + ], + create: ["POST /orgs/{org}/teams"], + createDiscussionCommentInOrg: [ + "POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments" + ], + createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], + deleteDiscussionCommentInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}" + ], + deleteDiscussionInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}" + ], + deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], + getByName: ["GET /orgs/{org}/teams/{team_slug}"], + getDiscussionCommentInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}" + ], + getDiscussionInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}" + ], + getMembershipForUserInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/memberships/{username}" + ], + list: ["GET /orgs/{org}/teams"], + listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], + listDiscussionCommentsInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments" + ], + listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], + listForAuthenticatedUser: ["GET /user/teams"], + listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], + listPendingInvitationsInOrg: [ + "GET /orgs/{org}/teams/{team_slug}/invitations" + ], + listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects"], + listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], + removeMembershipForUserInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}" + ], + removeProjectInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}" + ], + removeRepoInOrg: [ + "DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}" + ], + updateDiscussionCommentInOrg: [ + "PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}" + ], + updateDiscussionInOrg: [ + "PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}" + ], + updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"] + }, + users: { + addEmailForAuthenticated: [ + "POST /user/emails", + {}, + { renamed: ["users", "addEmailForAuthenticatedUser"] } + ], + addEmailForAuthenticatedUser: ["POST /user/emails"], + addSocialAccountForAuthenticatedUser: ["POST /user/social_accounts"], + block: ["PUT /user/blocks/{username}"], + checkBlocked: ["GET /user/blocks/{username}"], + checkFollowingForUser: ["GET /users/{username}/following/{target_user}"], + checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"], + createGpgKeyForAuthenticated: [ + "POST /user/gpg_keys", + {}, + { renamed: ["users", "createGpgKeyForAuthenticatedUser"] } + ], + createGpgKeyForAuthenticatedUser: ["POST /user/gpg_keys"], + createPublicSshKeyForAuthenticated: [ + "POST /user/keys", + {}, + { renamed: ["users", "createPublicSshKeyForAuthenticatedUser"] } + ], + createPublicSshKeyForAuthenticatedUser: ["POST /user/keys"], + createSshSigningKeyForAuthenticatedUser: ["POST /user/ssh_signing_keys"], + deleteEmailForAuthenticated: [ + "DELETE /user/emails", + {}, + { renamed: ["users", "deleteEmailForAuthenticatedUser"] } + ], + deleteEmailForAuthenticatedUser: ["DELETE /user/emails"], + deleteGpgKeyForAuthenticated: [ + "DELETE /user/gpg_keys/{gpg_key_id}", + {}, + { renamed: ["users", "deleteGpgKeyForAuthenticatedUser"] } + ], + deleteGpgKeyForAuthenticatedUser: ["DELETE /user/gpg_keys/{gpg_key_id}"], + deletePublicSshKeyForAuthenticated: [ + "DELETE /user/keys/{key_id}", + {}, + { renamed: ["users", "deletePublicSshKeyForAuthenticatedUser"] } + ], + deletePublicSshKeyForAuthenticatedUser: ["DELETE /user/keys/{key_id}"], + deleteSocialAccountForAuthenticatedUser: ["DELETE /user/social_accounts"], + deleteSshSigningKeyForAuthenticatedUser: [ + "DELETE /user/ssh_signing_keys/{ssh_signing_key_id}" + ], + follow: ["PUT /user/following/{username}"], + getAuthenticated: ["GET /user"], + getByUsername: ["GET /users/{username}"], + getContextForUser: ["GET /users/{username}/hovercard"], + getGpgKeyForAuthenticated: [ + "GET /user/gpg_keys/{gpg_key_id}", + {}, + { renamed: ["users", "getGpgKeyForAuthenticatedUser"] } + ], + getGpgKeyForAuthenticatedUser: ["GET /user/gpg_keys/{gpg_key_id}"], + getPublicSshKeyForAuthenticated: [ + "GET /user/keys/{key_id}", + {}, + { renamed: ["users", "getPublicSshKeyForAuthenticatedUser"] } + ], + getPublicSshKeyForAuthenticatedUser: ["GET /user/keys/{key_id}"], + getSshSigningKeyForAuthenticatedUser: [ + "GET /user/ssh_signing_keys/{ssh_signing_key_id}" + ], + list: ["GET /users"], + listBlockedByAuthenticated: [ + "GET /user/blocks", + {}, + { renamed: ["users", "listBlockedByAuthenticatedUser"] } + ], + listBlockedByAuthenticatedUser: ["GET /user/blocks"], + listEmailsForAuthenticated: [ + "GET /user/emails", + {}, + { renamed: ["users", "listEmailsForAuthenticatedUser"] } + ], + listEmailsForAuthenticatedUser: ["GET /user/emails"], + listFollowedByAuthenticated: [ + "GET /user/following", + {}, + { renamed: ["users", "listFollowedByAuthenticatedUser"] } + ], + listFollowedByAuthenticatedUser: ["GET /user/following"], + listFollowersForAuthenticatedUser: ["GET /user/followers"], + listFollowersForUser: ["GET /users/{username}/followers"], + listFollowingForUser: ["GET /users/{username}/following"], + listGpgKeysForAuthenticated: [ + "GET /user/gpg_keys", + {}, + { renamed: ["users", "listGpgKeysForAuthenticatedUser"] } + ], + listGpgKeysForAuthenticatedUser: ["GET /user/gpg_keys"], + listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], + listPublicEmailsForAuthenticated: [ + "GET /user/public_emails", + {}, + { renamed: ["users", "listPublicEmailsForAuthenticatedUser"] } + ], + listPublicEmailsForAuthenticatedUser: ["GET /user/public_emails"], + listPublicKeysForUser: ["GET /users/{username}/keys"], + listPublicSshKeysForAuthenticated: [ + "GET /user/keys", + {}, + { renamed: ["users", "listPublicSshKeysForAuthenticatedUser"] } + ], + listPublicSshKeysForAuthenticatedUser: ["GET /user/keys"], + listSocialAccountsForAuthenticatedUser: ["GET /user/social_accounts"], + listSocialAccountsForUser: ["GET /users/{username}/social_accounts"], + listSshSigningKeysForAuthenticatedUser: ["GET /user/ssh_signing_keys"], + listSshSigningKeysForUser: ["GET /users/{username}/ssh_signing_keys"], + setPrimaryEmailVisibilityForAuthenticated: [ + "PATCH /user/email/visibility", + {}, + { renamed: ["users", "setPrimaryEmailVisibilityForAuthenticatedUser"] } + ], + setPrimaryEmailVisibilityForAuthenticatedUser: [ + "PATCH /user/email/visibility" + ], + unblock: ["DELETE /user/blocks/{username}"], + unfollow: ["DELETE /user/following/{username}"], + updateAuthenticated: ["PATCH /user"] + } + }; + var endpoints_default = Endpoints; + var endpointMethodsMap = /* @__PURE__ */ new Map(); + for (const [scope, endpoints] of Object.entries(endpoints_default)) { + for (const [methodName, endpoint] of Object.entries(endpoints)) { + const [route, defaults3, decorations] = endpoint; + const [method, url] = route.split(/ /); + const endpointDefaults = Object.assign( + { + method, + url + }, + defaults3 + ); + if (!endpointMethodsMap.has(scope)) { + endpointMethodsMap.set(scope, /* @__PURE__ */ new Map()); + } + endpointMethodsMap.get(scope).set(methodName, { + scope, + methodName, + endpointDefaults, + decorations + }); + } + } + var handler = { + has({ scope }, methodName) { + return endpointMethodsMap.get(scope).has(methodName); + }, + getOwnPropertyDescriptor(target, methodName) { + return { + value: this.get(target, methodName), + // ensures method is in the cache + configurable: true, + writable: true, + enumerable: true + }; + }, + defineProperty(target, methodName, descriptor) { + Object.defineProperty(target.cache, methodName, descriptor); + return true; + }, + deleteProperty(target, methodName) { + delete target.cache[methodName]; + return true; + }, + ownKeys({ scope }) { + return [...endpointMethodsMap.get(scope).keys()]; + }, + set(target, methodName, value) { + return target.cache[methodName] = value; + }, + get({ octokit, scope, cache }, methodName) { + if (cache[methodName]) { + return cache[methodName]; + } + const method = endpointMethodsMap.get(scope).get(methodName); + if (!method) { + return void 0; + } + const { endpointDefaults, decorations } = method; + if (decorations) { + cache[methodName] = decorate( + octokit, + scope, + methodName, + endpointDefaults, + decorations + ); + } else { + cache[methodName] = octokit.request.defaults(endpointDefaults); + } + return cache[methodName]; + } + }; + function endpointsToMethods(octokit) { + const newMethods = {}; + for (const scope of endpointMethodsMap.keys()) { + newMethods[scope] = new Proxy({ octokit, scope, cache: {} }, handler); + } + return newMethods; + } + function decorate(octokit, scope, methodName, defaults3, decorations) { + const requestWithDefaults = octokit.request.defaults(defaults3); + function withDecorations(...args) { + let options = requestWithDefaults.endpoint.merge(...args); + if (decorations.mapToData) { + options = Object.assign({}, options, { + data: options[decorations.mapToData], + [decorations.mapToData]: void 0 + }); + 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) { + const options2 = requestWithDefaults.endpoint.merge(...args); + for (const [name, alias] of Object.entries( + decorations.renamedParameters + )) { + if (name in options2) { + octokit.log.warn( + `"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead` + ); + if (!(alias in options2)) { + options2[alias] = options2[name]; + } + delete options2[name]; + } + } + return requestWithDefaults(options2); + } + return requestWithDefaults(...args); + } + return Object.assign(withDecorations, requestWithDefaults); + } + function restEndpointMethods(octokit) { + const api = endpointsToMethods(octokit); + return { + rest: api + }; + } + restEndpointMethods.VERSION = VERSION3; + function legacyRestEndpointMethods(octokit) { + const api = endpointsToMethods(octokit); + return { + ...api, + rest: api + }; + } + legacyRestEndpointMethods.VERSION = VERSION3; + } +}); + +// node_modules/@octokit/plugin-paginate-rest/dist-node/index.js +var require_dist_node10 = __commonJS({ + "node_modules/@octokit/plugin-paginate-rest/dist-node/index.js"(exports2, module2) { + "use strict"; + var __defProp2 = Object.defineProperty; + var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; + var __getOwnPropNames2 = Object.getOwnPropertyNames; + var __hasOwnProp2 = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp2(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod); + var dist_src_exports = {}; + __export(dist_src_exports, { + composePaginateRest: () => composePaginateRest, + isPaginatingEndpoint: () => isPaginatingEndpoint, + paginateRest: () => paginateRest, + paginatingEndpoints: () => paginatingEndpoints + }); + module2.exports = __toCommonJS(dist_src_exports); + var VERSION3 = "9.2.2"; + function normalizePaginatedListResponse(response) { + if (!response.data) { + return { + ...response, + data: [] + }; + } + const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data); + if (!responseNeedsNormalization) + return response; + 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); + 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 = void 0; + } + return gather( + octokit, + [], + iterator(octokit, route, parameters)[Symbol.asyncIterator](), + mapFn + ); + } + function gather(octokit, results, iterator2, mapFn) { + return iterator2.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, iterator2, mapFn); + }); + } + var composePaginateRest = Object.assign(paginate, { + iterator + }); + var paginatingEndpoints = [ + "GET /advisories", + "GET /app/hook/deliveries", + "GET /app/installation-requests", + "GET /app/installations", + "GET /assignments/{assignment_id}/accepted_assignments", + "GET /classrooms", + "GET /classrooms/{classroom_id}/assignments", + "GET /enterprises/{enterprise}/dependabot/alerts", + "GET /enterprises/{enterprise}/secret-scanning/alerts", + "GET /events", + "GET /gists", + "GET /gists/public", + "GET /gists/starred", + "GET /gists/{gist_id}/comments", + "GET /gists/{gist_id}/commits", + "GET /gists/{gist_id}/forks", + "GET /installation/repositories", + "GET /issues", + "GET /licenses", + "GET /marketplace_listing/plans", + "GET /marketplace_listing/plans/{plan_id}/accounts", + "GET /marketplace_listing/stubbed/plans", + "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", + "GET /networks/{owner}/{repo}/events", + "GET /notifications", + "GET /organizations", + "GET /orgs/{org}/actions/cache/usage-by-repository", + "GET /orgs/{org}/actions/permissions/repositories", + "GET /orgs/{org}/actions/runners", + "GET /orgs/{org}/actions/secrets", + "GET /orgs/{org}/actions/secrets/{secret_name}/repositories", + "GET /orgs/{org}/actions/variables", + "GET /orgs/{org}/actions/variables/{name}/repositories", + "GET /orgs/{org}/blocks", + "GET /orgs/{org}/code-scanning/alerts", + "GET /orgs/{org}/codespaces", + "GET /orgs/{org}/codespaces/secrets", + "GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories", + "GET /orgs/{org}/copilot/billing/seats", + "GET /orgs/{org}/dependabot/alerts", + "GET /orgs/{org}/dependabot/secrets", + "GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories", + "GET /orgs/{org}/events", + "GET /orgs/{org}/failed_invitations", + "GET /orgs/{org}/hooks", + "GET /orgs/{org}/hooks/{hook_id}/deliveries", + "GET /orgs/{org}/installations", + "GET /orgs/{org}/invitations", + "GET /orgs/{org}/invitations/{invitation_id}/teams", + "GET /orgs/{org}/issues", + "GET /orgs/{org}/members", + "GET /orgs/{org}/members/{username}/codespaces", + "GET /orgs/{org}/migrations", + "GET /orgs/{org}/migrations/{migration_id}/repositories", + "GET /orgs/{org}/organization-roles/{role_id}/teams", + "GET /orgs/{org}/organization-roles/{role_id}/users", + "GET /orgs/{org}/outside_collaborators", + "GET /orgs/{org}/packages", + "GET /orgs/{org}/packages/{package_type}/{package_name}/versions", + "GET /orgs/{org}/personal-access-token-requests", + "GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories", + "GET /orgs/{org}/personal-access-tokens", + "GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories", + "GET /orgs/{org}/projects", + "GET /orgs/{org}/properties/values", + "GET /orgs/{org}/public_members", + "GET /orgs/{org}/repos", + "GET /orgs/{org}/rulesets", + "GET /orgs/{org}/rulesets/rule-suites", + "GET /orgs/{org}/secret-scanning/alerts", + "GET /orgs/{org}/security-advisories", + "GET /orgs/{org}/teams", + "GET /orgs/{org}/teams/{team_slug}/discussions", + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", + "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", + "GET /orgs/{org}/teams/{team_slug}/invitations", + "GET /orgs/{org}/teams/{team_slug}/members", + "GET /orgs/{org}/teams/{team_slug}/projects", + "GET /orgs/{org}/teams/{team_slug}/repos", + "GET /orgs/{org}/teams/{team_slug}/teams", + "GET /projects/columns/{column_id}/cards", + "GET /projects/{project_id}/collaborators", + "GET /projects/{project_id}/columns", + "GET /repos/{owner}/{repo}/actions/artifacts", + "GET /repos/{owner}/{repo}/actions/caches", + "GET /repos/{owner}/{repo}/actions/organization-secrets", + "GET /repos/{owner}/{repo}/actions/organization-variables", + "GET /repos/{owner}/{repo}/actions/runners", + "GET /repos/{owner}/{repo}/actions/runs", + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts", + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs", + "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs", + "GET /repos/{owner}/{repo}/actions/secrets", + "GET /repos/{owner}/{repo}/actions/variables", + "GET /repos/{owner}/{repo}/actions/workflows", + "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs", + "GET /repos/{owner}/{repo}/activity", + "GET /repos/{owner}/{repo}/assignees", + "GET /repos/{owner}/{repo}/branches", + "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", + "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", + "GET /repos/{owner}/{repo}/code-scanning/alerts", + "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", + "GET /repos/{owner}/{repo}/code-scanning/analyses", + "GET /repos/{owner}/{repo}/codespaces", + "GET /repos/{owner}/{repo}/codespaces/devcontainers", + "GET /repos/{owner}/{repo}/codespaces/secrets", + "GET /repos/{owner}/{repo}/collaborators", + "GET /repos/{owner}/{repo}/comments", + "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", + "GET /repos/{owner}/{repo}/commits", + "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments", + "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", + "GET /repos/{owner}/{repo}/commits/{ref}/check-runs", + "GET /repos/{owner}/{repo}/commits/{ref}/check-suites", + "GET /repos/{owner}/{repo}/commits/{ref}/status", + "GET /repos/{owner}/{repo}/commits/{ref}/statuses", + "GET /repos/{owner}/{repo}/contributors", + "GET /repos/{owner}/{repo}/dependabot/alerts", + "GET /repos/{owner}/{repo}/dependabot/secrets", + "GET /repos/{owner}/{repo}/deployments", + "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses", + "GET /repos/{owner}/{repo}/environments", + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies", + "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps", + "GET /repos/{owner}/{repo}/events", + "GET /repos/{owner}/{repo}/forks", + "GET /repos/{owner}/{repo}/hooks", + "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries", + "GET /repos/{owner}/{repo}/invitations", + "GET /repos/{owner}/{repo}/issues", + "GET /repos/{owner}/{repo}/issues/comments", + "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", + "GET /repos/{owner}/{repo}/issues/events", + "GET /repos/{owner}/{repo}/issues/{issue_number}/comments", + "GET /repos/{owner}/{repo}/issues/{issue_number}/events", + "GET /repos/{owner}/{repo}/issues/{issue_number}/labels", + "GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", + "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", + "GET /repos/{owner}/{repo}/keys", + "GET /repos/{owner}/{repo}/labels", + "GET /repos/{owner}/{repo}/milestones", + "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels", + "GET /repos/{owner}/{repo}/notifications", + "GET /repos/{owner}/{repo}/pages/builds", + "GET /repos/{owner}/{repo}/projects", + "GET /repos/{owner}/{repo}/pulls", + "GET /repos/{owner}/{repo}/pulls/comments", + "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/files", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews", + "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", + "GET /repos/{owner}/{repo}/releases", + "GET /repos/{owner}/{repo}/releases/{release_id}/assets", + "GET /repos/{owner}/{repo}/releases/{release_id}/reactions", + "GET /repos/{owner}/{repo}/rules/branches/{branch}", + "GET /repos/{owner}/{repo}/rulesets", + "GET /repos/{owner}/{repo}/rulesets/rule-suites", + "GET /repos/{owner}/{repo}/secret-scanning/alerts", + "GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations", + "GET /repos/{owner}/{repo}/security-advisories", + "GET /repos/{owner}/{repo}/stargazers", + "GET /repos/{owner}/{repo}/subscribers", + "GET /repos/{owner}/{repo}/tags", + "GET /repos/{owner}/{repo}/teams", + "GET /repos/{owner}/{repo}/topics", + "GET /repositories", + "GET /repositories/{repository_id}/environments/{environment_name}/secrets", + "GET /repositories/{repository_id}/environments/{environment_name}/variables", + "GET /search/code", + "GET /search/commits", + "GET /search/issues", + "GET /search/labels", + "GET /search/repositories", + "GET /search/topics", + "GET /search/users", + "GET /teams/{team_id}/discussions", + "GET /teams/{team_id}/discussions/{discussion_number}/comments", + "GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions", + "GET /teams/{team_id}/discussions/{discussion_number}/reactions", + "GET /teams/{team_id}/invitations", + "GET /teams/{team_id}/members", + "GET /teams/{team_id}/projects", + "GET /teams/{team_id}/repos", + "GET /teams/{team_id}/teams", + "GET /user/blocks", + "GET /user/codespaces", + "GET /user/codespaces/secrets", + "GET /user/emails", + "GET /user/followers", + "GET /user/following", + "GET /user/gpg_keys", + "GET /user/installations", + "GET /user/installations/{installation_id}/repositories", + "GET /user/issues", + "GET /user/keys", + "GET /user/marketplace_purchases", + "GET /user/marketplace_purchases/stubbed", + "GET /user/memberships/orgs", + "GET /user/migrations", + "GET /user/migrations/{migration_id}/repositories", + "GET /user/orgs", + "GET /user/packages", + "GET /user/packages/{package_type}/{package_name}/versions", + "GET /user/public_emails", + "GET /user/repos", + "GET /user/repository_invitations", + "GET /user/social_accounts", + "GET /user/ssh_signing_keys", + "GET /user/starred", + "GET /user/subscriptions", + "GET /user/teams", + "GET /users", + "GET /users/{username}/events", + "GET /users/{username}/events/orgs/{org}", + "GET /users/{username}/events/public", + "GET /users/{username}/followers", + "GET /users/{username}/following", + "GET /users/{username}/gists", + "GET /users/{username}/gpg_keys", + "GET /users/{username}/keys", + "GET /users/{username}/orgs", + "GET /users/{username}/packages", + "GET /users/{username}/projects", + "GET /users/{username}/received_events", + "GET /users/{username}/received_events/public", + "GET /users/{username}/repos", + "GET /users/{username}/social_accounts", + "GET /users/{username}/ssh_signing_keys", + "GET /users/{username}/starred", + "GET /users/{username}/subscriptions" + ]; + function isPaginatingEndpoint(arg) { + if (typeof arg === "string") { + return paginatingEndpoints.includes(arg); + } else { + return false; + } + } + function paginateRest(octokit) { + return { + paginate: Object.assign(paginate.bind(null, octokit), { + iterator: iterator.bind(null, octokit) + }) + }; + } + paginateRest.VERSION = VERSION3; + } +}); + +// node_modules/@actions/github/lib/utils.js +var require_utils4 = __commonJS({ + "node_modules/@actions/github/lib/utils.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getOctokitOptions = exports2.GitHub = exports2.defaults = exports2.context = void 0; + var Context = __importStar(require_context()); + var Utils = __importStar(require_utils3()); + var core_1 = require_dist_node8(); + var plugin_rest_endpoint_methods_1 = require_dist_node9(); + var plugin_paginate_rest_1 = require_dist_node10(); + exports2.context = new Context.Context(); + var baseUrl = Utils.getApiBaseUrl(); + exports2.defaults = { + baseUrl, + request: { + agent: Utils.getProxyAgent(baseUrl), + fetch: Utils.getProxyFetch(baseUrl) + } + }; + exports2.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(exports2.defaults); + function getOctokitOptions(token, options) { + const opts = Object.assign({}, options || {}); + const auth = Utils.getAuthString(token, opts); + if (auth) { + opts.auth = auth; + } + return opts; + } + exports2.getOctokitOptions = getOctokitOptions; + } +}); + +// node_modules/@actions/github/lib/github.js +var require_github = __commonJS({ + "node_modules/@actions/github/lib/github.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true }); + exports2.getOctokit = exports2.context = void 0; + var Context = __importStar(require_context()); + var utils_1 = require_utils4(); + exports2.context = new Context.Context(); + function getOctokit(token, options, ...additionalPlugins) { + const GitHubWithPlugins = utils_1.GitHub.plugin(...additionalPlugins); + return new GitHubWithPlugins((0, utils_1.getOctokitOptions)(token, options)); + } + exports2.getOctokit = getOctokit; + } +}); + +// node_modules/libsodium/dist/modules/libsodium.js +var require_libsodium = __commonJS({ + "node_modules/libsodium/dist/modules/libsodium.js"(exports2, module2) { + !function(A) { + function I(A2) { + "use strict"; + var I2; + void 0 === (I2 = A2) && (I2 = {}); + var g = I2; + "object" != typeof g.sodium && ("object" == typeof global ? g = global : "object" == typeof window && (g = window)); + var C = I2; + return I2.ready = new Promise(function(A3, I3) { + (B = C).onAbort = I3, B.print = function(A4) { + }, B.printErr = function(A4) { + }, B.onRuntimeInitialized = function() { + try { + B._crypto_secretbox_keybytes(), A3(); + } catch (A4) { + I3(A4); + } + }, B.useBackupModule = function() { + return new Promise(function(A4, I4) { + (B2 = {}).onAbort = I4, B2.onRuntimeInitialized = function() { + Object.keys(C).forEach(function(A5) { + "getRandomValue" !== A5 && delete C[A5]; + }), Object.keys(B2).forEach(function(A5) { + C[A5] = B2[A5]; + }), A4(); + }; + var g3, B2 = void 0 !== B2 ? B2 : {}, Q2 = "object" == typeof window, E2 = "function" == typeof importScripts, i2 = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, o2 = Object.assign({}, B2), c2 = ""; + if (i2) { + var D2 = require("fs"), a2 = require("path"); + c2 = __dirname + "/", g3 = (A5) => (A5 = U2(A5) ? new URL(A5) : a2.normalize(A5), D2.readFileSync(A5)), !B2.thisProgram && process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2), "undefined" != typeof module2 && (module2.exports = B2); + } else (Q2 || E2) && (E2 ? c2 = self.location.href : "undefined" != typeof document && document.currentScript && (c2 = document.currentScript.src), c2 = c2.startsWith("blob:") ? "" : c2.substr(0, c2.replace(/[?#].*/, "").lastIndexOf("/") + 1), E2 && (g3 = (A5) => { + var I5 = new XMLHttpRequest(); + return I5.open("GET", A5, false), I5.responseType = "arraybuffer", I5.send(null), new Uint8Array(I5.response); + })); + B2.print; + var y2, f2 = B2.printErr || void 0; + Object.assign(B2, o2), o2 = null, B2.arguments && B2.arguments, B2.thisProgram && B2.thisProgram, B2.quit && B2.quit, B2.wasmBinary && (y2 = B2.wasmBinary); + var e2, w2 = { Memory: function(A5) { + this.buffer = new ArrayBuffer(65536 * A5.initial); + }, Module: function(A5) { + }, Instance: function(A5, I5) { + this.exports = function(A6) { + for (var I6, g4 = new Uint8Array(123), C2 = 25; C2 >= 0; --C2) g4[48 + C2] = 52 + C2, g4[65 + C2] = C2, g4[97 + C2] = 26 + C2; + function B3(A7, I7, C3) { + for (var B4, Q4, E3 = 0, i3 = I7, o3 = C3.length, c3 = I7 + (3 * o3 >> 2) - ("=" == C3[o3 - 2]) - ("=" == C3[o3 - 1]); E3 < o3; E3 += 4) B4 = g4[C3.charCodeAt(E3 + 1)], Q4 = g4[C3.charCodeAt(E3 + 2)], A7[i3++] = g4[C3.charCodeAt(E3)] << 2 | B4 >> 4, i3 < c3 && (A7[i3++] = B4 << 4 | Q4 >> 2), i3 < c3 && (A7[i3++] = Q4 << 6 | g4[C3.charCodeAt(E3 + 3)]); + } + function Q3() { + throw new Error("abort"); + } + return g4[43] = 62, g4[47] = 63, function(A7) { + var g5 = new ArrayBuffer(16777216), C3 = new Int8Array(g5), E3 = (new Int16Array(g5), new Int32Array(g5)), i3 = new Uint8Array(g5), o3 = (new Uint16Array(g5), new Uint32Array(g5)), c3 = (new Float32Array(g5), new Float64Array(g5), Math.imul), D3 = (Math.fround, Math.abs, Math.clz32), a3 = (Math.min, Math.max, Math.floor, Math.ceil, Math.trunc, Math.sqrt, A7.a), y3 = a3.a, f3 = a3.b, e3 = a3.c, w3 = a3.d, r3 = 103200, t3 = 0; + function h3(A8, I7) { + var g6, B4, Q4, E4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, eA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, SA2 = 0, MA2 = 0, NA2 = 0, KA2 = 0, pA2 = 0, HA2 = 0, GA2 = 0; + fA2 = i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24, wA2 = c4 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, gA2 = i3[I7 + 104 | 0] | i3[I7 + 105 | 0] << 8 | i3[I7 + 106 | 0] << 16 | i3[I7 + 107 | 0] << 24, rA2 = c4 = i3[I7 + 108 | 0] | i3[I7 + 109 | 0] << 8 | i3[I7 + 110 | 0] << 16 | i3[I7 + 111 | 0] << 24, c4 = i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24, j2 = i3[I7 + 64 | 0] | i3[I7 + 65 | 0] << 8 | i3[I7 + 66 | 0] << 16 | i3[I7 + 67 | 0] << 24, BA2 = c4, KA2 = c4 = i3[I7 + 36 | 0] | i3[I7 + 37 | 0] << 8 | i3[I7 + 38 | 0] << 16 | i3[I7 + 39 | 0] << 24, K4 = c4, oA2 = i3[I7 + 120 | 0] | i3[I7 + 121 | 0] << 8 | i3[I7 + 122 | 0] << 16 | i3[I7 + 123 | 0] << 24, nA2 = c4 = i3[I7 + 124 | 0] | i3[I7 + 125 | 0] << 8 | i3[I7 + 126 | 0] << 16 | i3[I7 + 127 | 0] << 24, Q4 = c4 = i3[I7 + 92 | 0] | i3[I7 + 93 | 0] << 8 | i3[I7 + 94 | 0] << 16 | i3[I7 + 95 | 0] << 24, g6 = i3[I7 + 88 | 0] | i3[I7 + 89 | 0] << 8 | i3[I7 + 90 | 0] << 16 | i3[I7 + 91 | 0] << 24, z2 = c4, iA2 = i3[I7 + 80 | 0] | i3[I7 + 81 | 0] << 8 | i3[I7 + 82 | 0] << 16 | i3[I7 + 83 | 0] << 24, hA2 = c4 = i3[I7 + 84 | 0] | i3[I7 + 85 | 0] << 8 | i3[I7 + 86 | 0] << 16 | i3[I7 + 87 | 0] << 24, X2 = c4, QA2 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, c4 = (DA2 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24) + K4 | 0, q4 = (cA2 = i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24) + (aA2 = i3[I7 + 32 | 0] | i3[I7 + 33 | 0] << 8 | i3[I7 + 34 | 0] << 16 | i3[I7 + 35 | 0] << 24) | 0, c4 = (i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24) + (cA2 >>> 0 > q4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (QA2 = (D4 = q4) >>> 0 > (q4 = q4 + QA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, EA2 = eA2 = q4 + fA2 | 0, eA2 = c4 = eA2 >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, q4 = _A(q4 ^ (i3[A8 + 80 | 0] | i3[A8 + 81 | 0] << 8 | i3[A8 + 82 | 0] << 16 | i3[A8 + 83 | 0] << 24) ^ -79577749, QA2 ^ (i3[A8 + 84 | 0] | i3[A8 + 85 | 0] << 8 | i3[A8 + 86 | 0] << 16 | i3[A8 + 87 | 0] << 24) ^ 528734635, 32), SA2 = c4 = t3, c4 = c4 + 1013904242 | 0, QA2 = q4, V2 = c4 = (q4 = q4 - 23791573 | 0) >>> 0 < 4271175723 ? c4 + 1 | 0 : c4, DA2 = _A(q4 ^ cA2, c4 ^ DA2, 40), c4 = (c4 = eA2) + (eA2 = t3) | 0, cA2 = _A(QA2 ^ (h4 = cA2 = DA2 + EA2 | 0), SA2 ^ (k4 = h4 >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = V2 + (u4 = t3) | 0, S4 = c4 = (cA2 = q4 + (n4 = cA2) | 0) >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, cA2 = c4 = _A(DA2 ^ (F4 = cA2), eA2 ^ c4, 1), V2 = q4 = t3, eA2 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, SA2 = c4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, yA2 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, q4 = (DA2 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24) + (QA2 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24) | 0, c4 = (pA2 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24) + (GA2 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24) | 0, c4 = (i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24) + (q4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = SA2 + (EA2 = (D4 = q4) >>> 0 > (q4 = q4 + yA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (yA2 = q4 + eA2 | 0) >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(q4 ^ (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) ^ 725511199, EA2 ^ (i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24) ^ -1694144372, 32), e4 = _A(QA2 ^ (a4 = D4 - 2067093701 | 0), GA2 ^ (L4 = (d4 = q4 = t3) - ((D4 >>> 0 < 2067093701) + 1150833018 | 0) | 0), 40), c4 = (m4 = t3) + c4 | 0, c4 = (U4 = (M4 = q4 = e4 + yA2 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4) + V2 | 0, c4 = (M4 >>> 0 > (q4 = M4 + cA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + X2 | 0, c4 = (QA2 = (y4 = q4) >>> 0 > (q4 = q4 + iA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + z2 | 0, v4 = z2 = q4 + g6 | 0, r4 = c4 = z2 >>> 0 < q4 >>> 0 ? c4 + 1 | 0 : c4, s4 = cA2, sA2 = V2, V2 = q4, EA2 = QA2, cA2 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, q4 = c4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, GA2 = c4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E4 = QA2 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, X2 = c4, c4 = (MA2 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) + (f4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24) | 0, c4 = E4 + ((z2 = i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24) >>> 0 > (y4 = z2 + (QA2 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (yA2 = (X2 = y4 + X2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, kA2 = y4 = X2 + cA2 | 0, y4 = c4 = y4 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, w4 = z2, z2 = _A(X2 ^ (i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) ^ -1377402159, yA2 ^ (i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24) ^ 1359893119, 32), yA2 = c4 = t3, c4 = c4 + 1779033703 | 0, X2 = z2, G4 = c4 = (z2 = z2 - 205731576 | 0) >>> 0 < 4089235720 ? c4 + 1 | 0 : c4, f4 = _A(w4 ^ (N4 = z2), c4 ^ f4, 40), c4 = (P4 = t3) + y4 | 0, w4 = _A(X2 ^ (y4 = z2 = f4 + kA2 | 0), yA2 ^ (_4 = f4 >>> 0 > y4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(w4 ^ V2, (W2 = t3) ^ EA2, 32), T2 = z2 = t3, R4 = c4, B4 = c4 = i3[I7 + 60 | 0] | i3[I7 + 61 | 0] << 8 | i3[I7 + 62 | 0] << 16 | i3[I7 + 63 | 0] << 24, yA2 = kA2 = i3[I7 + 56 | 0] | i3[I7 + 57 | 0] << 8 | i3[I7 + 58 | 0] << 16 | i3[I7 + 59 | 0] << 24, H4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, z2 = (EA2 = i3[I7 + 48 | 0] | i3[I7 + 49 | 0] << 8 | i3[I7 + 50 | 0] << 16 | i3[I7 + 51 | 0] << 24) + (X2 = i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24) | 0, c4 = (NA2 = i3[I7 + 52 | 0] | i3[I7 + 53 | 0] << 8 | i3[I7 + 54 | 0] << 16 | i3[I7 + 55 | 0] << 24) + (b4 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24) | 0, c4 = (i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24) + (z2 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = B4 + (V2 = (p4 = z2) >>> 0 > (z2 = H4 + z2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (H4 = z2 + yA2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, V2 = _A(z2 ^ (i3[A8 + 88 | 0] | i3[A8 + 89 | 0] << 8 | i3[A8 + 90 | 0] << 16 | i3[A8 + 91 | 0] << 24) ^ 327033209, V2 ^ (i3[A8 + 92 | 0] | i3[A8 + 93 | 0] << 8 | i3[A8 + 94 | 0] << 16 | i3[A8 + 95 | 0] << 24) ^ 1541459225, 32), X2 = _A(X2 ^ (yA2 = V2 + 1595750129 | 0), (p4 = b4) ^ (b4 = (J4 = z2 = t3) - ((V2 >>> 0 < 2699217167) + 1521486533 | 0) | 0), 40), c4 = (IA2 = t3) + c4 | 0, z2 = _A((H4 = z2 = X2 + H4 | 0) ^ V2, J4 ^ (p4 = H4 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = b4 + ($2 = t3) | 0, Y4 = c4 = (z2 = yA2 + (b4 = z2) | 0) >>> 0 < yA2 >>> 0 ? c4 + 1 | 0 : c4, c4 = T2 + c4 | 0, O2 = s4 ^ (V2 = R4 + (J4 = z2) | 0), s4 = c4 = V2 >>> 0 < J4 >>> 0 ? c4 + 1 | 0 : c4, yA2 = _A(O2, c4 ^ sA2, 40), c4 = (sA2 = t3) + r4 | 0, z2 = _A(v4 = R4 ^ (r4 = z2 = yA2 + v4 | 0), T2 ^ (R4 = r4 >>> 0 < yA2 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = s4 + (CA2 = t3) | 0, T2 = c4 = (s4 = V2 + (v4 = z2) | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, z2 = (x4 = _A(s4 ^ yA2, sA2 ^ c4, 1)) + (V2 = i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) | 0, c4 = (tA2 = t3) + (sA2 = i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) | 0, FA2 = z2, l3 = z2 >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, Z2 = rA2, z2 = i3[I7 + 96 | 0] | i3[I7 + 97 | 0] << 8 | i3[I7 + 98 | 0] << 16 | i3[I7 + 99 | 0] << 24, yA2 = c4 = i3[I7 + 100 | 0] | i3[I7 + 101 | 0] << 8 | i3[I7 + 102 | 0] << 16 | i3[I7 + 103 | 0] << 24, X2 = (c4 = h4) + (h4 = _A(J4 ^ X2, Y4 ^ IA2, 1)) | 0, c4 = (J4 = t3) + k4 | 0, c4 = (h4 >>> 0 > X2 >>> 0 ? c4 + 1 | 0 : c4) + yA2 | 0, c4 = (k4 = (k4 = X2) >>> 0 > (X2 = z2 + X2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + Z2 | 0, O2 = Y4 = X2 + gA2 | 0, Y4 = c4 = Y4 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, M4 = _A(D4 ^ M4, U4 ^ d4, 48), U4 = c4 = _A(M4 ^ X2, (d4 = t3) ^ k4, 32), c4 = G4 + W2 | 0, c4 = (IA2 = X2 = t3) + (N4 = (X2 = w4 + N4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = c4 = (k4 = X2) >>> 0 > (w4 = k4 + U4 | 0) >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(w4 ^ h4, J4 ^ c4, 40), c4 = (W2 = t3) + Y4 | 0, c4 = (J4 = h4 >>> 0 > (Y4 = X2 = h4 + O2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + l3 | 0, c4 = (D4 = Y4 >>> 0 > (X2 = Y4 + FA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + nA2 | 0, FA2 = l3 = X2 + oA2 | 0, l3 = c4 = l3 >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, O2 = X2, Z2 = D4, X2 = i3[I7 + 116 | 0] | i3[I7 + 117 | 0] << 8 | i3[I7 + 118 | 0] << 16 | i3[I7 + 119 | 0] << 24, I7 = i3[I7 + 112 | 0] | i3[I7 + 113 | 0] << 8 | i3[I7 + 114 | 0] << 16 | i3[I7 + 115 | 0] << 24, f4 = _A(f4 ^ k4, N4 ^ P4, 1), c4 = (P4 = t3) + p4 | 0, c4 = ((D4 = f4 + H4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) + X2 | 0, c4 = (k4 = (N4 = D4) >>> 0 > (D4 = I7 + D4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + nA2 | 0, HA2 = N4 = D4 + oA2 | 0, N4 = c4 = N4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ n4, k4 ^ u4, 32), AA2 = D4 = t3, n4 = c4, k4 = D4, c4 = d4 + L4 | 0, M4 = D4 = a4 + M4 | 0, H4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + k4 | 0, p4 = D4 = D4 + n4 | 0, u4 = c4 = M4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, k4 = _A(D4 ^ f4, P4 ^ c4, 40), c4 = (P4 = t3) + N4 | 0, n4 = _A((D4 = k4 + HA2 | 0) ^ n4, AA2 ^ (a4 = D4 >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(n4 ^ O2, (HA2 = t3) ^ Z2, 32), AA2 = f4 = t3, N4 = c4, O2 = f4, e4 = _A(e4 ^ M4, H4 ^ m4, 1), c4 = _4 + (M4 = t3) | 0, c4 = ((f4 = y4) >>> 0 > (y4 = y4 + e4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + BA2 | 0, c4 = (y4 = (f4 = y4 + j2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + sA2 | 0, Z2 = _4 = f4 + V2 | 0, _4 = c4 = _4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, H4 = e4, f4 = _A(f4 ^ b4, y4 ^ $2, 32), c4 = (b4 = t3) + S4 | 0, F4 = _A(H4 ^ (y4 = e4 = f4 + F4 | 0), (S4 = f4 >>> 0 > y4 >>> 0 ? c4 + 1 | 0 : c4) ^ M4, 40), c4 = ($2 = t3) + _4 | 0, M4 = e4 = F4 + Z2 | 0, e4 = _A(f4 ^ e4, b4 ^ (_4 = e4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = S4 + (o4 = t3) | 0, S4 = e4, b4 = c4 = (e4 = y4 + e4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + O2 | 0, c4 = (H4 = e4) >>> 0 > (e4 = e4 + N4 | 0) >>> 0 ? c4 + 1 | 0 : c4, O2 = e4, e4 ^= x4, x4 = c4, f4 = _A(e4, tA2 ^ c4, 40), c4 = (tA2 = t3) + l3 | 0, l3 = e4 = f4 + FA2 | 0, c4 = Q4 + (Z2 = f4 >>> 0 > e4 >>> 0 ? c4 + 1 | 0 : c4) | 0, FA2 = e4 = e4 + g6 | 0, d4 = c4 = e4 >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4, e4 = D4, L4 = gA2, m4 = rA2, D4 = _A(U4 ^ Y4, J4 ^ IA2, 48), c4 = G4 + (IA2 = t3) | 0, U4 = D4, G4 = c4 = (y4 = w4 + D4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(y4 ^ h4, W2 ^ c4, 1), c4 = (w4 = t3) + m4 | 0, c4 = ((h4 = D4 + L4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = NA2 + (e4 = (a4 = e4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) | 0, Y4 = h4 = a4 + EA2 | 0, h4 = c4 = h4 >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ S4, e4 ^ o4, 32), c4 = T2 + (J4 = t3) | 0, S4 = a4, s4 = c4 = (a4 = s4 + a4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(D4 ^ a4, c4 ^ w4, 40), c4 = (c4 = h4) + (h4 = t3) | 0, w4 = D4 = e4 + Y4 | 0, D4 = _A(D4 ^ S4, J4 ^ (Y4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = s4 + (W2 = t3) | 0, J4 = D4, T2 = c4 = (s4 = a4 + D4 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ s4, h4 ^ c4, 1), c4 = (h4 = t3) + d4 | 0, c4 = B4 + (e4 = (a4 = D4 + FA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, FA2 = S4 = a4 + kA2 | 0, S4 = c4 = S4 >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4, d4 = D4, L4 = h4, c4 = u4 + HA2 | 0, c4 = (D4 = n4 + p4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, n4 = D4, p4 = c4, c4 = _A(D4 ^ k4, P4 ^ c4, 1), k4 = h4 = t3, D4 = c4, c4 = _4 + X2 | 0, c4 = ((M4 = I7 + M4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) + h4 | 0, c4 = hA2 + (M4 = (h4 = D4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4) | 0, u4 = _4 = h4 + iA2 | 0, _4 = c4 = _4 >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ v4, M4 ^ CA2, 32), c4 = G4 + (v4 = t3) | 0, M4 = h4, G4 = c4 = (G4 = y4) >>> 0 > (y4 = y4 + h4 | 0) >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(D4 ^ y4, c4 ^ k4, 40), c4 = (P4 = t3) + _4 | 0, k4 = D4 = h4 + u4 | 0, D4 = _A(_4 = D4 ^ M4, v4 ^ (M4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = G4 + (CA2 = t3) | 0, G4 = D4, _4 = D4 = y4 + D4 | 0, v4 = c4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, u4 = a4, m4 = e4, D4 = _A(F4 ^ H4, b4 ^ $2, 1), c4 = (y4 = t3) + K4 | 0, c4 = R4 + ((a4 = D4 + aA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = BA2 + (e4 = (a4 = a4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) | 0, R4 = r4 = a4 + j2 | 0, r4 = c4 = r4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, F4 = D4, D4 = (a4 = _A(a4 ^ U4, e4 ^ IA2, 32)) + n4 | 0, c4 = (n4 = t3) + p4 | 0, e4 = D4, y4 = _A(D4 ^ F4, (U4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ y4, 40), c4 = (IA2 = t3) + r4 | 0, r4 = D4 = y4 + R4 | 0, H4 = _A(D4 ^ a4, n4 ^ (R4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4), 48), a4 = _A(H4 ^ u4, (c4 = m4) ^ (m4 = t3), 32), c4 = (u4 = t3) + v4 | 0, n4 = D4 = a4 + _4 | 0, F4 = _A(D4 ^ d4, (p4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ L4, 40), c4 = (d4 = t3) + S4 | 0, S4 = D4 = F4 + FA2 | 0, D4 = _A(D4 ^ a4, u4 ^ (b4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = p4 + ($2 = t3) | 0, p4 = D4, u4 = c4 = (a4 = n4) >>> 0 > (n4 = n4 + D4 | 0) >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(n4 ^ F4, d4 ^ c4, 1), c4 = nA2 + (FA2 = t3) | 0, d4 = D4, HA2 = D4 = oA2 + D4 | 0, F4 = c4 = D4 >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = fA2, D4 = _A(h4 ^ _4, P4 ^ v4, 1), c4 = Y4 + (h4 = t3) | 0, c4 = ((_4 = w4) >>> 0 > (w4 = D4 + w4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, c4 = (_4 = (a4 = a4 + w4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) + SA2 | 0, L4 = w4 = a4 + eA2 | 0, Y4 = c4 = w4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, v4 = D4, w4 = _A(N4 ^ l3, Z2 ^ AA2, 48), c4 = _A(w4 ^ a4, (P4 = t3) ^ _4, 32), AA2 = D4 = t3, N4 = c4, a4 = D4, c4 = U4 + m4 | 0, c4 = (D4 = e4 + H4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = D4, U4 = c4, c4 = c4 + a4 | 0, _4 = D4 = D4 + N4 | 0, H4 = c4 = e4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(D4 ^ v4, c4 ^ h4, 40), c4 = (c4 = Y4) + (Y4 = t3) | 0, v4 = D4 = a4 + L4 | 0, l3 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + F4 | 0, Z2 = c4 = (h4 = D4 + HA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, F4 = c4, D4 = _A(y4 ^ e4, U4 ^ IA2, 1), c4 = q4 + (y4 = t3) | 0, c4 = M4 + ((e4 = D4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = yA2 + (k4 = (e4 = e4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4) | 0, L4 = M4 = e4 + z2 | 0, M4 = c4 = M4 >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, U4 = D4, c4 = _A(e4 ^ J4, k4 ^ W2, 32), m4 = D4 = t3, e4 = c4, k4 = D4, c4 = P4 + x4 | 0, J4 = D4 = w4 + O2 | 0, x4 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + k4 | 0, c4 = (w4 = D4 + e4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = w4 ^ U4, U4 = c4, k4 = _A(D4, c4 ^ y4, 40), c4 = (W2 = t3) + M4 | 0, y4 = D4 = k4 + L4 | 0, O2 = _A(D4 ^ e4, m4 ^ (M4 = D4 >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(O2 ^ h4, (IA2 = t3) ^ F4, 32), HA2 = D4 = t3, L4 = c4, F4 = D4, D4 = _A(f4 ^ J4, x4 ^ tA2, 1), c4 = R4 + (f4 = t3) | 0, c4 = MA2 + ((e4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (e4 = e4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) + pA2 | 0, J4 = R4 = e4 + DA2 | 0, R4 = c4 = R4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(e4 ^ G4, r4 ^ CA2, 32), c4 = T2 + (x4 = t3) | 0, G4 = e4, r4 = f4, f4 = c4 = (e4 = s4 + e4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ e4, r4 ^ c4, 40), c4 = (CA2 = t3) + R4 | 0, s4 = D4 = r4 + J4 | 0, D4 = _A(J4 = D4 ^ G4, x4 ^ (G4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = f4 + (P4 = t3) | 0, f4 = D4, R4 = D4 = e4 + D4 | 0, J4 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + F4 | 0, T2 = c4 = (F4 = D4 + L4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(F4 ^ d4, FA2 ^ c4, 40), c4 = Z2 + (x4 = t3) | 0, c4 = ((D4 = e4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) + rA2 | 0, h4 = D4, Z2 = D4 = D4 + gA2 | 0, d4 = c4 = h4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, m4 = BA2, h4 = _A(N4 ^ v4, l3 ^ AA2, 48), c4 = (tA2 = t3) + H4 | 0, N4 = D4 = h4 + _4 | 0, c4 = _A(D4 ^ a4, (_4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) ^ Y4, 1), Y4 = a4 = t3, D4 = c4, c4 = M4 + Q4 | 0, c4 = ((y4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = (y4 = (a4 = D4 + y4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + m4 | 0, H4 = M4 = a4 + j2 | 0, M4 = c4 = M4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ f4, y4 ^ P4, 32), c4 = u4 + (v4 = t3) | 0, n4 = c4 = (f4 = a4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ f4, c4 ^ Y4, 40), c4 = (l3 = t3) + M4 | 0, M4 = D4 = y4 + H4 | 0, a4 = _A(D4 ^ a4, v4 ^ (Y4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + (H4 = t3) | 0, v4 = c4 = (n4 = a4 + f4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(y4 ^ n4, l3 ^ c4, 1), c4 = (l3 = t3) + d4 | 0, c4 = sA2 + ((f4 = D4 + Z2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (y4 = (f4 = f4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) + K4 | 0, FA2 = K4 = f4 + aA2 | 0, K4 = c4 = K4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, u4 = D4, m4 = f4, P4 = y4, f4 = fA2, D4 = _A(r4 ^ R4, J4 ^ CA2, 1), c4 = b4 + (r4 = t3) | 0, c4 = ((y4 = S4) >>> 0 > (S4 = D4 + S4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, c4 = pA2 + (y4 = (f4 = f4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4) | 0, b4 = S4 = f4 + DA2 | 0, R4 = c4 = S4 >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4, S4 = D4, y4 = c4 = _A(f4 ^ h4, y4 ^ tA2, 32), c4 = U4 + IA2 | 0, c4 = (J4 = D4 = t3) + (w4 = (D4 = w4 + O2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (h4 = D4 + y4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(h4 ^ S4, c4 ^ r4, 40), c4 = (IA2 = t3) + R4 | 0, R4 = _A(b4 = (f4 = S4 + b4 | 0) ^ y4, J4 ^ (y4 = f4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(R4 ^ m4, (CA2 = t3) ^ P4, 32), tA2 = r4 = t3, b4 = c4, J4 = r4, D4 = _A(D4 ^ k4, w4 ^ W2, 1), c4 = yA2 + (r4 = t3) | 0, c4 = G4 + ((w4 = D4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = MA2 + (s4 = (w4 = w4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, m4 = k4 = w4 + QA2 | 0, k4 = c4 = k4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, G4 = D4, O2 = r4, w4 = _A(w4 ^ p4, s4 ^ $2, 32), c4 = (p4 = t3) + _4 | 0, r4 = D4 = w4 + N4 | 0, s4 = _A(D4 ^ G4, (N4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) ^ O2, 40), c4 = (W2 = t3) + k4 | 0, G4 = D4 = s4 + m4 | 0, D4 = _A(D4 ^ w4, p4 ^ (_4 = D4 >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = N4 + (m4 = t3) | 0, k4 = D4, N4 = D4 = r4 + D4 | 0, p4 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + J4 | 0, J4 = D4 = D4 + b4 | 0, w4 = l3, l3 = c4 = N4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ u4, w4 ^ c4, 40), c4 = (c4 = K4) + (K4 = t3) | 0, O2 = D4 = w4 + FA2 | 0, u4 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = y4, D4 = _A(L4 ^ Z2, d4 ^ HA2, 48), c4 = T2 + ($2 = t3) | 0, T2 = D4, y4 = (D4 = F4 + D4 | 0) ^ e4, e4 = c4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(y4, c4 ^ x4, 1), c4 = (x4 = t3) + r4 | 0, c4 = B4 + ((f4 = y4 + f4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (f4 = f4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, Z2 = F4 = f4 + cA2 | 0, F4 = c4 = F4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(f4 ^ k4, r4 ^ m4, 32), c4 = v4 + (d4 = t3) | 0, v4 = f4, n4 = c4 = (r4 = n4 + f4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(y4 ^ r4, x4 ^ c4, 40), c4 = (c4 = F4) + (F4 = t3) | 0, k4 = f4 = y4 + Z2 | 0, f4 = _A(L4 = f4 ^ v4, d4 ^ (v4 = f4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + (FA2 = t3) | 0, x4 = f4, Z2 = c4 = (n4 = r4 + f4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(y4 ^ n4, F4 ^ c4, 1), c4 = (F4 = t3) + u4 | 0, c4 = Q4 + ((y4 = f4 + O2 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = X2 + (r4 = (y4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, HA2 = d4 = I7 + y4 | 0, d4 = c4 = d4 >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, L4 = f4, m4 = F4, F4 = y4, P4 = r4, f4 = _A(s4 ^ N4, p4 ^ W2, 1), c4 = (r4 = t3) + Y4 | 0, c4 = hA2 + ((y4 = f4 + M4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (s4 = (y4 = y4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + X2 | 0, Y4 = M4 = I7 + y4 | 0, M4 = c4 = M4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, N4 = f4, y4 = c4 = _A(y4 ^ T2, s4 ^ $2, 32), s4 = f4 = t3, c4 = U4 + CA2 | 0, U4 = c4 = (f4 = h4 + R4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + s4 | 0, c4 = (h4 = f4) >>> 0 > (f4 = f4 + y4 | 0) >>> 0 ? c4 + 1 | 0 : c4, R4 = f4, f4 ^= N4, N4 = c4, r4 = _A(f4, c4 ^ r4, 40), c4 = (W2 = t3) + M4 | 0, s4 = _A(M4 = (f4 = r4 + Y4 | 0) ^ y4, s4 ^ (y4 = f4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(s4 ^ F4, (c4 = P4) ^ (P4 = t3), 32), $2 = F4 = t3, M4 = c4, Y4 = e4, e4 = a4, c4 = _A(h4 ^ S4, U4 ^ IA2, 1), p4 = a4 = t3, h4 = c4, c4 = _4 + SA2 | 0, c4 = ((S4 = G4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, S4 = c4 = (a4 = h4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(a4 ^ e4, c4 ^ H4, 32), c4 = (c4 = Y4) + (Y4 = t3) | 0, h4 = _A((D4 = e4 + D4 | 0) ^ h4, p4 ^ (U4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = S4 + (IA2 = t3) | 0, G4 = h4, c4 = NA2 + ((_4 = a4) >>> 0 > (a4 = a4 + h4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, _4 = c4 = (h4 = a4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(e4 ^ h4, Y4 ^ c4, 48), c4 = U4 + (CA2 = t3) | 0, H4 = D4, e4 = a4, U4 = D4 = D4 + a4 | 0, Y4 = c4 = H4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + F4 | 0, H4 = c4 = (F4 = D4 + M4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = (S4 = _A(F4 ^ L4, c4 ^ m4, 40)) + HA2 | 0, c4 = (HA2 = t3) + d4 | 0, p4 = D4, T2 = D4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(b4 ^ O2, u4 ^ tA2, 48), c4 = (b4 = t3) + l3 | 0, J4 = a4 = D4 + J4 | 0, L4 = K4, K4 = c4 = a4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(a4 ^ w4, L4 ^ c4, 1), O2 = a4 = t3, w4 = c4, c4 = y4 + B4 | 0, c4 = ((f4 = f4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = sA2 + (f4 = (a4 = f4 + w4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, u4 = y4 = a4 + V2 | 0, y4 = c4 = y4 >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ e4, f4 ^ CA2, 32), c4 = Z2 + (d4 = t3) | 0, l3 = a4, a4 = (e4 = n4 + a4 | 0) ^ w4, w4 = c4 = e4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(a4, O2 ^ c4, 40), c4 = (c4 = y4) + (y4 = t3) | 0, O2 = a4 = f4 + u4 | 0, a4 = _A(n4 = a4 ^ l3, d4 ^ (l3 = a4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = w4 + (CA2 = t3) | 0, Z2 = a4, e4 = c4 = (a4 = e4 + a4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(a4 ^ f4, y4 ^ c4, 1), c4 = (n4 = t3) + T2 | 0, c4 = nA2 + ((y4 = f4 + p4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (w4 = (y4 = y4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) + BA2 | 0, AA2 = u4 = y4 + j2 | 0, u4 = c4 = u4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, d4 = f4, L4 = y4, m4 = w4, f4 = _A(G4 ^ U4, Y4 ^ IA2, 1), c4 = (Y4 = t3) + rA2 | 0, c4 = v4 + (f4 >>> 0 > (y4 = f4 + gA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, w4 = c4 = (y4 = y4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ y4, c4 ^ b4, 32), b4 = D4 = t3, k4 = c4, c4 = N4 + P4 | 0, c4 = (D4 = s4 + R4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, s4 = D4, U4 = c4, c4 = b4 + c4 | 0, N4 = D4 = D4 + k4 | 0, G4 = c4 = s4 >>> 0 > D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(D4 ^ f4, Y4 ^ c4, 40), c4 = w4 + (P4 = t3) | 0, R4 = D4, c4 = yA2 + ((D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (D4 = D4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, Y4 = D4, D4 ^= k4, k4 = c4, w4 = _A(D4, b4 ^ c4, 48), c4 = _A(w4 ^ L4, (c4 = m4) ^ (m4 = t3), 32), IA2 = D4 = t3, b4 = c4, v4 = D4, D4 = _A(r4 ^ s4, U4 ^ W2, 1), c4 = SA2 + (y4 = t3) | 0, c4 = _4 + ((f4 = D4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (f4 = f4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, _4 = s4 = f4 + cA2 | 0, s4 = c4 = s4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, h4 = D4, U4 = y4, D4 = (f4 = _A(f4 ^ x4, r4 ^ FA2, 32)) + J4 | 0, c4 = (J4 = t3) + K4 | 0, y4 = D4, r4 = _A(r4 = D4 ^ h4, (h4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) ^ U4, 40), c4 = (W2 = t3) + s4 | 0, s4 = D4 = r4 + _4 | 0, f4 = _A(D4 ^ f4, J4 ^ (K4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = h4 + (U4 = t3) | 0, _4 = D4 = f4 + y4 | 0, J4 = c4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + v4 | 0, v4 = c4 = (h4 = D4 + b4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(h4 ^ d4, c4 ^ n4, 40), c4 = (x4 = t3) + u4 | 0, u4 = D4 = y4 + AA2 | 0, d4 = c4 = D4 >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, D4 = a4, n4 = e4, e4 = f4, a4 = _A(M4 ^ p4, T2 ^ $2, 48), c4 = H4 + (AA2 = t3) | 0, M4 = a4, F4 = c4 = (f4 = F4 + a4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(f4 ^ S4, HA2 ^ c4, 1), H4 = a4 = t3, S4 = c4, c4 = k4 + KA2 | 0, c4 = ((k4 = Y4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, k4 = c4 = (a4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(a4 ^ e4, c4 ^ U4, 32), c4 = (Y4 = t3) + n4 | 0, S4 = _A((D4 = e4 + D4 | 0) ^ S4, H4 ^ (n4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = k4 + (p4 = t3) | 0, c4 = MA2 + ((k4 = a4) >>> 0 > (a4 = a4 + S4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (k4 = a4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(e4 ^ k4, Y4 ^ c4, 48), c4 = n4 + ($2 = t3) | 0, Y4 = a4, H4 = c4 = (n4 = D4 + a4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(n4 ^ S4, p4 ^ c4, 1), c4 = (S4 = t3) + d4 | 0, c4 = hA2 + ((a4 = D4 + u4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = nA2 + (e4 = (a4 = a4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, tA2 = p4 = a4 + oA2 | 0, p4 = c4 = p4 >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4, T2 = D4, L4 = a4, D4 = _A(r4 ^ _4, J4 ^ W2, 1), c4 = (r4 = t3) + l3 | 0, c4 = pA2 + ((a4 = D4 + O2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = NA2 + (_4 = (a4 = a4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, O2 = J4 = a4 + EA2 | 0, J4 = c4 = J4 >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4, l3 = D4, c4 = _A(a4 ^ M4, _4 ^ AA2, 32), AA2 = D4 = t3, a4 = c4, c4 = G4 + m4 | 0, N4 = D4 = w4 + N4 | 0, M4 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = AA2 + c4 | 0, G4 = c4 = (w4 = D4 + a4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(w4 ^ l3, c4 ^ r4, 40), c4 = (m4 = t3) + J4 | 0, _4 = D4 = r4 + O2 | 0, l3 = _A(D4 ^ a4, AA2 ^ (J4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(l3 ^ L4, (AA2 = t3) ^ e4, 32), W2 = D4 = t3, O2 = c4, e4 = D4, a4 = fA2, D4 = _A(N4 ^ R4, M4 ^ P4, 1), c4 = K4 + (M4 = t3) | 0, c4 = ((N4 = s4) >>> 0 > (s4 = D4 + s4 | 0) >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, c4 = hA2 + (s4 = (a4 = a4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, N4 = K4 = a4 + iA2 | 0, K4 = c4 = K4 >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(a4 ^ Z2, s4 ^ CA2, 32), c4 = F4 + (R4 = t3) | 0, F4 = a4, c4 = (a4 = f4 + a4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = M4, M4 = c4, f4 = _A(D4 ^ a4, f4 ^ c4, 40), c4 = (P4 = t3) + K4 | 0, s4 = D4 = f4 + N4 | 0, D4 = _A(D4 ^ F4, R4 ^ (K4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = M4 + (L4 = t3) | 0, M4 = D4, N4 = D4 = a4 + D4 | 0, R4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + e4 | 0, c4 = (F4 = D4 + O2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = F4 ^ T2, T2 = c4, S4 = _A(D4, c4 ^ S4, 40), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = S4 + tA2 | 0, Z2 = D4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(b4 ^ u4, d4 ^ IA2, 48), c4 = v4 + (IA2 = t3) | 0, b4 = D4, c4 = (D4 = h4 + D4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, h4 = D4, v4 = c4, c4 = _A(D4 ^ y4, c4 ^ x4, 1), x4 = D4 = t3, e4 = c4, c4 = J4 + sA2 | 0, c4 = ((a4 = _4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) + D4 | 0, c4 = MA2 + (a4 = (D4 = a4 + e4 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) | 0, _4 = y4 = D4 + QA2 | 0, y4 = c4 = y4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(D4 ^ M4, a4 ^ L4, 32), c4 = H4 + (J4 = t3) | 0, M4 = D4, n4 = c4 = (a4 = n4 + D4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(a4 ^ e4, x4 ^ c4, 40), c4 = (x4 = t3) + y4 | 0, _4 = D4 = e4 + _4 | 0, D4 = _A(y4 = D4 ^ M4, J4 ^ (M4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + (tA2 = t3) | 0, n4 = D4, H4 = c4 = (y4 = a4 + D4 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(y4 ^ e4, x4 ^ c4, 1), c4 = (J4 = t3) + Z2 | 0, c4 = SA2 + ((a4 = D4 + p4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (e4 = (a4 = a4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) + rA2 | 0, FA2 = x4 = a4 + gA2 | 0, x4 = c4 = x4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, u4 = D4, d4 = a4, L4 = e4, D4 = _A(f4 ^ N4, P4 ^ R4, 1), c4 = pA2 + (e4 = t3) | 0, c4 = U4 + ((a4 = D4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = KA2 + (f4 = (a4 = a4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4) | 0, R4 = k4 = a4 + aA2 | 0, k4 = c4 = k4 >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4, U4 = D4, N4 = e4, c4 = _A(a4 ^ b4, f4 ^ IA2, 32), b4 = D4 = t3, f4 = c4, a4 = D4, c4 = G4 + AA2 | 0, c4 = (D4 = w4 + l3 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, w4 = D4, G4 = c4, c4 = c4 + a4 | 0, c4 = (e4 = D4 + f4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = e4 ^ U4, U4 = c4, D4 = _A(D4, c4 ^ N4, 40), c4 = (c4 = k4) + (k4 = t3) | 0, N4 = a4 = D4 + R4 | 0, R4 = c4 = a4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, b4 = _A(a4 ^ f4, b4 ^ c4, 48), c4 = _A(b4 ^ d4, (c4 = L4) ^ (L4 = t3), 32), P4 = a4 = t3, l3 = c4, a4 = _A(w4 ^ r4, G4 ^ m4, 1), c4 = (w4 = t3) + wA2 | 0, c4 = K4 + ((f4 = a4 + fA2 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = B4 + (r4 = (f4 = f4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, m4 = s4 = f4 + kA2 | 0, s4 = c4 = s4 >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4, K4 = a4, G4 = w4, f4 = _A(f4 ^ Y4, r4 ^ $2, 32), c4 = (Y4 = t3) + v4 | 0, w4 = a4 = f4 + h4 | 0, a4 = (r4 = _A(a4 ^ K4, (h4 = a4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4) ^ G4, 40)) + m4 | 0, c4 = (m4 = t3) + s4 | 0, K4 = a4, a4 = _A(a4 ^ f4, Y4 ^ (G4 = a4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = h4 + (AA2 = t3) | 0, Y4 = a4, v4 = a4 = w4 + a4 | 0, d4 = c4 = a4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = P4 + c4 | 0, c4 = (f4 = a4 + l3 | 0) >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, a4 = J4, J4 = c4, w4 = _A(f4 ^ u4, a4 ^ c4, 40), c4 = (IA2 = t3) + x4 | 0, s4 = a4 = w4 + FA2 | 0, c4 = _A(a4 ^ l3, P4 ^ (x4 = a4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4), 48), P4 = a4 = t3, l3 = c4, a4 = D4, c4 = U4 + L4 | 0, U4 = D4 = e4 + b4 | 0, b4 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ a4, c4 ^ k4, 1), e4 = a4 = t3, D4 = c4, c4 = G4 + Q4 | 0, c4 = ((h4 = K4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, c4 = yA2 + (h4 = (a4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4) | 0, L4 = k4 = a4 + z2 | 0, k4 = c4 = k4 >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, K4 = D4, G4 = e4, D4 = _A(p4 ^ O2, Z2 ^ W2, 48), c4 = T2 + (W2 = t3) | 0, p4 = D4, c4 = (D4 = F4 + D4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, F4 = D4, a4 = _A(a4 ^ n4, h4 ^ tA2, 32), T2 = c4, c4 = c4 + (O2 = t3) | 0, e4 = D4 = a4 + D4 | 0, h4 = _A(D4 ^ K4, (n4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ G4, 40), c4 = (Z2 = t3) + k4 | 0, k4 = D4 = h4 + L4 | 0, D4 = _A(D4 ^ a4, O2 ^ (K4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + ($2 = t3) | 0, G4 = D4, O2 = c4 = (n4 = e4 + D4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ n4, Z2 ^ c4, 1), c4 = MA2 + (L4 = t3) | 0, Z2 = D4, tA2 = D4 = QA2 + D4 | 0, e4 = c4 = D4 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(S4 ^ F4, T2 ^ CA2, 1), c4 = (h4 = t3) + R4 | 0, c4 = NA2 + ((a4 = D4 + N4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = BA2 + (F4 = (a4 = a4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, T2 = S4 = a4 + j2 | 0, S4 = c4 = S4 >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, N4 = h4, a4 = _A(a4 ^ Y4, F4 ^ AA2, 32), c4 = H4 + (AA2 = t3) | 0, R4 = a4, c4 = (h4 = y4 + a4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, y4 = N4, N4 = c4, F4 = _A(D4 ^ h4, y4 ^ c4, 40), c4 = (CA2 = t3) + S4 | 0, Y4 = D4 = F4 + T2 | 0, c4 = (H4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, S4 = c4 = (e4 = D4 + tA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, T2 = c4 = _A(e4 ^ l3, c4 ^ P4, 32), u4 = D4 = t3, D4 = _A(r4 ^ v4, d4 ^ m4, 1), c4 = (y4 = t3) + M4 | 0, c4 = X2 + ((a4 = D4 + _4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (r4 = (a4 = I7 + a4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) + q4 | 0, d4 = M4 = a4 + cA2 | 0, M4 = c4 = M4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, _4 = D4, v4 = y4, a4 = _A(a4 ^ p4, r4 ^ W2, 32), c4 = (p4 = t3) + b4 | 0, y4 = D4 = a4 + U4 | 0, D4 = (r4 = _A(D4 ^ _4, (U4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4) ^ v4, 40)) + d4 | 0, c4 = (d4 = t3) + M4 | 0, M4 = D4, D4 = _A(D4 ^ a4, p4 ^ (_4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = U4 + (W2 = t3) | 0, U4 = D4, p4 = c4 = (D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + u4 | 0, b4 = c4 = (y4 = D4) >>> 0 > (D4 = D4 + T2 | 0) >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(D4 ^ Z2, L4 ^ c4, 40), c4 = S4 + (L4 = t3) | 0, v4 = a4, c4 = Q4 + ((a4 = e4 + a4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4) | 0, Z2 = a4 = a4 + g6 | 0, e4 = a4 ^ T2, T2 = c4 = a4 >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4, a4 = _A(e4, u4 ^ c4, 48), c4 = b4 + (u4 = t3) | 0, b4 = c4 = (S4 = D4 + a4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = c4 = _A(S4 ^ v4, L4 ^ c4, 1), v4 = e4 = t3, e4 = _A(y4 ^ r4, p4 ^ d4, 1), c4 = K4 + (r4 = t3) | 0, c4 = NA2 + ((y4 = e4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = hA2 + (k4 = (y4 = y4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, L4 = K4 = y4 + iA2 | 0, K4 = c4 = K4 >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, p4 = e4, d4 = r4, c4 = J4 + P4 | 0, c4 = (e4 = f4 + l3 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, J4 = e4, R4 = _A(Y4 ^ R4, H4 ^ AA2, 48), r4 = _A(y4 ^ R4, k4 ^ (AA2 = t3), 32), Y4 = c4, c4 = c4 + (tA2 = t3) | 0, k4 = e4 = r4 + e4 | 0, e4 = _A(e4 ^ p4, (H4 = e4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) ^ d4, 40), c4 = (p4 = t3) + K4 | 0, d4 = c4 = (f4 = e4 + L4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + v4 | 0, c4 = B4 + ((l3 = f4) >>> 0 > (f4 = D4 + f4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (y4 = (f4 = f4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + wA2 | 0, FA2 = K4 = f4 + fA2 | 0, L4 = c4 = K4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, m4 = D4, P4 = f4, c4 = _A(w4 ^ J4, Y4 ^ IA2, 1), w4 = f4 = t3, D4 = c4, c4 = _4 + pA2 | 0, c4 = ((K4 = M4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, c4 = yA2 + (K4 = (f4 = D4 + K4 | 0) >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4) | 0, Y4 = M4 = f4 + z2 | 0, M4 = c4 = M4 >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4, _4 = D4, c4 = _A(f4 ^ G4, K4 ^ $2, 32), J4 = D4 = t3, f4 = c4, K4 = D4, c4 = N4 + AA2 | 0, N4 = D4 = h4 + R4 | 0, G4 = c4 = D4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + K4 | 0, c4 = (h4 = D4 + f4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = h4 ^ _4; + _4 = c4, K4 = _A(D4, c4 ^ w4, 40), c4 = (AA2 = t3) + M4 | 0, R4 = _A(M4 = (D4 = K4 + Y4 | 0) ^ f4, J4 ^ (f4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = _A(c4 = R4 ^ P4, (P4 = t3) ^ y4, 32), IA2 = y4 = t3, Y4 = c4, M4 = y4, y4 = _A(F4 ^ N4, G4 ^ CA2, 1), c4 = BA2 + (F4 = t3) | 0, c4 = x4 + ((w4 = y4 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = SA2 + (s4 = (w4 = w4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = N4 = w4 + eA2 | 0, N4 = c4 = N4 >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ U4, s4 ^ W2, 32), c4 = O2 + (J4 = t3) | 0, U4 = w4, n4 = c4 = (w4 = n4 + w4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, s4 = _A(y4 ^ w4, c4 ^ F4, 40), c4 = (W2 = t3) + N4 | 0, F4 = y4 = s4 + G4 | 0, y4 = _A(N4 = y4 ^ U4, J4 ^ (U4 = y4 >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = n4 + ($2 = t3) | 0, N4 = y4, G4 = y4 = w4 + y4 | 0, J4 = c4 = y4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, c4 = c4 + M4 | 0, c4 = (w4 = y4 + Y4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4, y4 = v4, v4 = c4, n4 = _A(w4 ^ m4, y4 ^ c4, 40), c4 = (x4 = t3) + L4 | 0, M4 = y4 = n4 + FA2 | 0, y4 = _A(L4 = y4 ^ Y4, IA2 ^ (Y4 = y4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = v4 + (IA2 = t3) | 0, v4 = y4, w4 = c4 = (y4 = w4 + y4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, x4 = c4 = _A(y4 ^ n4, x4 ^ c4, 1), CA2 = c4, O2 = n4 = t3, n4 = f4, f4 = e4, e4 = _A(r4 ^ l3, d4 ^ tA2, 48), c4 = H4 + (tA2 = t3) | 0, H4 = e4, c4 = (e4 = k4 + e4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = D4, D4 = f4 ^ e4, f4 = c4, D4 = _A(D4, c4 ^ p4, 1), c4 = (p4 = t3) + n4 | 0, c4 = KA2 + (D4 >>> 0 > (r4 = k4 + D4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = rA2 + (k4 = (r4 = r4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = n4 = r4 + gA2 | 0, n4 = c4 = n4 >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ N4, k4 ^ $2, 32), c4 = b4 + (d4 = t3) | 0, N4 = c4 = (k4 = r4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(D4 ^ k4, p4 ^ c4, 40), c4 = ($2 = t3) + n4 | 0, p4 = D4 = S4 + l3 | 0, r4 = _A(D4 ^ r4, d4 ^ (b4 = D4 >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4), 48), c4 = N4 + (l3 = t3) | 0, d4 = D4 = r4 + k4 | 0, N4 = D4, L4 = c4 = D4 >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = e4, n4 = f4, c4 = _4 + P4 | 0, c4 = (D4 = h4 + R4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, h4 = D4, D4 ^= K4, K4 = c4, c4 = _A(D4, AA2 ^ c4, 1), m4 = D4 = t3, _4 = c4, f4 = c4, c4 = U4 + q4 | 0, c4 = ((e4 = F4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) + D4 | 0, F4 = c4 = (D4 = e4) >>> 0 > (e4 = f4 + e4 | 0) >>> 0 ? c4 + 1 | 0 : c4, f4 = _A(a4 ^ e4, c4 ^ u4, 32), c4 = (c4 = n4) + (n4 = t3) | 0, R4 = D4 = f4 + k4 | 0, a4 = _A(a4 = D4 ^ _4, m4 ^ (_4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = F4 + (u4 = t3) | 0, c4 = sA2 + ((D4 = a4 + e4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4) | 0, m4 = c4 = (k4 = D4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, n4 = _A(f4 ^ k4, n4 ^ c4, 48), FA2 = c4 = t3, D4 = _A(s4 ^ G4, J4 ^ W2, 1), c4 = (f4 = t3) + T2 | 0, c4 = nA2 + ((e4 = D4 + Z2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = X2 + (s4 = (e4 = e4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, T2 = F4 = I7 + e4 | 0, G4 = c4 = F4 >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, J4 = D4, F4 = _A(e4 ^ H4, s4 ^ tA2, 32), c4 = (W2 = t3) + K4 | 0, K4 = D4 = F4 + h4 | 0, e4 = _A(D4 ^ J4, (H4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ f4, 40), c4 = (c4 = G4) + (G4 = t3) | 0, J4 = D4 = e4 + T2 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = X2 + O2 | 0, c4 = ((s4 = I7 + x4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, U4 = c4 = (f4 = D4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ n4, FA2 ^ c4, 32), c4 = (x4 = t3) + L4 | 0, h4 = _A((s4 = D4 + N4 | 0) ^ CA2, (c4 = s4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ O2, 40), O2 = c4, c4 = rA2 + (N4 = t3) | 0, c4 = U4 + ((Z2 = h4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = f4 + Z2 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = x4, x4 = c4, f4 = _A(D4 ^ U4, f4 ^ c4, 48), c4 = (c4 = O2) + (O2 = t3) | 0, D4 = h4 ^ (s4 = f4 + s4 | 0), h4 = c4 = s4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, Z2 = c4 = _A(D4, c4 ^ N4, 1), CA2 = c4, P4 = D4 = t3, N4 = y4, AA2 = w4, y4 = e4, e4 = _A(F4 ^ J4, T2 ^ W2, 48), c4 = H4 + (J4 = t3) | 0, F4 = D4 = e4 + K4 | 0, K4 = c4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ G4, 1), c4 = (T2 = t3) + KA2 | 0, c4 = m4 + ((D4 = y4 + aA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, k4 = c4 = (w4 = D4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(w4 ^ r4, c4 ^ l3, 32), c4 = (G4 = t3) + AA2 | 0, N4 = r4 = D4 + N4 | 0, H4 = c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(y4 ^ r4, c4 ^ T2, 40), c4 = hA2 + (tA2 = t3) | 0, T2 = y4, c4 = k4 + ((y4 = iA2 + y4 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, w4 = c4 = (y4 = y4 + w4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ y4, c4 ^ G4, 48), c4 = (c4 = H4) + (H4 = t3) | 0, l3 = D4 = r4 + N4 | 0, G4 = D4, m4 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _4 + FA2 | 0, N4 = (D4 = n4 + R4 | 0) ^ a4, a4 = c4 = D4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(N4, c4 ^ u4, 1), u4 = k4 = t3, N4 = c4, c4 = b4 + yA2 | 0, c4 = ((n4 = p4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) + k4 | 0, _4 = c4 = (_4 = n4) >>> 0 > (n4 = n4 + N4 | 0) >>> 0 ? c4 + 1 | 0 : c4, R4 = k4 = _A(n4 ^ v4, IA2 ^ c4, 32), p4 = c4 = t3, c4 = c4 + K4 | 0, b4 = k4 = k4 + F4 | 0, v4 = c4 = R4 >>> 0 > k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = _A(k4 ^ N4, u4 ^ c4, 40), c4 = wA2 + (u4 = t3) | 0, c4 = _4 + ((F4 = k4 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (N4 = n4) >>> 0 > (n4 = n4 + F4 | 0) >>> 0 ? c4 + 1 | 0 : c4, N4 = _A(n4 ^ R4, c4 ^ p4, 48), IA2 = c4 = t3, K4 = c4, S4 = _A(S4 ^ d4, L4 ^ $2, 1), _4 = c4 = t3, R4 = e4, c4 = c4 + q4 | 0, c4 = Y4 + ((e4 = S4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (e4 = e4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, M4 = e4 ^ R4, R4 = c4, M4 = _A(M4, c4 ^ J4, 32), c4 = ($2 = t3) + a4 | 0, Y4 = D4 = M4 + D4 | 0, a4 = _A(D4 ^ S4, (a4 = _4) ^ (_4 = D4 >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = nA2 + (p4 = t3) | 0, c4 = R4 + ((D4 = a4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, R4 = D4 = D4 + e4 | 0, J4 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + NA2 | 0, c4 = ((S4 = Z2 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, Z2 = c4 = (e4 = D4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ N4, c4 ^ K4, 32), c4 = (d4 = t3) + m4 | 0, K4 = _A((S4 = D4 + G4 | 0) ^ CA2, (c4 = S4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = G4 = t3, P4 = c4, c4 = G4 + SA2 | 0, c4 = Z2 + ((G4 = K4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, Z2 = c4 = (G4 = e4 + G4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = _A(D4 ^ G4, c4 ^ d4, 48), c4 = (d4 = t3) + P4 | 0, D4 = (S4 = e4 + S4 | 0) ^ K4, K4 = c4 = S4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, L4 = c4 = _A(D4, c4 ^ L4, 1), P4 = D4 = t3, AA2 = s4, W2 = r4, r4 = a4, a4 = _A(M4 ^ R4, J4 ^ $2, 48), c4 = (M4 = t3) + _4 | 0, _4 = D4 = a4 + Y4 | 0, R4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ r4, c4 ^ p4, 1), c4 = (p4 = t3) + MA2 | 0, c4 = ((D4 = r4 + QA2 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) + F4 | 0, n4 = c4 = (s4 = D4 + n4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(s4 ^ W2, c4 ^ H4, 32), c4 = (F4 = t3) + h4 | 0, Y4 = h4 = D4 + AA2 | 0, H4 = c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ h4, c4 ^ p4, 40), c4 = B4 + (W2 = t3) | 0, p4 = r4, c4 = n4 + ((r4 = kA2 + r4 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, J4 = c4 = (h4 = r4 + s4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ h4, c4 ^ F4, 48), c4 = (c4 = H4) + (H4 = t3) | 0, Y4 = D4 = r4 + Y4 | 0, AA2 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, n4 = f4, s4 = y4, c4 = v4 + IA2 | 0, f4 = c4 = (D4 = N4 + b4 | 0) >>> 0 < N4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ k4, c4 ^ u4, 1), c4 = (k4 = t3) + BA2 | 0, c4 = ((F4 = y4 + j2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) + w4 | 0, w4 = _A(n4 ^ (s4 = s4 + F4 | 0), (c4 = s4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ O2, 32), F4 = c4, N4 = y4, c4 = (n4 = t3) + R4 | 0, c4 = (y4 = w4 + _4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, _4 = y4, y4 ^= N4, N4 = c4, y4 = _A(y4, c4 ^ k4, 40), c4 = Q4 + (R4 = t3) | 0, c4 = ((k4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + F4 | 0, b4 = c4 = (F4 = k4) >>> 0 > (k4 = k4 + s4 | 0) >>> 0 ? c4 + 1 | 0 : c4, n4 = _A(w4 ^ k4, c4 ^ n4, 48), IA2 = c4 = t3, s4 = c4, w4 = _A(l3 ^ T2, m4 ^ tA2, 1), v4 = c4 = t3, T2 = f4, c4 = c4 + sA2 | 0, c4 = x4 + ((f4 = w4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = M4, M4 = c4 = (f4 = f4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, F4 = _A(a4 ^ f4, F4 ^ c4, 32), c4 = ($2 = t3) + T2 | 0, U4 = D4 = F4 + D4 | 0, a4 = _A(D4 ^ w4, (a4 = v4) ^ (v4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = pA2 + (T2 = t3) | 0, c4 = M4 + ((D4 = a4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, x4 = D4 = D4 + f4 | 0, l3 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + yA2 | 0, c4 = ((w4 = z2 + L4 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + w4 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ n4, c4 ^ s4, 32), c4 = (O2 = t3) + AA2 | 0, s4 = _A((w4 = D4 + Y4 | 0) ^ L4, (c4 = w4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = q4 + (u4 = t3) | 0, c4 = M4 + ((m4 = s4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + m4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = O2, O2 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (w4 = f4 + w4 | 0) ^ s4, s4 = c4 = w4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, u4 = c4 = _A(D4, c4 ^ u4, 1), m4 = D4 = t3, P4 = r4, r4 = a4, a4 = _A(F4 ^ x4, l3 ^ $2, 48), c4 = (c4 = v4) + (v4 = t3) | 0, U4 = D4 = a4 + U4 | 0, F4 = T2, T2 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ r4, F4 ^ c4, 1), c4 = (x4 = t3) + SA2 | 0, c4 = b4 + ((D4 = r4 + eA2 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = k4, k4 = D4 + k4 | 0, D4 = H4, H4 = c4 = F4 >>> 0 > k4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(k4 ^ P4, D4 ^ c4, 32), c4 = (c4 = K4) + (K4 = t3) | 0, b4 = c4 = (F4 = D4 + S4 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, S4 = F4, r4 = _A(r4 ^ F4, c4 ^ x4, 40), c4 = sA2 + ($2 = t3) | 0, x4 = r4, c4 = H4 + ((r4 = V2 + r4 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, H4 = c4 = (F4 = r4 + k4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(D4 ^ F4, c4 ^ K4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = r4 + S4 | 0, P4 = c4 = D4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, S4 = e4, c4 = N4 + IA2 | 0, e4 = c4 = (D4 = n4 + _4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ R4, 1), c4 = rA2 + (n4 = t3) | 0, c4 = J4 + ((k4 = y4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, N4 = (k4 = h4 + k4 | 0) ^ S4, S4 = c4 = k4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(N4, c4 ^ d4, 32), K4 = c4 = t3, N4 = y4, c4 = c4 + T2 | 0, c4 = (y4 = h4 + U4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, _4 = y4, y4 ^= N4, N4 = c4, y4 = _A(y4, c4 ^ n4, 40), c4 = Q4 + (R4 = t3) | 0, c4 = S4 + ((n4 = y4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, J4 = c4 = (n4 = k4 + n4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(h4 ^ n4, c4 ^ K4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(p4 ^ Y4, W2 ^ AA2, 1), U4 = c4 = t3, Y4 = e4, c4 = c4 + B4 | 0, c4 = Z2 + ((e4 = h4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = c4 = (e4 = e4 + G4 | 0) >>> 0 < G4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ v4, 32), c4 = (CA2 = t3) + Y4 | 0, Y4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (p4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4) ^ U4, 40), c4 = X2 + (v4 = t3) | 0, c4 = G4 + ((D4 = I7 + a4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) | 0, G4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = m4 + nA2 | 0, c4 = ((h4 = u4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + P4 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ u4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ m4, 40), d4 = c4, c4 = KA2 + (u4 = t3) | 0, c4 = U4 + ((m4 = k4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + m4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = d4) + (d4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, u4 = c4 = _A(D4, c4 ^ u4, 1), tA2 = c4, m4 = D4 = t3, AA2 = w4, W2 = r4, w4 = a4, a4 = _A(K4 ^ G4, T2 ^ CA2, 48), c4 = (K4 = t3) + p4 | 0, G4 = D4 = a4 + Y4 | 0, Y4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ v4, 1), c4 = (v4 = t3) + wA2 | 0, c4 = J4 + ((D4 = w4 + fA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (p4 = t3) + s4 | 0, b4 = c4 = (s4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ v4, 40), c4 = MA2 + (CA2 = t3) | 0, J4 = w4, c4 = n4 + ((w4 = QA2 + w4 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = w4 + r4 | 0, w4 = p4, p4 = c4 = n4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ n4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, v4 = D4 = w4 + s4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = N4 + IA2 | 0, f4 = c4 = (D4 = S4 + _4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ R4, 1), c4 = (S4 = t3) + pA2 | 0, c4 = H4 + ((s4 = y4 + DA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, r4 = _A(r4 ^ (s4 = s4 + F4 | 0), (c4 = s4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ L4, 32), N4 = F4 = t3, F4 = c4, _4 = y4, c4 = N4 + Y4 | 0, c4 = (y4 = r4 + G4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, G4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = hA2 + (R4 = t3) | 0, c4 = ((S4 = y4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + F4 | 0, H4 = N4, N4 = c4 = (F4 = s4 + S4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(r4 ^ F4, H4 ^ c4, 48), IA2 = c4 = t3, s4 = c4, r4 = _A(l3 ^ x4, P4 ^ $2, 1), Y4 = c4 = t3, H4 = f4, c4 = c4 + BA2 | 0, c4 = O2 + ((f4 = r4 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, M4 = c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ f4, c4 ^ K4, 32), c4 = ($2 = t3) + H4 | 0, H4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ r4, (a4 = Y4) ^ (Y4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = NA2 + (x4 = t3) | 0, c4 = M4 + ((D4 = a4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = D4 = D4 + f4 | 0, O2 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = m4 + Q4 | 0, c4 = ((r4 = u4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ S4, c4 ^ s4, 32), c4 = (u4 = t3) + T2 | 0, s4 = _A((r4 = D4 + v4 | 0) ^ tA2, (c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ m4, 40), m4 = c4, c4 = SA2 + (L4 = t3) | 0, c4 = M4 + ((P4 = s4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + P4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = u4, u4 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = m4) + (m4 = t3) | 0, D4 = (r4 = f4 + r4 | 0) ^ s4, s4 = c4 = r4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, L4 = c4 = _A(D4, c4 ^ L4, 1), P4 = D4 = t3, AA2 = h4, W2 = w4, w4 = a4, a4 = _A(K4 ^ l3, O2 ^ $2, 48), c4 = (K4 = t3) + Y4 | 0, Y4 = D4 = a4 + H4 | 0, H4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ x4, 1), c4 = (x4 = t3) + MA2 | 0, c4 = N4 + ((D4 = w4 + QA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (h4 = D4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ W2, c4 ^ b4, 32), c4 = (N4 = t3) + k4 | 0, b4 = c4 = (k4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ k4, c4 ^ x4, 40), c4 = BA2 + ($2 = t3) | 0, x4 = w4, c4 = F4 + ((w4 = j2 + w4 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = w4 + h4 | 0, w4 = N4, N4 = c4 = F4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ F4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = w4 + k4 | 0, O2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, h4 = e4, c4 = _4 + IA2 | 0, e4 = c4 = (D4 = S4 + G4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ R4, 1), c4 = NA2 + (S4 = t3) | 0, c4 = p4 + ((k4 = y4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (k4 = k4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ k4, c4 ^ d4, 32), G4 = c4 = t3, _4 = y4, c4 = c4 + H4 | 0, c4 = (y4 = h4 + Y4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = nA2 + (Y4 = t3) | 0, c4 = n4 + ((S4 = y4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (n4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = G4, G4 = c4, S4 = _A(h4 ^ n4, k4 ^ c4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(J4 ^ v4, T2 ^ CA2, 1), H4 = c4 = t3, p4 = e4, c4 = c4 + X2 | 0, c4 = Z2 + ((e4 = I7 + h4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (e4 = e4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ K4, 32), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = sA2 + (J4 = t3) | 0, c4 = U4 + ((D4 = a4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, v4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + rA2 | 0, c4 = ((h4 = L4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + O2 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ L4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = B4 + (d4 = t3) | 0, c4 = U4 + ((P4 = k4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + P4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = r4, W2 = w4, w4 = a4, a4 = _A(K4 ^ v4, T2 ^ CA2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ J4, 1), c4 = (J4 = t3) + yA2 | 0, c4 = G4 + ((D4 = w4 + z2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (G4 = t3) + s4 | 0, b4 = c4 = (s4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ J4, 40), c4 = pA2 + (CA2 = t3) | 0, J4 = w4, c4 = n4 + ((w4 = DA2 + w4 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = w4 + r4 | 0, w4 = G4, G4 = c4 = n4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ n4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, v4 = D4 = w4 + s4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = _4 + IA2 | 0, f4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = (S4 = t3) + hA2 | 0, c4 = N4 + ((s4 = y4 + iA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (s4 = s4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ s4, c4 ^ m4, 32), N4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = r4 + H4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = wA2 + (Y4 = t3) | 0, c4 = F4 + ((S4 = y4 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, H4 = N4, N4 = c4 = (F4 = s4 + S4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(r4 ^ F4, H4 ^ c4, 48), IA2 = c4 = t3, s4 = c4, r4 = _A(l3 ^ x4, O2 ^ $2, 1), H4 = c4 = t3, p4 = f4, c4 = c4 + q4 | 0, c4 = u4 + ((f4 = r4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, M4 = c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ f4, c4 ^ K4, 32), c4 = ($2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ r4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = KA2 + (x4 = t3) | 0, c4 = M4 + ((D4 = a4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = D4 = D4 + f4 | 0, O2 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + B4 | 0, c4 = ((r4 = d4 + kA2 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ S4, c4 ^ s4, 32), c4 = (u4 = t3) + T2 | 0, s4 = _A((r4 = D4 + v4 | 0) ^ d4, (c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), m4 = c4, c4 = NA2 + (d4 = t3) | 0, c4 = M4 + ((P4 = s4 + EA2 | 0) >>> 0 < EA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + P4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = u4, u4 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = m4) + (m4 = t3) | 0, D4 = (r4 = f4 + r4 | 0) ^ s4, s4 = c4 = r4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = h4, W2 = w4, w4 = a4, a4 = _A(K4 ^ l3, O2 ^ $2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ x4, 1), c4 = (x4 = t3) + q4 | 0, c4 = N4 + ((D4 = w4 + cA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (h4 = D4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ W2, c4 ^ b4, 32), c4 = (N4 = t3) + k4 | 0, b4 = c4 = (k4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ k4, c4 ^ x4, 40), c4 = wA2 + ($2 = t3) | 0, x4 = w4, c4 = F4 + ((w4 = fA2 + w4 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = w4 + h4 | 0, w4 = N4, N4 = c4 = F4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ F4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = w4 + k4 | 0, O2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, h4 = e4, c4 = _4 + IA2 | 0, e4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = hA2 + (S4 = t3) | 0, c4 = G4 + ((k4 = y4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (k4 = k4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ k4, c4 ^ L4, 32), G4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = h4 + H4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = pA2 + (Y4 = t3) | 0, c4 = n4 + ((S4 = y4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (n4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = G4, G4 = c4, S4 = _A(h4 ^ n4, k4 ^ c4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(J4 ^ v4, T2 ^ CA2, 1), H4 = c4 = t3, p4 = e4, c4 = c4 + BA2 | 0, c4 = Z2 + ((e4 = h4 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (e4 = e4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ K4, 32), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = KA2 + (J4 = t3) | 0, c4 = U4 + ((D4 = a4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, v4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + sA2 | 0, c4 = ((h4 = d4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + O2 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ d4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = X2 + (d4 = t3) | 0, c4 = U4 + ((P4 = I7 + k4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + P4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = r4, W2 = w4, w4 = a4, a4 = _A(K4 ^ v4, T2 ^ CA2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ J4, 1), c4 = (J4 = t3) + nA2 | 0, c4 = G4 + ((D4 = w4 + oA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (G4 = t3) + s4 | 0, b4 = c4 = (s4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ J4, 40), c4 = Q4 + (CA2 = t3) | 0, J4 = w4, c4 = n4 + ((w4 = g6 + w4 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = w4 + r4 | 0, w4 = G4, G4 = c4 = n4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ n4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, v4 = D4 = w4 + s4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = _4 + IA2 | 0, f4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = (S4 = t3) + rA2 | 0, c4 = N4 + ((s4 = y4 + gA2 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (s4 = s4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ s4, c4 ^ m4, 32), N4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = r4 + H4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = MA2 + (Y4 = t3) | 0, c4 = F4 + ((S4 = y4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, H4 = N4, N4 = c4 = (F4 = s4 + S4 | 0) >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4, S4 = _A(r4 ^ F4, H4 ^ c4, 48), IA2 = c4 = t3, s4 = c4, r4 = _A(l3 ^ x4, O2 ^ $2, 1), H4 = c4 = t3, p4 = f4, c4 = c4 + SA2 | 0, c4 = u4 + ((f4 = r4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, M4 = c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ f4, c4 ^ K4, 32), c4 = ($2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ r4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = yA2 + (x4 = t3) | 0, c4 = M4 + ((D4 = a4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) | 0, l3 = D4 = D4 + f4 | 0, O2 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + KA2 | 0, c4 = ((r4 = d4 + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, M4 = c4 = (f4 = D4 + r4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(f4 ^ S4, c4 ^ s4, 32), c4 = (u4 = t3) + T2 | 0, s4 = _A((r4 = D4 + v4 | 0) ^ d4, (c4 = r4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), m4 = c4, c4 = wA2 + (d4 = t3) | 0, c4 = M4 + ((P4 = s4 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (M4 = f4 + P4 | 0) >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = u4, u4 = c4, f4 = _A(D4 ^ M4, f4 ^ c4, 48), c4 = (c4 = m4) + (m4 = t3) | 0, D4 = (r4 = f4 + r4 | 0) ^ s4, s4 = c4 = r4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = h4, W2 = w4, w4 = a4, a4 = _A(K4 ^ l3, O2 ^ $2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ x4, 1), c4 = (x4 = t3) + NA2 | 0, c4 = N4 + ((D4 = w4 + EA2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (h4 = D4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(h4 ^ W2, c4 ^ b4, 32), c4 = (N4 = t3) + k4 | 0, b4 = c4 = (k4 = D4 + AA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ k4, c4 ^ x4, 40), c4 = B4 + ($2 = t3) | 0, x4 = w4, c4 = F4 + ((w4 = kA2 + w4 | 0) >>> 0 < kA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = w4 + h4 | 0, w4 = N4, N4 = c4 = F4 >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ F4, w4 ^ c4, 48), c4 = (c4 = b4) + (b4 = t3) | 0, l3 = D4 = w4 + k4 | 0, O2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, h4 = e4, c4 = _4 + IA2 | 0, e4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = MA2 + (S4 = t3) | 0, c4 = G4 + ((k4 = y4 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (k4 = k4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(h4 ^ k4, c4 ^ L4, 32), G4 = c4 = t3, _4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = h4 + H4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, R4 = y4, y4 ^= _4, _4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = q4 + (Y4 = t3) | 0, c4 = n4 + ((S4 = y4 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (n4 = k4 + S4 | 0) >>> 0 < k4 >>> 0 ? c4 + 1 | 0 : c4, k4 = G4, G4 = c4, S4 = _A(h4 ^ n4, k4 ^ c4, 48), IA2 = c4 = t3, k4 = c4, h4 = _A(J4 ^ v4, T2 ^ CA2, 1), H4 = c4 = t3, p4 = e4, c4 = c4 + pA2 | 0, c4 = Z2 + ((e4 = h4 + DA2 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, U4 = c4 = (e4 = e4 + U4 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, K4 = _A(a4 ^ e4, c4 ^ K4, 32), c4 = (CA2 = t3) + p4 | 0, p4 = D4 = K4 + D4 | 0, a4 = _A(D4 ^ h4, (a4 = H4) ^ (H4 = D4 >>> 0 < K4 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = SA2 + (J4 = t3) | 0, c4 = U4 + ((D4 = a4 + eA2 | 0) >>> 0 < eA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, v4 = D4 = D4 + e4 | 0, T2 = c4 = D4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = c4, c4 = P4 + hA2 | 0, c4 = ((h4 = d4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + e4 | 0, U4 = c4 = (e4 = D4 + h4 | 0) >>> 0 < h4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(e4 ^ S4, c4 ^ k4, 32), c4 = (Z2 = t3) + O2 | 0, k4 = _A((h4 = D4 + l3 | 0) ^ d4, (c4 = h4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), L4 = c4, c4 = Q4 + (d4 = t3) | 0, c4 = U4 + ((P4 = k4 + g6 | 0) >>> 0 < g6 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (U4 = e4 + P4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, e4 = Z2, Z2 = c4, e4 = _A(D4 ^ U4, e4 ^ c4, 48), c4 = (c4 = L4) + (L4 = t3) | 0, D4 = (h4 = e4 + h4 | 0) ^ k4, k4 = c4 = h4 >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, d4 = c4 = _A(D4, c4 ^ d4, 1), P4 = D4 = t3, AA2 = r4, W2 = w4, w4 = a4, a4 = _A(K4 ^ v4, T2 ^ CA2, 48), c4 = (K4 = t3) + H4 | 0, H4 = D4 = a4 + p4 | 0, p4 = c4 = D4 >>> 0 < a4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ w4, c4 ^ J4, 1), c4 = (v4 = t3) + BA2 | 0, c4 = G4 + ((D4 = w4 + j2 | 0) >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4) | 0, n4 = c4 = (r4 = D4 + n4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, D4 = _A(r4 ^ W2, c4 ^ b4, 32), c4 = (G4 = t3) + s4 | 0, b4 = s4 = D4 + AA2 | 0, J4 = c4 = s4 >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ s4, c4 ^ v4, 40), c4 = sA2 + (AA2 = t3) | 0, v4 = w4, c4 = n4 + ((w4 = V2 + w4 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) | 0, s4 = w4 + r4 | 0, w4 = G4, G4 = c4 = s4 >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(D4 ^ s4, w4 ^ c4, 48), c4 = (c4 = J4) + (J4 = t3) | 0, b4 = D4 = w4 + b4 | 0, T2 = c4 = D4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = f4, c4 = _4 + IA2 | 0, f4 = c4 = (D4 = S4 + R4 | 0) >>> 0 < S4 >>> 0 ? c4 + 1 | 0 : c4, y4 = _A(D4 ^ y4, c4 ^ Y4, 1), c4 = (S4 = t3) + X2 | 0, c4 = N4 + ((n4 = I7 + y4 | 0) >>> 0 < y4 >>> 0 ? c4 + 1 | 0 : c4) | 0, F4 = c4 = (n4 = n4 + F4 | 0) >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4, N4 = r4 = _A(r4 ^ n4, c4 ^ m4, 32), _4 = c4 = t3, R4 = y4, c4 = c4 + p4 | 0, c4 = (y4 = r4 + H4 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, Y4 = y4, y4 ^= R4, R4 = c4, y4 = _A(y4, c4 ^ S4, 40), c4 = nA2 + (H4 = t3) | 0, c4 = F4 + ((r4 = y4 + oA2 | 0) >>> 0 < oA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, p4 = (r4 = r4 + n4 | 0) ^ N4, N4 = c4 = r4 >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, n4 = _A(p4, c4 ^ _4, 48), m4 = c4 = t3, S4 = c4, _4 = F4 = _A(l3 ^ x4, O2 ^ $2, 1), p4 = c4 = t3, x4 = f4, c4 = c4 + yA2 | 0, c4 = u4 + ((f4 = F4 + z2 | 0) >>> 0 < z2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (f4 = f4 + M4 | 0) >>> 0 < M4 >>> 0 ? c4 + 1 | 0 : c4, M4 = K4, K4 = c4, F4 = _A(a4 ^ f4, M4 ^ c4, 32), c4 = (W2 = t3) + x4 | 0, M4 = D4 = F4 + D4 | 0, a4 = _A(a4 = D4 ^ _4, (_4 = D4 >>> 0 < F4 >>> 0 ? c4 + 1 | 0 : c4) ^ p4, 40), c4 = rA2 + (p4 = t3) | 0, c4 = K4 + ((D4 = a4 + gA2 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, K4 = D4 = D4 + f4 | 0, x4 = c4 = D4 >>> 0 < f4 >>> 0 ? c4 + 1 | 0 : c4, f4 = c4, c4 = P4 + sA2 | 0, c4 = ((u4 = V2) >>> 0 > (V2 = d4 + V2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + f4 | 0, sA2 = c4 = (D4 = D4 + V2 | 0) >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4, V2 = _A(D4 ^ n4, c4 ^ S4, 32), c4 = (l3 = t3) + T2 | 0, S4 = _A((f4 = b4 + V2 | 0) ^ d4, (c4 = f4 >>> 0 < V2 >>> 0 ? c4 + 1 | 0 : c4) ^ P4, 40), u4 = c4, c4 = nA2 + (O2 = t3) | 0, c4 = sA2 + ((d4 = oA2) >>> 0 > (oA2 = S4 + oA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (oA2 = D4 + oA2 | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, D4 = V2 ^ oA2, V2 = c4, nA2 = _A(D4, c4 ^ l3, 48); + c4 = (sA2 = t3) + u4 | 0, f4 = c4 = (D4 = f4 + nA2 | 0) >>> 0 < nA2 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(D4 ^ S4, c4 ^ O2, 1), S4 = t3, l3 = c4, O2 = h4, h4 = gA2, u4 = rA2, rA2 = _A(F4 ^ K4, x4 ^ W2, 48), c4 = (F4 = t3) + _4 | 0, _4 = h4, M4 = c4 = (gA2 = M4 + rA2 | 0) >>> 0 < rA2 >>> 0 ? c4 + 1 | 0 : c4, h4 = _A(a4 ^ (K4 = gA2), c4 ^ p4, 1), c4 = (p4 = t3) + u4 | 0, c4 = N4 + (h4 >>> 0 > (gA2 = _4 + h4 | 0) >>> 0 ? c4 + 1 | 0 : c4) | 0, a4 = c4 = (gA2 = r4 + gA2 | 0) >>> 0 < r4 >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ gA2, c4 ^ J4, 32), c4 = (c4 = k4) + (k4 = t3) | 0, N4 = r4 = w4 + O2 | 0, _4 = c4 = r4 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, r4 = _A(r4 ^ h4, c4 ^ p4, 40), c4 = (p4 = t3) + NA2 | 0, c4 = (r4 >>> 0 > (EA2 = r4 + EA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, a4 = c4 = (a4 = EA2) >>> 0 > (EA2 = gA2 + EA2 | 0) >>> 0 ? c4 + 1 | 0 : c4, w4 = _A(w4 ^ EA2, c4 ^ k4, 48), c4 = (h4 = t3) + _4 | 0, k4 = gA2 = w4 + N4 | 0, NA2 = c4 = gA2 >>> 0 < w4 >>> 0 ? c4 + 1 | 0 : c4, N4 = I7, _4 = X2, c4 = R4 + m4 | 0, gA2 = c4 = (I7 = n4 + Y4 | 0) >>> 0 < n4 >>> 0 ? c4 + 1 | 0 : c4, X2 = _A(I7 ^ y4, c4 ^ H4, 1), c4 = (n4 = t3) + _4 | 0, c4 = G4 + ((y4 = N4 + X2 | 0) >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4) | 0, e4 = _A((y4 = y4 + s4 | 0) ^ e4, (c4 = y4 >>> 0 < s4 >>> 0 ? c4 + 1 | 0 : c4) ^ L4, 32), N4 = c4, G4 = iA2, iA2 = X2, c4 = (s4 = t3) + M4 | 0, M4 = n4, n4 = c4 = (X2 = e4 + K4 | 0) >>> 0 < e4 >>> 0 ? c4 + 1 | 0 : c4, iA2 = _A(X2 ^ iA2, M4 ^ c4, 40), c4 = (K4 = t3) + hA2 | 0, c4 = ((hA2 = G4 + iA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + N4 | 0, N4 = hA2, y4 = e4 ^ (hA2 = y4 + hA2 | 0), e4 = c4 = N4 >>> 0 > hA2 >>> 0 ? c4 + 1 | 0 : c4, c4 = _A(y4, c4 ^ s4, 48), R4 = y4 = t3, s4 = c4, M4 = j2, N4 = BA2, j2 = _A(b4 ^ v4, T2 ^ AA2, 1), _4 = c4 = t3, c4 = c4 + KA2 | 0, c4 = Z2 + ((j2 = (G4 = j2) + aA2 | 0) >>> 0 < aA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, aA2 = c4 = (j2 = U4 + j2 | 0) >>> 0 < U4 >>> 0 ? c4 + 1 | 0 : c4, BA2 = _A(j2 ^ rA2, c4 ^ F4, 32), c4 = (U4 = t3) + gA2 | 0, gA2 = I7 = BA2 + I7 | 0, rA2 = _A(I7 ^ G4, (F4 = I7 >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4) ^ _4, 40), c4 = (c4 = N4) + (N4 = t3) | 0, c4 = aA2 + ((I7 = rA2 + M4 | 0) >>> 0 < rA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, aA2 = I7 = I7 + j2 | 0, KA2 = c4 = I7 >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, j2 = c4, c4 = S4 + MA2 | 0, c4 = ((G4 = QA2) >>> 0 > (QA2 = l3 + QA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + j2 | 0, MA2 = c4 = (j2 = I7 + QA2 | 0) >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4, QA2 = _A(s4 ^ j2, c4 ^ y4, 32), c4 = (G4 = t3) + NA2 | 0, y4 = I7 = QA2 + k4 | 0, I7 = _A(I7 ^ l3, (M4 = S4) ^ (S4 = I7 >>> 0 < QA2 >>> 0 ? c4 + 1 | 0 : c4), 40), c4 = pA2 + (_4 = t3) | 0, pA2 = I7, c4 = MA2 + ((I7 = DA2 + I7 | 0) >>> 0 < DA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (I7 = I7 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, MA2 = I7, Y4 = (i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24) ^ I7, M4 = c4, H4 = c4 ^ (i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24), j2 = _A(BA2 ^ aA2, U4 ^ KA2, 48), c4 = (aA2 = t3) + F4 | 0, F4 = I7 = j2 + gA2 | 0, KA2 = c4 = I7 >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, BA2 = fA2, c4 = n4 + R4 | 0, fA2 = c4 = (I7 = s4 + X2 | 0) >>> 0 < X2 >>> 0 ? c4 + 1 | 0 : c4, iA2 = _A(I7 ^ iA2, c4 ^ K4, 1), c4 = (s4 = t3) + wA2 | 0, c4 = ((BA2 = iA2 + BA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4) + a4 | 0, BA2 = c4 = (wA2 = BA2 + EA2 | 0) >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4, gA2 = _A(wA2 ^ nA2, c4 ^ sA2, 32), c4 = (X2 = t3) + KA2 | 0, EA2 = c4 = (DA2 = gA2 + F4 | 0) >>> 0 < gA2 >>> 0 ? c4 + 1 | 0 : c4, nA2 = gA2, gA2 = _A(iA2 ^ DA2, c4 ^ s4, 40), c4 = (a4 = t3) + SA2 | 0, c4 = (gA2 >>> 0 > (iA2 = gA2 + eA2 | 0) >>> 0 ? c4 + 1 | 0 : c4) + BA2 | 0, n4 = X2, X2 = c4 = (wA2 = iA2 + wA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, iA2 = _A(nA2 ^ (eA2 = wA2), n4 ^ c4, 48), c4 = (s4 = t3) + EA2 | 0, c4 = (BA2 = iA2 + DA2 | 0) >>> 0 < iA2 >>> 0 ? c4 + 1 | 0 : c4, DA2 = BA2, BA2 ^= Y4, C3[A8 + 8 | 0] = BA2, C3[A8 + 9 | 0] = BA2 >>> 8, C3[A8 + 10 | 0] = BA2 >>> 16, C3[A8 + 11 | 0] = BA2 >>> 24, EA2 = c4, c4 ^= H4, C3[A8 + 12 | 0] = c4, C3[A8 + 13 | 0] = c4 >>> 8, C3[A8 + 14 | 0] = c4 >>> 16, C3[A8 + 15 | 0] = c4 >>> 24, wA2 = I7, BA2 = fA2, I7 = j2, j2 = _A(r4 ^ k4, p4 ^ NA2, 1), c4 = (SA2 = t3) + Q4 | 0, c4 = (j2 >>> 0 > (fA2 = j2 + g6 | 0) >>> 0 ? c4 + 1 | 0 : c4) + V2 | 0, oA2 = c4 = (k4 = fA2) >>> 0 > (fA2 = oA2 + fA2 | 0) >>> 0 ? c4 + 1 | 0 : c4, I7 = _A(I7 ^ fA2, c4 ^ aA2, 32), c4 = (c4 = BA2) + (BA2 = t3) | 0, aA2 = c4 = (wA2 = I7 + wA2 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, nA2 = I7, wA2 = _A(j2 ^ (V2 = wA2), c4 ^ SA2, 40), c4 = (r4 = t3) + B4 | 0, c4 = oA2 + ((I7 = wA2 + kA2 | 0) >>> 0 < wA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (I7 = I7 + fA2 | 0) >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4, oA2 = I7, I7 ^= nA2, nA2 = c4, fA2 = _A(I7, c4 ^ BA2, 48), c4 = (k4 = t3) + aA2 | 0, V2 = I7 = fA2 + V2 | 0, aA2 = I7 >>> 0 < fA2 >>> 0 ? c4 + 1 | 0 : c4, rA2 = I7 = _A(F4 ^ rA2, N4 ^ KA2, 1), SA2 = c4 = t3, c4 = c4 + q4 | 0, c4 = e4 + ((I7 = I7 + cA2 | 0) >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, q4 = c4 = (j2 = I7 + hA2 | 0) >>> 0 < hA2 >>> 0 ? c4 + 1 | 0 : c4, I7 = (BA2 = _A(w4 ^ j2, c4 ^ h4, 32)) + D4 | 0, c4 = (D4 = t3) + f4 | 0, hA2 = I7, I7 = (cA2 = _A(e4 = I7 ^ rA2, (rA2 = I7 >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4) ^ SA2, 40)) + z2 | 0, c4 = (z2 = t3) + yA2 | 0, c4 = q4 + (I7 >>> 0 < cA2 >>> 0 ? c4 + 1 | 0 : c4) | 0, c4 = (q4 = I7 + j2 | 0) >>> 0 < j2 >>> 0 ? c4 + 1 | 0 : c4, j2 = q4 ^ GA2 ^ V2, C3[0 | (I7 = A8)] = j2, C3[I7 + 1 | 0] = j2 >>> 8, C3[I7 + 2 | 0] = j2 >>> 16, C3[I7 + 3 | 0] = j2 >>> 24, j2 = c4 ^ E4 ^ aA2, C3[I7 + 4 | 0] = j2, C3[I7 + 5 | 0] = j2 >>> 8, C3[I7 + 6 | 0] = j2 >>> 16, C3[I7 + 7 | 0] = j2 >>> 24, j2 = (BA2 = _A(q4 ^ BA2, c4 ^ D4, 48)) + hA2 | 0, c4 = (hA2 = t3) + rA2 | 0, c4 = (rA2 = j2 >>> 0 < BA2 >>> 0 ? c4 + 1 | 0 : c4) ^ (i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24) ^ nA2, q4 = (i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24) ^ oA2 ^ j2, C3[I7 + 16 | 0] = q4, C3[I7 + 17 | 0] = q4 >>> 8, C3[I7 + 18 | 0] = q4 >>> 16, C3[I7 + 19 | 0] = q4 >>> 24, C3[I7 + 20 | 0] = c4, C3[I7 + 21 | 0] = c4 >>> 8, C3[I7 + 22 | 0] = c4 >>> 16, C3[I7 + 23 | 0] = c4 >>> 24, I7 = _A(QA2 ^ MA2, M4 ^ G4, 48), q4 = t3, oA2 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, c4 = (i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24) ^ _A(gA2 ^ DA2, a4 ^ EA2, 1) ^ I7, C3[A8 + 32 | 0] = c4, C3[A8 + 33 | 0] = c4 >>> 8, C3[A8 + 34 | 0] = c4 >>> 16, C3[A8 + 35 | 0] = c4 >>> 24, c4 = t3 ^ oA2 ^ q4, C3[A8 + 36 | 0] = c4, C3[A8 + 37 | 0] = c4 >>> 8, C3[A8 + 38 | 0] = c4 >>> 16, C3[A8 + 39 | 0] = c4 >>> 24, c4 = S4 + q4 | 0, c4 = (oA2 = I7 + y4 | 0) >>> 0 < I7 >>> 0 ? c4 + 1 | 0 : c4, gA2 = (i3[(I7 = A8) + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24) ^ X2 ^ c4, q4 = (i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24) ^ eA2 ^ oA2, C3[I7 + 24 | 0] = q4, C3[I7 + 25 | 0] = q4 >>> 8, C3[I7 + 26 | 0] = q4 >>> 16, C3[I7 + 27 | 0] = q4 >>> 24, C3[I7 + 28 | 0] = gA2, C3[I7 + 29 | 0] = gA2 >>> 8, C3[I7 + 30 | 0] = gA2 >>> 16, C3[I7 + 31 | 0] = gA2 >>> 24, gA2 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, I7 = fA2 ^ (i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24) ^ _A(j2 ^ cA2, z2 ^ rA2, 1), C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, I7 = k4 ^ t3 ^ gA2, C3[A8 + 44 | 0] = I7, C3[A8 + 45 | 0] = I7 >>> 8, C3[A8 + 46 | 0] = I7 >>> 16, C3[A8 + 47 | 0] = I7 >>> 24, j2 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24, I7 = BA2 ^ (i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24) ^ _A(V2 ^ wA2, r4 ^ aA2, 1), C3[A8 + 56 | 0] = I7, C3[A8 + 57 | 0] = I7 >>> 8, C3[A8 + 58 | 0] = I7 >>> 16, C3[A8 + 59 | 0] = I7 >>> 24, I7 = hA2 ^ t3 ^ j2, C3[A8 + 60 | 0] = I7, C3[A8 + 61 | 0] = I7 >>> 8, C3[A8 + 62 | 0] = I7 >>> 16, C3[A8 + 63 | 0] = I7 >>> 24, j2 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24, I7 = iA2 ^ (i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24) ^ _A(oA2 ^ pA2, c4 ^ _4, 1), C3[A8 + 48 | 0] = I7, C3[A8 + 49 | 0] = I7 >>> 8, C3[A8 + 50 | 0] = I7 >>> 16, C3[A8 + 51 | 0] = I7 >>> 24, I7 = s4 ^ t3 ^ j2, C3[A8 + 52 | 0] = I7, C3[A8 + 53 | 0] = I7 >>> 8, C3[A8 + 54 | 0] = I7 >>> 16, C3[A8 + 55 | 0] = I7 >>> 24; + } + function k3(A8, I7, g6, B4, Q4, o4, c4) { + var D4, a4, y4, f4, e4, w4, h4, k4, n4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, R4, L4, x4, u4, m4, q4, l3, z2, j2, X2, O2, T2, V2, $2, AA2, IA2, gA2, CA2, BA2, QA2, EA2, iA2, oA2, cA2, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, eA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, SA2 = 0, NA2 = 0, KA2 = 0, _A2 = 0, pA2 = 0, HA2 = 0, GA2 = 0, JA2 = 0, YA2 = 0, UA2 = 0, dA2 = 0, bA2 = 0, vA2 = 0, RA2 = 0, LA2 = 0, xA2 = 0, uA2 = 0, qA2 = 0, lA2 = 0, zA2 = 0, jA2 = 0, XA2 = 0, OA2 = 0, TA2 = 0, VA2 = 0, ZA2 = 0, WA2 = 0, $A2 = 0, AI2 = 0, II2 = 0, gI2 = 0, CI2 = 0, BI2 = 0, QI2 = 0; + return r3 = y4 = r3 - 560 | 0, MA(yA2 = y4 + 352 | 0), c4 && W(yA2, 35120, 34, 0), FA(y4 + 288 | 0, o4, 32, 0), W(wA2 = y4 + 352 | 0, y4 + 320 | 0, 32, 0), W(wA2, g6, B4, Q4), v3(wA2, tA2 = y4 + 224 | 0), kA2 = i3[(aA2 = o4) + 32 | 0] | i3[aA2 + 33 | 0] << 8 | i3[aA2 + 34 | 0] << 16 | i3[aA2 + 35 | 0] << 24, nA2 = i3[aA2 + 36 | 0] | i3[aA2 + 37 | 0] << 8 | i3[aA2 + 38 | 0] << 16 | i3[aA2 + 39 | 0] << 24, fA2 = i3[aA2 + 40 | 0] | i3[aA2 + 41 | 0] << 8 | i3[aA2 + 42 | 0] << 16 | i3[aA2 + 43 | 0] << 24, DA2 = i3[aA2 + 44 | 0] | i3[aA2 + 45 | 0] << 8 | i3[aA2 + 46 | 0] << 16 | i3[aA2 + 47 | 0] << 24, yA2 = i3[aA2 + 48 | 0] | i3[aA2 + 49 | 0] << 8 | i3[aA2 + 50 | 0] << 16 | i3[aA2 + 51 | 0] << 24, o4 = i3[aA2 + 52 | 0] | i3[aA2 + 53 | 0] << 8 | i3[aA2 + 54 | 0] << 16 | i3[aA2 + 55 | 0] << 24, eA2 = i3[aA2 + 60 | 0] | i3[aA2 + 61 | 0] << 8 | i3[aA2 + 62 | 0] << 16 | i3[aA2 + 63 | 0] << 24, aA2 = i3[aA2 + 56 | 0] | i3[aA2 + 57 | 0] << 8 | i3[aA2 + 58 | 0] << 16 | i3[aA2 + 59 | 0] << 24, C3[A8 + 56 | 0] = aA2, C3[A8 + 57 | 0] = aA2 >>> 8, C3[A8 + 58 | 0] = aA2 >>> 16, C3[A8 + 59 | 0] = aA2 >>> 24, C3[A8 + 60 | 0] = eA2, C3[A8 + 61 | 0] = eA2 >>> 8, C3[A8 + 62 | 0] = eA2 >>> 16, C3[A8 + 63 | 0] = eA2 >>> 24, C3[A8 + 48 | 0] = yA2, C3[A8 + 49 | 0] = yA2 >>> 8, C3[A8 + 50 | 0] = yA2 >>> 16, C3[A8 + 51 | 0] = yA2 >>> 24, C3[A8 + 52 | 0] = o4, C3[A8 + 53 | 0] = o4 >>> 8, C3[A8 + 54 | 0] = o4 >>> 16, C3[A8 + 55 | 0] = o4 >>> 24, C3[A8 + 40 | 0] = fA2, C3[A8 + 41 | 0] = fA2 >>> 8, C3[A8 + 42 | 0] = fA2 >>> 16, C3[A8 + 43 | 0] = fA2 >>> 24, C3[A8 + 44 | 0] = DA2, C3[A8 + 45 | 0] = DA2 >>> 8, C3[A8 + 46 | 0] = DA2 >>> 16, C3[A8 + 47 | 0] = DA2 >>> 24, C3[0 | (o4 = A8 + 32 | 0)] = kA2, C3[o4 + 1 | 0] = kA2 >>> 8, C3[o4 + 2 | 0] = kA2 >>> 16, C3[o4 + 3 | 0] = kA2 >>> 24, C3[o4 + 4 | 0] = nA2, C3[o4 + 5 | 0] = nA2 >>> 8, C3[o4 + 6 | 0] = nA2 >>> 16, C3[o4 + 7 | 0] = nA2 >>> 24, s3(tA2), Z(y4, tA2), mA(A8, y4), MA(wA2), c4 && W(wA2, 35120, 34, 0), W(c4 = y4 + 352 | 0, A8, 64, 0), W(c4, g6, B4, Q4), v3(c4, rA2 = y4 + 160 | 0), s3(rA2), C3[y4 + 288 | 0] = 248 & i3[y4 + 288 | 0], C3[y4 + 319 | 0] = 63 & i3[y4 + 319 | 0] | 64, g6 = i3[23 + (A8 = a4 = y4 + 288 | 0) | 0], fA2 = PA(f4 = i3[A8 + 21 | 0] | i3[A8 + 22 | 0] << 8 | g6 << 16 & 2031616, 0, e4 = (i3[rA2 + 28 | 0] | i3[rA2 + 29 | 0] << 8 | i3[rA2 + 30 | 0] << 16 | i3[rA2 + 31 | 0] << 24) >>> 7 | 0, 0), yA2 = t3, g6 = (A8 = i3[rA2 + 27 | 0]) >>> 24 | 0, Q4 = A8 << 8 | (DA2 = i3[rA2 + 23 | 0] | i3[rA2 + 24 | 0] << 8 | i3[rA2 + 25 | 0] << 16 | i3[rA2 + 26 | 0] << 24) >>> 24, A8 = PA(w4 = 2097151 & ((3 & (nA2 = (A8 = (B4 = i3[rA2 + 28 | 0]) >>> 16 | 0) | g6)) << 30 | (g6 = (B4 <<= 16) | Q4) >>> 2), 0, h4 = (c4 = i3[a4 + 23 | 0] | i3[a4 + 24 | 0] << 8 | i3[a4 + 25 | 0] << 16 | i3[a4 + 26 | 0] << 24) >>> 5 & 2097151, 0), g6 = t3 + yA2 | 0, B4 = A8 >>> 0 > (Q4 = A8 + fA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(k4 = (g6 = i3[rA2 + 23 | 0]) << 16 & 2031616 | i3[rA2 + 21 | 0] | i3[rA2 + 22 | 0] << 8, 0, n4 = (i3[a4 + 28 | 0] | i3[a4 + 29 | 0] << 8 | i3[a4 + 30 | 0] << 16 | i3[a4 + 31 | 0] << 24) >>> 7 | 0, 0), B4 = t3 + B4 | 0, yA2 = g6 = A8 + Q4 | 0, Q4 = A8 >>> 0 > g6 >>> 0 ? B4 + 1 | 0 : B4, B4 = (A8 = i3[a4 + 27 | 0]) >>> 24 | 0, c4 = A8 << 8 | c4 >>> 24, A8 = PA(F4 = 2097151 & ((3 & (B4 |= g6 = (A8 = i3[a4 + 28 | 0]) >>> 16 | 0)) << 30 | (g6 = (A8 <<= 16) | c4) >>> 2), 0, S4 = DA2 >>> 5 & 2097151, 0), g6 = t3 + Q4 | 0, aA2 = B4 = A8 + yA2 | 0, Q4 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, DA2 = PA(h4, 0, S4, 0), yA2 = t3, g6 = (A8 = i3[a4 + 19 | 0]) >>> 24 | 0, c4 = A8 << 8 | (HA2 = i3[a4 + 15 | 0] | i3[a4 + 16 | 0] << 8 | i3[a4 + 17 | 0] << 16 | i3[a4 + 18 | 0] << 24) >>> 24, B4 = g6, g6 = PA(M4 = (7 & (B4 |= g6 = (A8 = i3[a4 + 20 | 0]) >>> 16 | 0)) << 29 | (g6 = (A8 <<= 16) | c4) >>> 3, nA2 = B4 >>> 3 | 0, e4, 0), A8 = t3 + yA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, c4 = (g6 = PA(f4, 0, w4, 0)) + B4 | 0, B4 = t3 + A8 | 0, g6 = g6 >>> 0 > (DA2 = c4) >>> 0 ? B4 + 1 | 0 : B4, B4 = (A8 = i3[rA2 + 19 | 0]) >>> 24 | 0, yA2 = A8 << 8 | (KA2 = i3[rA2 + 15 | 0] | i3[rA2 + 16 | 0] << 8 | i3[rA2 + 17 | 0] << 16 | i3[rA2 + 18 | 0] << 24) >>> 24, A8 = PA(N4 = (7 & (fA2 = (A8 = (c4 = i3[rA2 + 20 | 0]) >>> 16 | 0) | B4)) << 29 | (B4 = (c4 <<= 16) | yA2) >>> 3, K4 = fA2 >>> 3 | 0, n4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(k4, 0, F4, 0), g6 = t3 + g6 | 0, kA2 = g6 = A8 >>> 0 > (tA2 = A8 + B4 | 0) >>> 0 ? g6 + 1 | 0 : g6, sA2 = A8 = g6 - ((tA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >>> 21 | 0) + Q4 | 0, DA2 = B4 = (A8 = (2097151 & A8) << 11 | (fA2 = tA2 - -1048576 | 0) >>> 21) >>> 0 > (aA2 = A8 + aA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, NA2 = A8 = B4 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, eA2 = (2097151 & A8) << 11 | (yA2 = aA2 - -1048576 | 0) >>> 21, c4 = A8 >>> 21 | 0, A8 = PA(n4, 0, S4, 0), g6 = t3, B4 = A8, A8 = PA(e4, 0, h4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, SA2 = (A8 = B4) + (B4 = PA(w4, 0, F4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > SA2 >>> 0 ? A8 + 1 | 0 : A8, wA2 = SA2 - (g6 = -2097152 & (B4 = SA2 - -1048576 | 0)) | 0, g6 = (A8 - ((131071 & (Q4 = A8 - ((SA2 >>> 0 < 4293918720) - 1 | 0) | 0)) + (g6 >>> 0 > SA2 >>> 0) | 0) | 0) + c4 | 0, m4 = g6 = (A8 = eA2 + wA2 | 0) >>> 0 < wA2 >>> 0 ? g6 + 1 | 0 : g6, q4 = A8, wA2 = PA(A8, g6, 470296, 0), eA2 = t3, g6 = PA(e4, 0, F4, 0), A8 = t3, c4 = g6, g6 = PA(w4, 0, n4, 0), A8 = t3 + A8 | 0, g6 = g6 >>> 0 > (c4 = c4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = Q4 >>> 21 | 0, Q4 = (2097151 & Q4) << 11 | B4 >>> 21, B4 = A8 + g6 | 0, UA2 = Q4 = (B4 = Q4 >>> 0 > (c4 = Q4 + c4 | 0) >>> 0 ? B4 + 1 | 0 : B4) - ((c4 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = c4 - (g6 = -2097152 & (YA2 = c4 - -1048576 | 0)) | 0, l3 = c4 = B4 - ((131071 & Q4) + (g6 >>> 0 > c4 >>> 0) | 0) | 0, z2 = g6 = aA2 - (B4 = -2097152 & yA2) | 0, j2 = Q4 = DA2 - ((B4 >>> 0 > aA2 >>> 0) + NA2 | 0) | 0, X2 = A8, B4 = PA(A8, c4, 666643, 0), A8 = t3 + eA2 | 0, A8 = B4 >>> 0 > (c4 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(g6, Q4, 654183, 0), g6 = t3 + A8 | 0, hA2 = Q4 = B4 + c4 | 0, yA2 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, SA2 = tA2 - (A8 = -2097152 & fA2) | 0, sA2 = kA2 - ((A8 >>> 0 > tA2 >>> 0) + sA2 | 0) | 0, g6 = PA(w4, 0, M4, nA2), B4 = t3, Q4 = (A8 = g6) + (g6 = PA(_4 = HA2 >>> 6 & 2097151, 0, e4, 0)) | 0, A8 = t3 + B4 | 0, A8 = g6 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(h4, 0, k4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(f4, 0, S4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(n4, 0, p4 = KA2 >>> 6 & 2097151, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(F4, 0, N4, K4), g6 = t3 + A8 | 0, tA2 = Q4 = B4 + Q4 | 0, c4 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[a4 + 14 | 0]) >>> 24 | 0, Q4 = A8 << 8 | (kA2 = i3[a4 + 10 | 0] | i3[a4 + 11 | 0] << 8 | i3[a4 + 12 | 0] << 16 | i3[a4 + 13 | 0] << 24) >>> 24, g6 = PA(H4 = 2097151 & ((1 & (g6 |= A8 = (B4 = i3[a4 + 15 | 0]) >>> 16 | 0)) << 31 | (A8 = (B4 <<= 16) | Q4) >>> 1), 0, e4, 0), A8 = t3, B4 = g6, g6 = PA(w4, 0, _4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(S4, 0, M4, nA2)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(h4, 0, N4, K4), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(f4, 0, k4, 0), g6 = t3 + g6 | 0, fA2 = B4 = A8 + Q4 | 0, Q4 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[rA2 + 14 | 0]) >>> 24 | 0, DA2 = A8 << 8 | (aA2 = i3[rA2 + 10 | 0] | i3[rA2 + 11 | 0] << 8 | i3[rA2 + 12 | 0] << 16 | i3[rA2 + 13 | 0] << 24) >>> 24, B4 = g6, g6 = (A8 = i3[rA2 + 15 | 0]) >>> 16 | 0, g6 = PA(G4 = 2097151 & ((1 & (g6 |= B4)) << 31 | (A8 = A8 << 16 | DA2) >>> 1), 0, n4, 0), A8 = t3 + Q4 | 0, A8 = g6 >>> 0 > (B4 = g6 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(F4, 0, p4, 0), A8 = t3 + A8 | 0, DA2 = A8 = g6 >>> 0 > (fA2 = g6 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, dA2 = g6 = A8 - ((fA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >>> 21 | 0) + c4 | 0, eA2 = B4 = (g6 = (2097151 & g6) << 11 | (wA2 = fA2 - -1048576 | 0) >>> 21) >>> 0 > (NA2 = g6 + tA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, GA2 = g6 = B4 - ((NA2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >>> 21 | 0) + sA2 | 0, O2 = A8 = (g6 = (B4 = (2097151 & g6) << 11 | (tA2 = NA2 - -1048576 | 0) >>> 21) + SA2 | 0) >>> 0 < B4 >>> 0 ? A8 + 1 | 0 : A8, T2 = g6, A8 = PA(g6, A8, -997805, -1), g6 = t3 + yA2 | 0, hA2 = B4 = A8 + hA2 | 0, yA2 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, SA2 = (RA2 = i3[23 + (D4 = y4 + 224 | 0) | 0] | i3[D4 + 24 | 0] << 8 | i3[D4 + 25 | 0] << 16 | i3[D4 + 26 | 0] << 24) >>> 5 & 2097151, B4 = PA(J4 = (A8 = i3[a4 + 2 | 0]) << 16 & 2031616 | i3[0 | a4] | i3[a4 + 1 | 0] << 8, 0, S4, 0), g6 = t3, Q4 = (A8 = PA(k4, 0, Y4 = (c4 = i3[a4 + 2 | 0] | i3[a4 + 3 | 0] << 8 | i3[a4 + 4 | 0] << 16 | i3[a4 + 5 | 0] << 24) >>> 5 & 2097151, 0)) + B4 | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(U4 = (i3[a4 + 7 | 0] | i3[a4 + 8 | 0] << 8 | i3[a4 + 9 | 0] << 16 | i3[a4 + 10 | 0] << 24) >>> 7 & 2097151, 0, p4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(G4, 0, d4 = kA2 >>> 4 & 2097151, 0), A8 = t3 + g6 | 0, kA2 = Q4 = B4 + Q4 | 0, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, c4 = (g6 = i3[a4 + 6 | 0]) << 8 | c4 >>> 24, B4 = A8 = g6 >>> 24 | 0, g6 = (A8 = i3[a4 + 7 | 0]) >>> 16 | 0, g6 = PA(b4 = 2097151 & ((3 & (g6 |= B4)) << 30 | (A8 = A8 << 16 | c4) >>> 2), 0, N4, K4), A8 = t3 + Q4 | 0, A8 = g6 >>> 0 > (B4 = g6 + kA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(_4, 0, P4 = (i3[rA2 + 7 | 0] | i3[rA2 + 8 | 0] << 8 | i3[rA2 + 9 | 0] << 16 | i3[rA2 + 10 | 0] << 24) >>> 7 & 2097151, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(H4, 0, JA2 = aA2 >>> 4 & 2097151, 0), A8 = t3 + B4 | 0, c4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = (g6 = i3[rA2 + 6 | 0]) >>> 24 | 0, kA2 = g6 << 8 | (aA2 = i3[rA2 + 2 | 0] | i3[rA2 + 3 | 0] << 8 | i3[rA2 + 4 | 0] << 16 | i3[rA2 + 5 | 0] << 24) >>> 24, g6 = A8, A8 = PA(M4, nA2, R4 = 2097151 & ((3 & (g6 |= B4 = (A8 = i3[rA2 + 7 | 0]) >>> 16 | 0)) << 30 | (A8 = A8 << 16 | kA2) >>> 2), 0), g6 = t3 + c4 | 0, g6 = A8 >>> 0 > (B4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = B4, B4 = PA(L4 = (A8 = i3[rA2 + 2 | 0]) << 16 & 2031616 | i3[0 | rA2] | i3[rA2 + 1 | 0] << 8, 0, h4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = Q4 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(f4, 0, x4 = aA2 >>> 5 & 2097151, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = B4, kA2 = B4 = B4 + SA2 | 0, c4 = g6 = g6 >>> 0 > B4 >>> 0 ? A8 + 1 | 0 : A8, Q4 = i3[D4 + 21 | 0] | i3[D4 + 22 | 0] << 8, A8 = PA(k4, 0, J4, 0), g6 = t3, aA2 = (B4 = A8) + (A8 = PA(N4, K4, Y4, 0)) | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > aA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(G4, 0, U4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (aA2 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(d4, 0, JA2, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, aA2 = (A8 = B4) + (B4 = PA(p4, 0, b4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > aA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(_4, 0, R4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + aA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, aA2 = (g6 = PA(H4, 0, P4, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > aA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(M4, nA2, x4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (aA2 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(f4, 0, L4, 0), g6 = t3 + g6 | 0, A8 = A8 >>> 0 > (B4 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, g6 = (g6 = B4) >>> 0 > (B4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = B4, B4 = (A8 = i3[D4 + 23 | 0]) << 16 & 2031616, A8 = g6, B4 = A8 = B4 >>> 0 > (Q4 = Q4 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, rA2 = A8 = A8 - ((Q4 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (g6 = A8 >>> 21 | 0) + c4 | 0, A8 = (g6 = (c4 = kA2 = (A8 = (2097151 & A8) << 11 | (aA2 = Q4 - -1048576 | 0) >>> 21) + kA2 | 0) >>> 0 < A8 >>> 0 ? g6 + 1 | 0 : g6) + yA2 | 0, A8 = (yA2 = c4 + hA2 | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, KA2 = c4 - -1048576 | 0, _A2 = c4 = g6 - ((c4 >>> 0 < 4293918720) - 1 | 0) | 0, pA2 = yA2 - (g6 = -2097152 & KA2) | 0, bA2 = A8 - ((g6 >>> 0 > yA2 >>> 0) + c4 | 0) | 0, kA2 = Q4, yA2 = B4, A8 = PA(z2, j2, 470296, 0), g6 = t3, B4 = A8, A8 = PA(q4, m4, 666643, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(T2, O2, 654183, 0)) | 0, A8 = t3 + g6 | 0, HA2 = Q4, c4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(N4, K4, J4, 0), A8 = t3, B4 = g6, g6 = PA(p4, 0, Y4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(U4, 0, JA2, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(d4, 0, P4, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(G4, 0, b4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(_4, 0, x4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(H4, 0, R4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(M4, nA2, L4, 0)) | 0, g6 = t3 + A8 | 0, SA2 = Q4, B4 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[D4 + 19 | 0]) >>> 24 | 0, sA2 = A8 << 8 | (hA2 = i3[D4 + 15 | 0] | i3[D4 + 16 | 0] << 8 | i3[D4 + 17 | 0] << 16 | i3[D4 + 18 | 0] << 24) >>> 24, B4 = ((vA2 = (A8 = (Q4 = i3[D4 + 20 | 0]) >>> 16 | 0) | g6) >>> 3 | 0) + B4 | 0, SA2 = Q4 = (g6 = (7 & vA2) << 29 | (g6 = (Q4 <<= 16) | sA2) >>> 3) + SA2 | 0, Q4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, sA2 = hA2 >>> 6 & 2097151, A8 = PA(p4, 0, J4, 0), g6 = t3, B4 = A8, A8 = PA(G4, 0, Y4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, hA2 = (A8 = B4) + (B4 = PA(U4, 0, P4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > hA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(d4, 0, R4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (hA2 = B4 + hA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(b4, 0, JA2, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (hA2 = B4 + hA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(_4, 0, L4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (hA2 = g6 + hA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(H4, 0, x4, 0), g6 = t3 + B4 | 0, A8 = A8 >>> 0 > (hA2 = A8 + hA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, OA2 = A8 = (xA2 = hA2 + sA2 | 0) >>> 0 < hA2 >>> 0 ? A8 + 1 | 0 : A8, II2 = A8 = A8 - ((xA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (jA2 = xA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + Q4 | 0, VA2 = A8 = B4 >>> 0 > (TA2 = B4 + SA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, gI2 = A8 = A8 - ((TA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (qA2 = TA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + c4 | 0, g6 = (B4 >>> 0 > (Q4 = B4 + HA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) + yA2 | 0, yA2 = (B4 = Q4 + kA2 | 0) - (A8 = -2097152 & aA2) | 0, rA2 = A8 = (g6 = B4 >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + rA2 | 0) | 0, CI2 = A8 = A8 - ((yA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (lA2 = yA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + bA2 | 0, Q4 = A8 = B4 >>> 0 > (c4 = B4 + pA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, AI2 = A8 = A8 - ((c4 >>> 0 < 4293918720) - 1 | 0) | 0, zA2 = (2097151 & A8) << 11 | (HA2 = c4 - -1048576 | 0) >>> 21, kA2 = A8 >> 21, vA2 = NA2 - (A8 = -2097152 & tA2) | 0, GA2 = eA2 - ((A8 >>> 0 > NA2 >>> 0) + GA2 | 0) | 0, A8 = PA(e4, 0, n4, 0), XA2 = g6 = t3, pA2 = A8, hA2 = A8 - -1048576 | 0, uA2 = g6 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, V2 = A8 = g6 >>> 21 | 0, A8 = PA(u4 = (2097151 & g6) << 11 | hA2 >>> 21, A8, -683901, -1), g6 = t3 + DA2 | 0, g6 = A8 >>> 0 > (B4 = A8 + fA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, tA2 = B4 - (A8 = -2097152 & wA2) | 0, aA2 = g6 - ((A8 >>> 0 > B4 >>> 0) + dA2 | 0) | 0, g6 = PA(S4, 0, _4, 0), A8 = t3, B4 = g6, g6 = PA(e4, 0, d4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(w4, 0, H4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, DA2 = (g6 = B4) + (B4 = PA(k4, 0, M4, nA2)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > DA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(h4, 0, p4, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(f4, 0, N4, K4), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(n4, 0, JA2, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(F4, 0, G4, 0), A8 = t3 + A8 | 0, fA2 = B4 = g6 + DA2 | 0, DA2 = g6 >>> 0 > B4 >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(w4, 0, d4, 0), g6 = t3, B4 = A8, A8 = PA(e4, 0, U4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, eA2 = (A8 = PA(k4, 0, _4, 0)) + B4 | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > eA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(S4, 0, H4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (eA2 = A8 + eA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(M4, nA2, N4, K4), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (eA2 = B4 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(h4, 0, G4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, eA2 = (g6 = B4) + (B4 = PA(f4, 0, p4, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > eA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(n4, 0, P4, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (eA2 = A8 + eA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(F4, 0, JA2, 0), g6 = t3 + B4 | 0, sA2 = g6 = A8 >>> 0 > (SA2 = A8 + eA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, WA2 = A8 = g6 - ((SA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (2097151 & A8) << 11 | (NA2 = SA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + DA2 | 0, wA2 = A8 = g6 >>> 0 > (dA2 = g6 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, LA2 = A8 = A8 - ((dA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (B4 = A8 >>> 21 | 0) + aA2 | 0, tA2 = g6 = (A8 = (2097151 & A8) << 11 | (eA2 = dA2 - -1048576 | 0) >>> 21) >>> 0 > (bA2 = A8 + tA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, ZA2 = A8 = g6 - ((bA2 >>> 0 < 4293918720) - 1 | 0) | 0, DA2 = (2097151 & A8) << 11 | (aA2 = bA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + GA2 | 0, $2 = A8 = (g6 = DA2 + vA2 | 0) >>> 0 < DA2 >>> 0 ? A8 + 1 | 0 : A8, AA2 = g6, A8 = PA(g6, A8, -683901, -1), g6 = t3 + kA2 | 0, zA2 = B4 = A8 + zA2 | 0, kA2 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(w4, 0, J4, 0), g6 = t3, B4 = A8, A8 = PA(S4, 0, Y4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, DA2 = (A8 = B4) + (B4 = PA(N4, K4, U4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(p4, 0, d4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(k4, 0, b4, 0), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(_4, 0, JA2, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(H4, 0, G4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, DA2 = (A8 = B4) + (B4 = PA(M4, nA2, P4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(h4, 0, x4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(f4, 0, R4, 0), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(F4, 0, L4, 0), g6 = t3 + A8 | 0, GA2 = DA2 = B4 + DA2 | 0, B4 = B4 >>> 0 > DA2 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[D4 + 27 | 0]) >>> 24 | 0, fA2 = A8 << 8 | RA2 >>> 24, DA2 = 2097151 & ((3 & (g6 |= A8 = (DA2 = i3[D4 + 28 | 0]) >>> 16 | 0)) << 30 | (A8 = (DA2 <<= 16) | fA2) >>> 2), g6 = B4, fA2 = A8 = DA2 + GA2 | 0, DA2 = A8 >>> 0 < DA2 >>> 0 ? g6 + 1 | 0 : g6, vA2 = PA(X2, l3, 470296, 0), GA2 = t3, A8 = (B4 = (2097151 & UA2) << 11 | YA2 >>> 21) + (pA2 - (g6 = -2097152 & hA2) | 0) | 0, g6 = XA2 - ((524287 & uA2) + (g6 >>> 0 > pA2 >>> 0) | 0) + (UA2 >>> 21) | 0, IA2 = g6 = A8 >>> 0 < B4 >>> 0 ? g6 + 1 | 0 : g6, gA2 = A8, g6 = PA(A8, g6, 666643, 0), A8 = t3 + GA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + vA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, hA2 = (g6 = PA(q4, m4, 654183, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > hA2 >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(z2, j2, -997805, -1), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (hA2 = g6 + hA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(T2, O2, 136657, 0), g6 = t3 + A8 | 0, KA2 = (A8 = (2097151 & _A2) << 11 | KA2 >>> 21) + (hA2 = B4 + hA2 | 0) | 0, g6 = (_A2 >>> 21 | 0) + (B4 >>> 0 > hA2 >>> 0 ? g6 + 1 | 0 : g6) | 0, uA2 = hA2 = DA2 - ((fA2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 >>> 0 > KA2 >>> 0 ? g6 + 1 | 0 : g6) + DA2 | 0, g6 = (DA2 = fA2 + KA2 | 0) - (B4 = -2097152 & (XA2 = fA2 - -1048576 | 0)) | 0, B4 = (A8 = (A8 = DA2 >>> 0 < KA2 >>> 0 ? A8 + 1 | 0 : A8) - ((B4 >>> 0 > DA2 >>> 0) + hA2 | 0) | 0) + kA2 | 0, vA2 = DA2 = A8 - ((g6 >>> 0 < 4293918720) - 1 | 0) | 0, pA2 = (B4 = (fA2 = g6 + zA2 | 0) >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4) - (((g6 = -2097152 & (GA2 = g6 - -1048576 | 0)) >>> 0 > fA2 >>> 0) + DA2 | 0) | 0, RA2 = A8 = fA2 - g6 | 0, DA2 = c4, c4 = Q4, $A2 = bA2 - (A8 = -2097152 & aA2) | 0, hA2 = tA2 - ((A8 >>> 0 > bA2 >>> 0) + ZA2 | 0) | 0, A8 = PA(gA2, IA2, -683901, -1), g6 = t3, Q4 = (B4 = A8) + (A8 = PA(u4, V2, 136657, 0)) | 0, B4 = t3 + g6 | 0, g6 = wA2 + (A8 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4) | 0, eA2 = (B4 = Q4 + dA2 | 0) - (A8 = -2097152 & eA2) | 0, tA2 = (g6 = B4 >>> 0 < dA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + LA2 | 0) | 0, g6 = PA(u4, V2, -997805, -1), A8 = t3 + sA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + SA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(gA2, IA2, 136657, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(X2, l3, -683901, -1), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, aA2 = Q4 - (A8 = -2097152 & NA2) | 0, kA2 = g6 - ((A8 >>> 0 > Q4 >>> 0) + WA2 | 0) | 0, g6 = PA(S4, 0, d4, 0), A8 = t3, B4 = g6, g6 = PA(w4, 0, U4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(e4, 0, b4, 0)) + B4 | 0, B4 = t3 + A8 | 0, B4 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(N4, K4, _4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(k4, 0, H4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(M4, nA2, p4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(h4, 0, JA2, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(f4, 0, G4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(n4, 0, R4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(F4, 0, P4, 0), A8 = t3 + g6 | 0, fA2 = Q4 = B4 + Q4 | 0, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(S4, 0, U4, 0), g6 = t3, B4 = A8, A8 = PA(e4, 0, Y4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, wA2 = (A8 = B4) + (B4 = PA(k4, 0, d4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > wA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(w4, 0, b4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (wA2 = g6 + wA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(_4, 0, p4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (wA2 = A8 + wA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(N4, K4, H4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (wA2 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(M4, nA2, G4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (wA2 = B4 + wA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(h4, 0, P4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (wA2 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(f4, 0, JA2, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (wA2 = g6 + wA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, wA2 = (A8 = PA(n4, 0, x4, 0)) + wA2 | 0, g6 = t3 + B4 | 0, B4 = PA(F4, 0, R4, 0), A8 = t3 + (A8 >>> 0 > wA2 >>> 0 ? g6 + 1 | 0 : g6) | 0, bA2 = A8 = B4 >>> 0 > (ZA2 = B4 + wA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, BA2 = A8 = A8 - ((ZA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (UA2 = ZA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + Q4 | 0, YA2 = A8 = B4 >>> 0 > (zA2 = B4 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, QA2 = A8 = A8 - ((zA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (_A2 = zA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + kA2 | 0, KA2 = A8 = B4 >>> 0 > (dA2 = B4 + aA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, EA2 = A8 = A8 - ((dA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (sA2 = dA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + tA2 | 0, Q4 = A8 = B4 >>> 0 > (aA2 = B4 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, tA2 = A8 = A8 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, kA2 = (2097151 & A8) << 11 | (B4 = aA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + hA2 | 0, WA2 = A8 = (fA2 = kA2 + $A2 | 0) >>> 0 < kA2 >>> 0 ? A8 + 1 | 0 : A8, LA2 = fA2, A8 = PA(fA2, A8, -683901, -1), g6 = t3, fA2 = A8, A8 = PA(AA2, $2, 136657, 0), g6 = t3 + g6 | 0, A8 = (A8 >>> 0 > (fA2 = fA2 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6) + c4 | 0, BI2 = (c4 = DA2 + fA2 | 0) - (g6 = -2097152 & HA2) | 0, QI2 = (A8 = c4 >>> 0 < fA2 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 > c4 >>> 0) + AI2 | 0) | 0, kA2 = yA2, fA2 = rA2, yA2 = PA(LA2, WA2, 136657, 0), c4 = t3, $A2 = A8 = aA2 - (g6 = -2097152 & B4) | 0, CA2 = Q4 = Q4 - ((g6 >>> 0 > aA2 >>> 0) + tA2 | 0) | 0, B4 = PA(AA2, $2, -997805, -1), g6 = t3 + c4 | 0, g6 = B4 >>> 0 > (yA2 = B4 + yA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(A8, Q4, -683901, -1), A8 = t3 + g6 | 0, AI2 = Q4 = B4 + yA2 | 0, DA2 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(T2, O2, 470296, 0), g6 = t3, Q4 = (B4 = A8) + (A8 = PA(z2, j2, 666643, 0)) | 0, B4 = t3 + g6 | 0, g6 = VA2 + (A8 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4) | 0, HA2 = A8 = Q4 + TA2 | 0, c4 = g6 = A8 >>> 0 < TA2 >>> 0 ? g6 + 1 | 0 : g6, g6 = PA(T2, O2, 666643, 0), A8 = t3 + OA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + xA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, eA2 = B4 - (g6 = -2097152 & jA2) | 0, SA2 = A8 - ((g6 >>> 0 > B4 >>> 0) + II2 | 0) | 0, g6 = PA(G4, 0, J4, 0), A8 = t3, B4 = g6, g6 = PA(Y4, 0, JA2, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(U4, 0, R4, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(d4, 0, x4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (Q4 = B4 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(b4, 0, P4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(H4, 0, L4, 0), g6 = t3 + B4 | 0, aA2 = Q4 = A8 + Q4 | 0, Q4 = A8 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, g6 = (A8 = i3[D4 + 14 | 0]) >>> 24 | 0, yA2 = A8 << 8 | (tA2 = i3[D4 + 10 | 0] | i3[D4 + 11 | 0] << 8 | i3[D4 + 12 | 0] << 16 | i3[D4 + 13 | 0] << 24) >>> 24, g6 = 2097151 & ((1 & (g6 |= B4 = (A8 = i3[D4 + 15 | 0]) >>> 16 | 0)) << 31 | (A8 = yA2 | A8 << 16) >>> 1), A8 = Q4, aA2 = B4 = g6 + aA2 | 0, Q4 = g6 >>> 0 > B4 >>> 0 ? A8 + 1 | 0 : A8, yA2 = tA2 >>> 4 & 2097151, A8 = PA(J4, 0, JA2, 0), g6 = t3, B4 = A8, A8 = PA(Y4, 0, P4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(U4, 0, x4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + B4 | 0) >>> 0 ? g6 + 1 | 0 : g6, tA2 = (A8 = B4) + (B4 = PA(d4, 0, L4, 0)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > tA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(b4, 0, R4, 0), B4 = t3 + A8 | 0, A8 = g6 >>> 0 > (tA2 = g6 + tA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, rA2 = A8 = (jA2 = yA2 + tA2 | 0) >>> 0 < tA2 >>> 0 ? A8 + 1 | 0 : A8, iA2 = A8 = A8 - ((jA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (B4 = A8 >>> 21 | 0) + Q4 | 0, NA2 = g6 = (A8 = (2097151 & A8) << 11 | (hA2 = jA2 - -1048576 | 0) >>> 21) >>> 0 > (VA2 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, oA2 = A8 = g6 - ((VA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (2097151 & A8) << 11 | (wA2 = VA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + SA2 | 0, tA2 = A8 = g6 >>> 0 > (eA2 = g6 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, cA2 = A8 = A8 - ((eA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (B4 = A8 >> 21) + c4 | 0, II2 = g6 = (g6 = (A8 = (2097151 & A8) << 11 | (aA2 = eA2 - -1048576 | 0) >>> 21) >>> 0 > (Q4 = A8 + HA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) - (((B4 = -2097152 & qA2) >>> 0 > Q4 >>> 0) + gI2 | 0) | 0, qA2 = A8 = Q4 - B4 | 0, yA2 = A8 - -1048576 | 0, gI2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >> 21) + DA2 | 0, g6 = ((A8 = (2097151 & A8) << 11 | yA2 >>> 21) >>> 0 > (Q4 = A8 + AI2 | 0) >>> 0 ? B4 + 1 | 0 : B4) + fA2 | 0, xA2 = g6 = (g6 = (A8 = Q4) >>> 0 > (Q4 = Q4 + kA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) - (((B4 = -2097152 & lA2) >>> 0 > Q4 >>> 0) + CI2 | 0) | 0, fA2 = A8 = Q4 - B4 | 0, c4 = A8 - -1048576 | 0, OA2 = A8 = g6 - ((A8 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >> 21) + QI2 | 0, lA2 = A8 = (B4 = (A8 = (2097151 & A8) << 11 | c4 >>> 21) >>> 0 > (DA2 = A8 + BI2 | 0) >>> 0 ? B4 + 1 | 0 : B4) - ((DA2 >>> 0 < 4293918720) - 1 | 0) | 0, HA2 = RA2 - -1048576 | 0, SA2 = pA2 - ((RA2 >>> 0 < 4293918720) - 1 | 0) | 0, kA2 = (2097151 & A8) << 11 | (Q4 = DA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + pA2 | 0, CI2 = (RA2 = kA2 + RA2 | 0) - (g6 = -2097152 & HA2) | 0, BI2 = (kA2 >>> 0 > RA2 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 > RA2 >>> 0) + SA2 | 0) | 0, QI2 = DA2 - (A8 = -2097152 & Q4) | 0, AI2 = B4 - ((A8 >>> 0 > DA2 >>> 0) + lA2 | 0) | 0, TA2 = fA2 - (A8 = -2097152 & c4) | 0, RA2 = xA2 - ((A8 >>> 0 > fA2 >>> 0) + OA2 | 0) | 0, A8 = PA(LA2, WA2, -997805, -1), g6 = t3, B4 = A8, A8 = PA(AA2, $2, 654183, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA($A2, CA2, 136657, 0)) | 0, A8 = t3 + g6 | 0, g6 = II2 + (B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8) | 0, xA2 = (B4 = Q4 + qA2 | 0) - (A8 = -2097152 & yA2) | 0, OA2 = (g6 = B4 >>> 0 < qA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + gI2 | 0) | 0, qA2 = dA2 - (A8 = -2097152 & sA2) | 0, pA2 = KA2 - ((A8 >>> 0 > dA2 >>> 0) + EA2 | 0) | 0, g6 = PA(gA2, IA2, -997805, -1), A8 = t3, B4 = g6, g6 = PA(u4, V2, 654183, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(X2, l3, 136657, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(q4, m4, -683901, -1), B4 = t3 + g6 | 0, g6 = YA2 + (A8 >>> 0 > (Q4 = A8 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4) | 0, sA2 = (B4 = Q4 + zA2 | 0) - (A8 = -2097152 & _A2) | 0, KA2 = (g6 = B4 >>> 0 < zA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > B4 >>> 0) + QA2 | 0) | 0, g6 = PA(gA2, IA2, 654183, 0), A8 = t3, B4 = g6, g6 = PA(u4, V2, 470296, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(X2, l3, -997805, -1)) + B4 | 0, B4 = t3 + A8 | 0, g6 = bA2 + (g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4) | 0, g6 = (A8 = Q4 + ZA2 | 0) >>> 0 < ZA2 >>> 0 ? g6 + 1 | 0 : g6, B4 = A8, A8 = PA(q4, m4, 136657, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(z2, j2, -683901, -1)) | 0, A8 = t3 + g6 | 0, yA2 = Q4 - (g6 = -2097152 & UA2) | 0, c4 = (B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8) - ((g6 >>> 0 > Q4 >>> 0) + BA2 | 0) | 0, Q4 = (i3[D4 + 28 | 0] | i3[D4 + 29 | 0] << 8 | i3[D4 + 30 | 0] << 16 | i3[D4 + 31 | 0] << 24) >>> 7 | 0, A8 = PA(e4, 0, J4, 0), g6 = t3, DA2 = (B4 = A8) + (A8 = PA(w4, 0, Y4, 0)) | 0, B4 = t3 + g6 | 0, B4 = A8 >>> 0 > DA2 >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(k4, 0, U4, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(N4, K4, d4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(S4, 0, b4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(_4, 0, G4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(p4, 0, H4, 0), B4 = t3 + A8 | 0, B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, A8 = PA(M4, nA2, JA2, 0), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(h4, 0, R4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(f4, 0, P4, 0), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(n4, 0, L4, 0), A8 = t3 + g6 | 0, A8 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(F4, 0, x4, 0), B4 = t3 + A8 | 0, g6 = B4 = g6 >>> 0 > (DA2 = g6 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, YA2 = (B4 = (2097151 & uA2) << 11 | XA2 >>> 21) + (A8 = Q4 + DA2 | 0) | 0, A8 = (uA2 >>> 21 | 0) + (g6 = A8 >>> 0 < DA2 >>> 0 ? g6 + 1 | 0 : g6) | 0, kA2 = A8 = B4 >>> 0 > YA2 >>> 0 ? A8 + 1 | 0 : A8, lA2 = g6 = A8 - ((YA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >>> 21 | 0) + c4 | 0, fA2 = B4 = (g6 = (2097151 & g6) << 11 | (nA2 = YA2 - -1048576 | 0) >>> 21) >>> 0 > (_A2 = g6 + yA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, XA2 = g6 = B4 - ((_A2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >> 21) + KA2 | 0, yA2 = A8 = (g6 = (2097151 & g6) << 11 | (DA2 = _A2 - -1048576 | 0) >>> 21) >>> 0 > (sA2 = g6 + sA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, UA2 = g6 = A8 - ((sA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >> 21) + pA2 | 0, uA2 = B4 = (g6 = (Q4 = (2097151 & g6) << 11 | (c4 = sA2 - -1048576 | 0) >>> 21) + qA2 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, pA2 = g6, A8 = PA(g6, B4, -683901, -1), g6 = t3 + OA2 | 0, KA2 = B4 = A8 + xA2 | 0, Q4 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, g6 = PA(AA2, $2, 470296, 0), A8 = t3 + tA2 | 0, A8 = g6 >>> 0 > (eA2 = g6 + eA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(LA2, WA2, 654183, 0), A8 = t3 + (A8 - (((B4 = -2097152 & aA2) >>> 0 > eA2 >>> 0) + cA2 | 0) | 0) | 0, A8 = g6 >>> 0 > (aA2 = g6 + (eA2 - B4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA($A2, CA2, -997805, -1), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (aA2 = B4 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, bA2 = B4 = sA2 - (A8 = -2097152 & c4) | 0, JA2 = yA2 = yA2 - ((A8 >>> 0 > sA2 >>> 0) + UA2 | 0) | 0, aA2 = (c4 = PA(pA2, uA2, 136657, 0)) + aA2 | 0, A8 = t3 + g6 | 0, B4 = PA(B4, yA2, -683901, -1), g6 = t3 + (c4 >>> 0 > aA2 >>> 0 ? A8 + 1 | 0 : A8) | 0, yA2 = g6 = B4 >>> 0 > (tA2 = B4 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, UA2 = A8 = g6 - ((tA2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = (2097151 & A8) << 11 | (c4 = tA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + Q4 | 0, sA2 = g6 = (A8 = g6 >>> 0 > (aA2 = g6 + KA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, eA2 = (2097151 & g6) << 11 | (Q4 = aA2 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + RA2 | 0, TA2 = KA2 = eA2 + TA2 | 0, KA2 = eA2 >>> 0 > KA2 >>> 0 ? g6 + 1 | 0 : g6, RA2 = aA2 - (g6 = -2097152 & Q4) | 0, ZA2 = A8 - ((g6 >>> 0 > aA2 >>> 0) + sA2 | 0) | 0, xA2 = tA2 - (A8 = -2097152 & c4) | 0, OA2 = yA2 - ((A8 >>> 0 > tA2 >>> 0) + UA2 | 0) | 0, A8 = PA(AA2, $2, 666643, 0), B4 = NA2 + t3 | 0, B4 = (c4 = A8 + VA2 | 0) >>> 0 < VA2 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (A8 = PA(LA2, WA2, 470296, 0)) + (c4 - (g6 = -2097152 & wA2) | 0) | 0, g6 = t3 + (B4 - ((g6 >>> 0 > c4 >>> 0) + oA2 | 0) | 0) | 0, g6 = A8 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, B4 = PA($A2, CA2, 654183, 0), A8 = t3 + g6 | 0, aA2 = Q4 = B4 + Q4 | 0, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, c4 = _A2 - (A8 = -2097152 & DA2) | 0, yA2 = fA2 - ((A8 >>> 0 > _A2 >>> 0) + XA2 | 0) | 0, A8 = PA(gA2, IA2, 470296, 0), g6 = t3, B4 = A8, A8 = PA(u4, V2, 666643, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(X2, l3, 654183, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + B4 | 0) >>> 0 ? g6 + 1 | 0 : g6, DA2 = (A8 = B4) + (B4 = PA(q4, m4, -997805, -1)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(z2, j2, 136657, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + DA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, DA2 = (g6 = PA(T2, O2, -683901, -1)) + B4 | 0, B4 = t3 + A8 | 0, g6 = kA2 + (g6 >>> 0 > DA2 >>> 0 ? B4 + 1 | 0 : B4) | 0, _A2 = (B4 = (2097151 & vA2) << 11 | GA2 >>> 21) + ((DA2 = DA2 + YA2 | 0) - (A8 = -2097152 & nA2) | 0) | 0, A8 = ((g6 = DA2 >>> 0 < YA2 >>> 0 ? g6 + 1 | 0 : g6) - ((A8 >>> 0 > DA2 >>> 0) + lA2 | 0) | 0) + (vA2 >> 21) | 0, sA2 = A8 = B4 >>> 0 > _A2 >>> 0 ? A8 + 1 | 0 : A8, qA2 = A8 = A8 - ((_A2 >>> 0 < 4293918720) - 1 | 0) | 0, g6 = c4, c4 = (2097151 & A8) << 11 | (wA2 = _A2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + yA2 | 0, UA2 = A8 = (B4 = g6 + c4 | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, YA2 = B4, A8 = PA(B4, A8, -683901, -1), g6 = t3 + Q4 | 0, g6 = A8 >>> 0 > (B4 = A8 + aA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(pA2, uA2, -997805, -1)) | 0, A8 = t3 + g6 | 0, A8 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(bA2, JA2, 136657, 0), B4 = t3 + A8 | 0, GA2 = Q4 = g6 + Q4 | 0, fA2 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, aA2 = jA2 - (A8 = -2097152 & hA2) | 0, kA2 = rA2 - ((A8 >>> 0 > jA2 >>> 0) + iA2 | 0) | 0, g6 = PA(J4, 0, P4, 0), A8 = t3, B4 = g6, g6 = PA(Y4, 0, R4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = B4 + g6 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(U4, 0, L4, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + B4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = PA(b4, 0, x4, 0)) + B4 | 0, B4 = t3 + A8 | 0, g6 = g6 >>> 0 > Q4 >>> 0 ? B4 + 1 | 0 : B4, nA2 = B4 = (A8 = (i3[D4 + 7 | 0] | i3[D4 + 8 | 0] << 8 | i3[D4 + 9 | 0] << 16 | i3[D4 + 10 | 0] << 24) >>> 7 & 2097151) + Q4 | 0, DA2 = A8 >>> 0 > B4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(J4, 0, R4, 0), g6 = t3, B4 = A8, A8 = PA(Y4, 0, x4, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = B4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, Q4 = (A8 = B4) + (B4 = PA(b4, 0, L4, 0)) | 0, A8 = t3 + g6 | 0, yA2 = Q4, Q4 = B4 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, A8 = (g6 = i3[D4 + 6 | 0]) >>> 24 | 0, c4 = g6 << 8 | (lA2 = i3[D4 + 2 | 0] | i3[D4 + 3 | 0] << 8 | i3[D4 + 4 | 0] << 16 | i3[D4 + 5 | 0] << 24) >>> 24, B4 = A8, g6 = (A8 = i3[D4 + 7 | 0]) >>> 16 | 0, g6 |= B4, B4 = Q4, c4 = B4 = (A8 = 2097151 & ((3 & g6) << 30 | (A8 = A8 << 16 | c4) >>> 2)) >>> 0 > (yA2 = A8 + yA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, zA2 = A8 = B4 - ((yA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (NA2 = yA2 - -1048576 | 0) >>> 21, A8 = (A8 >>> 21 | 0) + DA2 | 0, eA2 = A8 = B4 >>> 0 > (rA2 = B4 + nA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, XA2 = A8 = A8 - ((rA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (g6 = A8 >>> 21 | 0) + kA2 | 0, B4 = (A8 = (2097151 & A8) << 11 | (tA2 = rA2 - -1048576 | 0) >>> 21) >>> 0 > (Q4 = A8 + aA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(LA2, WA2, 666643, 0), A8 = t3 + B4 | 0, A8 = g6 >>> 0 > (Q4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA($A2, CA2, 470296, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + Q4 | 0) >>> 0 ? A8 + 1 | 0 : A8, Q4 = (g6 = B4) + (B4 = PA(YA2, UA2, 136657, 0)) | 0, g6 = t3 + A8 | 0, g6 = B4 >>> 0 > Q4 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(pA2, uA2, 654183, 0), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, aA2 = (A8 = PA(bA2, JA2, -997805, -1)) + B4 | 0, B4 = t3 + g6 | 0, kA2 = B4 = A8 >>> 0 > aA2 >>> 0 ? B4 + 1 | 0 : B4, vA2 = A8 = B4 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & A8) << 11 | (nA2 = aA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + fA2 | 0, GA2 = B4 = (A8 = B4 >>> 0 > (Q4 = B4 + GA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) - ((Q4 >>> 0 < 4293918720) - 1 | 0) | 0, DA2 = (2097151 & B4) << 11 | (fA2 = Q4 - -1048576 | 0) >>> 21, B4 = (B4 >> 21) + OA2 | 0, dA2 = hA2 = DA2 + xA2 | 0, hA2 = DA2 >>> 0 > hA2 >>> 0 ? B4 + 1 | 0 : B4, DA2 = Q4, g6 = A8, Q4 = (_A2 - (A8 = -2097152 & wA2) | 0) + (wA2 = (2097151 & SA2) << 11 | HA2 >>> 21) | 0, A8 = (sA2 - ((A8 >>> 0 > _A2 >>> 0) + qA2 | 0) | 0) + (SA2 >> 21) | 0, SA2 = A8 = Q4 >>> 0 < wA2 >>> 0 ? A8 + 1 | 0 : A8, xA2 = A8 = A8 - ((Q4 >>> 0 < 4293918720) - 1 | 0) | 0, _A2 = B4 = A8 >> 21, A8 = PA(LA2 = (2097151 & A8) << 11 | (sA2 = Q4 - -1048576 | 0) >>> 21, B4, -683901, -1), g6 = t3 + g6 | 0, g6 = A8 >>> 0 > (B4 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, OA2 = B4 - (A8 = -2097152 & fA2) | 0, jA2 = g6 - ((A8 >>> 0 > B4 >>> 0) + GA2 | 0) | 0, g6 = PA(LA2, _A2, 136657, 0), A8 = t3 + kA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + aA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, VA2 = B4 - (g6 = -2097152 & nA2) | 0, vA2 = A8 - ((g6 >>> 0 > B4 >>> 0) + vA2 | 0) | 0, g6 = PA($A2, CA2, 666643, 0), A8 = t3 + (eA2 - (((B4 = -2097152 & tA2) >>> 0 > rA2 >>> 0) + XA2 | 0) | 0) | 0, A8 = g6 >>> 0 > (DA2 = g6 + (rA2 - B4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, B4 = PA(YA2, UA2, -997805, -1), g6 = t3 + A8 | 0, g6 = B4 >>> 0 > (DA2 = B4 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(pA2, uA2, 470296, 0), B4 = t3 + g6 | 0, B4 = A8 >>> 0 > (DA2 = A8 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(bA2, JA2, 654183, 0), A8 = t3 + B4 | 0, GA2 = DA2 = g6 + DA2 | 0, kA2 = g6 >>> 0 > DA2 >>> 0 ? A8 + 1 | 0 : A8, B4 = lA2 >>> 5 & 2097151, A8 = PA(J4, 0, x4, 0), g6 = t3, fA2 = A8, A8 = PA(Y4, 0, L4, 0), g6 = t3 + g6 | 0, A8 = A8 >>> 0 > (DA2 = fA2 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, fA2 = g6 = B4 + DA2 | 0, B4 = A8 = g6 >>> 0 < DA2 >>> 0 ? A8 + 1 | 0 : A8, rA2 = (g6 = PA(J4, 0, L4, 0)) + (A8 = (A8 = i3[D4 + 2 | 0]) << 16 & 2031616 | i3[0 | D4] | i3[D4 + 1 | 0] << 8) | 0, g6 = t3, wA2 = g6 = A8 >>> 0 > rA2 >>> 0 ? g6 + 1 | 0 : g6, qA2 = g6 = g6 - ((rA2 >>> 0 < 4293918720) - 1 | 0) | 0, A8 = (A8 = g6 >>> 21 | 0) + B4 | 0, tA2 = A8 = (g6 = (2097151 & g6) << 11 | (eA2 = rA2 - -1048576 | 0) >>> 21) >>> 0 > (HA2 = g6 + fA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, lA2 = g6 = A8 - ((HA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (2097151 & g6) << 11 | (aA2 = HA2 - -1048576 | 0) >>> 21, g6 = (g6 >>> 21 | 0) + c4 | 0, g6 = B4 >>> 0 > (DA2 = B4 + yA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, B4 = PA(YA2, UA2, 654183, 0), A8 = t3 + (g6 - (((c4 = -2097152 & NA2) >>> 0 > DA2 >>> 0) + zA2 | 0) | 0) | 0, A8 = B4 >>> 0 > (yA2 = B4 + (DA2 - c4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(pA2, uA2, 666643, 0), A8 = t3 + A8 | 0, A8 = g6 >>> 0 > (B4 = g6 + yA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, nA2 = (g6 = B4) + (B4 = PA(bA2, JA2, 470296, 0)) | 0, g6 = t3 + A8 | 0, fA2 = g6 = B4 >>> 0 > nA2 >>> 0 ? g6 + 1 | 0 : g6, XA2 = g6 = g6 - ((nA2 >>> 0 < 4293918720) - 1 | 0) | 0, B4 = (A8 = g6 >> 21) + kA2 | 0, NA2 = g6 = (B4 = (g6 = (2097151 & g6) << 11 | (DA2 = nA2 - -1048576 | 0) >>> 21) >>> 0 > (yA2 = g6 + GA2 | 0) >>> 0 ? B4 + 1 | 0 : B4) - ((yA2 >>> 0 < 4293918720) - 1 | 0) | 0, kA2 = (2097151 & g6) << 11 | (c4 = yA2 - -1048576 | 0) >>> 21, g6 = (g6 >> 21) + vA2 | 0, uA2 = pA2 = kA2 + VA2 | 0, kA2 = kA2 >>> 0 > pA2 >>> 0 ? g6 + 1 | 0 : g6, A8 = PA(LA2, _A2, -997805, -1), g6 = t3 + B4 | 0, g6 = A8 >>> 0 > (yA2 = A8 + yA2 | 0) >>> 0 ? g6 + 1 | 0 : g6, vA2 = yA2 - (A8 = -2097152 & c4) | 0, GA2 = g6 - ((A8 >>> 0 > yA2 >>> 0) + NA2 | 0) | 0, g6 = PA(LA2, _A2, 654183, 0), A8 = t3 + fA2 | 0, A8 = g6 >>> 0 > (B4 = g6 + nA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, pA2 = B4 - (g6 = -2097152 & DA2) | 0, NA2 = A8 - ((g6 >>> 0 > B4 >>> 0) + XA2 | 0) | 0, A8 = PA(YA2, UA2, 470296, 0), B4 = t3 + (tA2 - (((g6 = -2097152 & aA2) >>> 0 > HA2 >>> 0) + lA2 | 0) | 0) | 0, B4 = A8 >>> 0 > (c4 = A8 + (HA2 - g6 | 0) | 0) >>> 0 ? B4 + 1 | 0 : B4, g6 = PA(bA2, JA2, 666643, 0), A8 = t3 + B4 | 0, yA2 = c4 = g6 + c4 | 0, B4 = g6 >>> 0 > c4 >>> 0 ? A8 + 1 | 0 : A8, g6 = PA(YA2, UA2, 666643, 0), A8 = t3 + (wA2 - ((4095 & qA2) + ((c4 = -2097152 & eA2) >>> 0 > rA2 >>> 0) | 0) | 0) | 0, nA2 = A8 = g6 >>> 0 > (aA2 = g6 + (rA2 - c4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8, wA2 = A8 = A8 - ((aA2 >>> 0 < 4293918720) - 1 | 0) | 0, c4 = (2097151 & A8) << 11 | (fA2 = aA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + B4 | 0, B4 = A8 = c4 >>> 0 > (DA2 = c4 + yA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, eA2 = A8 = A8 - ((DA2 >>> 0 < 4293918720) - 1 | 0) | 0, c4 = (2097151 & A8) << 11 | (yA2 = DA2 - -1048576 | 0) >>> 21, A8 = (A8 >> 21) + NA2 | 0, c4 = c4 >>> 0 > (tA2 = c4 + pA2 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = PA(LA2, _A2, 470296, 0), B4 = t3 + B4 | 0, B4 = A8 >>> 0 > (g6 = A8 + DA2 | 0) >>> 0 ? B4 + 1 | 0 : B4, DA2 = g6 - (A8 = -2097152 & yA2) | 0, yA2 = B4 - ((A8 >>> 0 > g6 >>> 0) + eA2 | 0) | 0, g6 = PA(LA2, _A2, 666643, 0), A8 = t3 + (nA2 - (((B4 = -2097152 & fA2) >>> 0 > aA2 >>> 0) + wA2 | 0) | 0) | 0, g6 = (B4 = (A8 = g6 >>> 0 > (NA2 = g6 + (aA2 - B4 | 0) | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + yA2 | 0, A8 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | NA2 >>> 21) >>> 0 > (wA2 = A8 + DA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + c4 | 0, g6 = (g6 = (A8 = (g6 = (2097151 & g6) << 11 | wA2 >>> 21) >>> 0 > (eA2 = g6 + tA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + GA2 | 0, B4 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | eA2 >>> 21) >>> 0 > (c4 = A8 + vA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + kA2 | 0, A8 = (g6 = (B4 = (g6 = (2097151 & g6) << 11 | c4 >>> 21) >>> 0 > (tA2 = g6 + uA2 | 0) >>> 0 ? B4 + 1 | 0 : B4) >> 21) + jA2 | 0, g6 = (B4 = (A8 = (B4 = (2097151 & B4) << 11 | tA2 >>> 21) >>> 0 > (aA2 = B4 + OA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + hA2 | 0, A8 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | aA2 >>> 21) >>> 0 > (kA2 = A8 + dA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + ZA2 | 0, g6 = (g6 = (A8 = (g6 = (2097151 & g6) << 11 | kA2 >>> 21) >>> 0 > (nA2 = g6 + RA2 | 0) >>> 0 ? A8 + 1 | 0 : A8) >> 21) + KA2 | 0, B4 = (A8 = (g6 = (A8 = (2097151 & A8) << 11 | nA2 >>> 21) >>> 0 > (fA2 = A8 + TA2 | 0) >>> 0 ? g6 + 1 | 0 : g6) >> 21) + AI2 | 0, A8 = (g6 = (B4 = (g6 = (2097151 & g6) << 11 | fA2 >>> 21) >>> 0 > (DA2 = g6 + QI2 | 0) >>> 0 ? B4 + 1 | 0 : B4) >> 21) + BI2 | 0, sA2 = (hA2 = Q4 - (g6 = -2097152 & sA2) | 0) + ((2097151 & (A8 = (B4 = (2097151 & B4) << 11 | DA2 >>> 21) >>> 0 > (yA2 = B4 + CI2 | 0) >>> 0 ? A8 + 1 | 0 : A8)) << 11 | yA2 >>> 21) | 0, A8 = (SA2 - ((g6 >>> 0 > Q4 >>> 0) + xA2 | 0) | 0) + (A8 >> 21) | 0, SA2 = g6 = (A8 = hA2 >>> 0 > sA2 >>> 0 ? A8 + 1 | 0 : A8) >> 21, NA2 = (A8 = PA(KA2 = (2097151 & A8) << 11 | sA2 >>> 21, g6, 666643, 0)) + (g6 = 2097151 & NA2) | 0, A8 = t3, Q4 = A8 = g6 >>> 0 > NA2 >>> 0 ? A8 + 1 | 0 : A8, C3[0 | o4] = NA2, C3[o4 + 1 | 0] = (255 & A8) << 24 | NA2 >>> 8, A8 = 2097151 & wA2, g6 = PA(KA2, SA2, 470296, 0) + A8 | 0, B4 = t3, A8 = (Q4 >> 21) + (A8 >>> 0 > g6 >>> 0 ? B4 + 1 | 0 : B4) | 0, A8 = (wA2 = (hA2 = (2097151 & Q4) << 11 | NA2 >>> 21) + g6 | 0) >>> 0 < hA2 >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 4 | 0] = (2047 & A8) << 21 | wA2 >>> 11, g6 = A8, B4 = wA2, C3[o4 + 3 | 0] = (7 & A8) << 29 | B4 >>> 3, C3[o4 + 2 | 0] = 31 & ((65535 & Q4) << 16 | NA2 >>> 16) | B4 << 5, Q4 = 2097151 & eA2, eA2 = PA(KA2, SA2, 654183, 0) + Q4 | 0, A8 = t3, wA2 = (2097151 & g6) << 11 | B4 >>> 21, g6 = (g6 >> 21) + (Q4 = Q4 >>> 0 > eA2 >>> 0 ? A8 + 1 | 0 : A8) | 0, A8 = g6 = (eA2 = wA2 + eA2 | 0) >>> 0 < wA2 >>> 0 ? g6 + 1 | 0 : g6, C3[o4 + 6 | 0] = (63 & A8) << 26 | eA2 >>> 6, Q4 = eA2, eA2 = 0, C3[o4 + 5 | 0] = eA2 << 13 | (1572864 & B4) >>> 19 | Q4 << 2, B4 = 2097151 & c4, c4 = PA(KA2, SA2, -997805, -1) + B4 | 0, g6 = t3, g6 = B4 >>> 0 > c4 >>> 0 ? g6 + 1 | 0 : g6, eA2 = (2097151 & (B4 = A8)) << 11 | Q4 >>> 21, B4 = (A8 >>= 21) + g6 | 0, B4 = (c4 = eA2 + c4 | 0) >>> 0 < eA2 >>> 0 ? B4 + 1 | 0 : B4, C3[o4 + 9 | 0] = (511 & B4) << 23 | c4 >>> 9, C3[o4 + 8 | 0] = (1 & B4) << 31 | c4 >>> 1, g6 = 0, C3[o4 + 7 | 0] = g6 << 18 | (2080768 & Q4) >>> 14 | c4 << 7, g6 = 2097151 & tA2, Q4 = PA(KA2, SA2, 136657, 0) + g6 | 0, A8 = t3, A8 = g6 >>> 0 > Q4 >>> 0 ? A8 + 1 | 0 : A8, tA2 = (2097151 & (g6 = B4)) << 11 | c4 >>> 21, g6 = A8 + (B4 = g6 >> 21) | 0, g6 = (Q4 = tA2 + Q4 | 0) >>> 0 < tA2 >>> 0 ? g6 + 1 | 0 : g6, C3[o4 + 12 | 0] = (4095 & g6) << 20 | Q4 >>> 12, B4 = Q4, C3[o4 + 11 | 0] = (15 & g6) << 28 | B4 >>> 4, Q4 = 0, C3[o4 + 10 | 0] = Q4 << 15 | (1966080 & c4) >>> 17 | B4 << 4, Q4 = 2097151 & aA2, c4 = PA(KA2, SA2, -683901, -1) + Q4 | 0, A8 = t3, A8 = Q4 >>> 0 > c4 >>> 0 ? A8 + 1 | 0 : A8, Q4 = g6, g6 = A8 + (g6 >>= 21) | 0, g6 = (Q4 = (aA2 = c4) + (c4 = (2097151 & Q4) << 11 | B4 >>> 21) | 0) >>> 0 < c4 >>> 0 ? g6 + 1 | 0 : g6, C3[o4 + 14 | 0] = (127 & g6) << 25 | Q4 >>> 7, c4 = 0, C3[o4 + 13 | 0] = c4 << 12 | (1048576 & B4) >>> 20 | Q4 << 1, A8 = g6 >> 21, B4 = (g6 = (2097151 & g6) << 11 | Q4 >>> 21) >>> 0 > (c4 = g6 + (2097151 & kA2) | 0) >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 17 | 0] = (1023 & B4) << 22 | c4 >>> 10, C3[o4 + 16 | 0] = (3 & B4) << 30 | c4 >>> 2, g6 = 0, C3[o4 + 15 | 0] = g6 << 17 | (2064384 & Q4) >>> 15 | c4 << 6, A8 = B4 >> 21, A8 = (g6 = (2097151 & B4) << 11 | c4 >>> 21) >>> 0 > (B4 = g6 + (2097151 & nA2) | 0) >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 20 | 0] = (8191 & A8) << 19 | B4 >>> 13, C3[o4 + 19 | 0] = (31 & A8) << 27 | B4 >>> 5, Q4 = (g6 = 2097151 & fA2) + (fA2 = (2097151 & A8) << 11 | B4 >>> 21) | 0, g6 = A8 >> 21, g6 = Q4 >>> 0 < fA2 >>> 0 ? g6 + 1 | 0 : g6, fA2 = Q4, C3[o4 + 21 | 0] = Q4, nA2 = 0, C3[o4 + 18 | 0] = nA2 << 14 | (1835008 & c4) >>> 18 | B4 << 3, C3[o4 + 22 | 0] = (255 & g6) << 24 | Q4 >>> 8, B4 = g6 >> 21, B4 = (Q4 = (c4 = (2097151 & g6) << 11 | Q4 >>> 21) + (2097151 & DA2) | 0) >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, C3[o4 + 25 | 0] = (2047 & B4) << 21 | Q4 >>> 11, C3[o4 + 24 | 0] = (7 & B4) << 29 | Q4 >>> 3, C3[o4 + 23 | 0] = 31 & ((65535 & g6) << 16 | fA2 >>> 16) | Q4 << 5, A8 = B4 >> 21, A8 = (g6 = (2097151 & B4) << 11 | Q4 >>> 21) >>> 0 > (B4 = g6 + (2097151 & yA2) | 0) >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 27 | 0] = (63 & A8) << 26 | B4 >>> 6, c4 = 0, C3[o4 + 26 | 0] = c4 << 13 | (1572864 & Q4) >>> 19 | B4 << 2, g6 = A8, A8 >>= 21, g6 = (Q4 = (yA2 = (2097151 & g6) << 11 | B4 >>> 21) + (c4 = 2097151 & sA2) | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, C3[o4 + 31 | 0] = (131071 & g6) << 15 | Q4 >>> 17, A8 = Q4, C3[o4 + 30 | 0] = (511 & g6) << 23 | A8 >>> 9, Q4 = 0, C3[o4 + 28 | 0] = Q4 << 18 | (2080768 & B4) >>> 14 | A8 << 7, C3[o4 + 29 | 0] = yA2 + sA2 >>> 1, MI(a4, 64), MI(D4, 64), I7 && (E3[I7 >> 2] = 64, E3[I7 + 4 >> 2] = 0), r3 = y4 + 560 | 0, 0; + } + function n3(A8, I7, g6, C4) { + for (var B4 = 0, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0; o4 = (B4 = D4 << 3) + g6 | 0, Q4 = i3[0 | (B4 = I7 + B4 | 0)] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, _4 = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, a4 = Q4 << 24 | (65280 & Q4) << 8, y4 = (c4 = 16711680 & Q4) << 24, c4 = c4 >>> 8 | 0, B4 = (e4 = -16777216 & Q4) >>> 24 | 0, E3[o4 >> 2] = y4 | e4 << 8 | -16777216 & ((255 & _4) << 24 | Q4 >>> 8) | 16711680 & ((16777215 & _4) << 8 | Q4 >>> 24) | _4 >>> 8 & 65280 | _4 >>> 24, Q4 = B4 | c4 | a4, B4 = 0, E3[o4 + 4 >> 2] = Q4 | B4, 16 != (0 | (D4 = D4 + 1 | 0)); ) ; + for (I7 = E3[A8 + 4 >> 2], E3[C4 >> 2] = E3[A8 >> 2], E3[C4 + 4 >> 2] = I7, I7 = E3[A8 + 60 >> 2], E3[C4 + 56 >> 2] = E3[A8 + 56 >> 2], E3[C4 + 60 >> 2] = I7, I7 = E3[A8 + 52 >> 2], E3[C4 + 48 >> 2] = E3[A8 + 48 >> 2], E3[C4 + 52 >> 2] = I7, I7 = E3[A8 + 44 >> 2], E3[C4 + 40 >> 2] = E3[A8 + 40 >> 2], E3[C4 + 44 >> 2] = I7, I7 = E3[A8 + 36 >> 2], E3[C4 + 32 >> 2] = E3[A8 + 32 >> 2], E3[C4 + 36 >> 2] = I7, I7 = E3[A8 + 28 >> 2], E3[C4 + 24 >> 2] = E3[A8 + 24 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[A8 + 20 >> 2], E3[C4 + 16 >> 2] = E3[A8 + 16 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[A8 + 12 >> 2], E3[C4 + 8 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 12 >> 2] = I7; o4 = E3[C4 + 56 >> 2], c4 = E3[C4 + 60 >> 2], B4 = E3[(I7 = _4 = (p4 = q4 << 3) + g6 | 0) >> 2], I7 = E3[I7 + 4 >> 2], S4 = Q4 = E3[C4 + 36 >> 2], Q4 = _A(n4 = E3[C4 + 32 >> 2], Q4, 50), D4 = t3, Q4 = _A(n4, S4, 46) ^ Q4, D4 ^= t3, Q4 = _A(n4, S4, 23) ^ Q4, I7 = (t3 ^ D4) + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (D4 = E3[(Q4 = p4 + 33968 | 0) >> 2]) + B4 | 0, I7 = E3[Q4 + 4 >> 2] + I7 | 0, I7 = B4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (D4 = ((y4 = E3[C4 + 48 >> 2]) ^ (w4 = E3[C4 + 40 >> 2])) & n4 ^ y4) + B4 | 0, B4 = (((s4 = E3[C4 + 52 >> 2]) ^ (M4 = E3[C4 + 44 >> 2])) & S4 ^ s4) + I7 | 0, I7 = (Q4 >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4) + c4 | 0, I7 = (o4 = Q4 + o4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, D4 = (Q4 = E3[C4 + 24 >> 2]) + o4 | 0, B4 = E3[C4 + 28 >> 2] + I7 | 0, r4 = B4 = Q4 >>> 0 > D4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 24 >> 2] = D4, E3[C4 + 28 >> 2] = B4, F4 = B4 = E3[C4 + 4 >> 2], B4 = _A(Q4 = E3[C4 >> 2], B4, 36), c4 = t3, B4 = _A(Q4, F4, 30) ^ B4, c4 ^= t3, e4 = o4 + (_A(Q4, F4, 25) ^ B4) | 0, B4 = I7 + (t3 ^ c4) | 0, B4 = o4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4, a4 = (I7 = e4) + (e4 = Q4 & ((c4 = E3[C4 + 16 >> 2]) | (o4 = E3[C4 + 8 >> 2])) | o4 & c4) | 0, I7 = (I7 = B4) + (F4 & ((B4 = E3[C4 + 20 >> 2]) | (h4 = E3[C4 + 12 >> 2])) | B4 & h4) | 0, e4 = I7 = a4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 56 >> 2] = a4, E3[C4 + 60 >> 2] = I7, f4 = c4, k4 = B4, K4 = E3[(I7 = v4 = (N4 = 8 | p4) + g6 | 0) >> 2], G4 = E3[I7 + 4 >> 2], B4 = ((S4 ^ M4) & r4 ^ M4) + s4 | 0, B4 = (I7 = (c4 = (w4 ^ n4) & D4 ^ w4) + y4 | 0) >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, c4 = _A(D4, r4, 50), y4 = t3, c4 = _A(D4, r4, 46) ^ c4, y4 ^= t3, c4 = (s4 = _A(D4, r4, 23) ^ c4) + I7 | 0, I7 = (t3 ^ y4) + B4 | 0, I7 = (c4 >>> 0 < s4 >>> 0 ? I7 + 1 | 0 : I7) + G4 | 0, I7 = (B4 = c4 + K4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, c4 = (c4 = B4) + (y4 = E3[(B4 = N4 + 33968 | 0) >> 2]) | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (I7 = c4 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4) + k4 | 0, s4 = B4 = (y4 = c4 + f4 | 0) >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 16 >> 2] = y4, E3[C4 + 20 >> 2] = B4, I7 = I7 + ((h4 | F4) & e4 | h4 & F4) | 0, I7 = (B4 = c4 + ((Q4 | o4) & a4 | Q4 & o4) | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, c4 = _A(a4, e4, 36), f4 = t3, c4 = _A(a4, e4, 30) ^ c4, f4 ^= t3, k4 = B4, B4 = _A(a4, e4, 25) ^ c4, I7 = (t3 ^ f4) + I7 | 0, f4 = I7 = B4 >>> 0 > (c4 = k4 + B4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 48 >> 2] = c4, E3[C4 + 52 >> 2] = I7, k4 = o4, N4 = h4, I7 = (h4 = E3[(B4 = U4 = (o4 = 16 | p4) + g6 | 0) >> 2]) + w4 | 0, B4 = E3[B4 + 4 >> 2] + M4 | 0, B4 = I7 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, o4 = (w4 = I7) + (h4 = E3[(I7 = o4 + 33968 | 0) >> 2]) | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = ((r4 ^ S4) & s4 ^ S4) + (I7 = o4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = o4) + (o4 = (D4 ^ n4) & y4 ^ n4) | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, o4 = _A(y4, s4, 50), h4 = t3, o4 = _A(y4, s4, 46) ^ o4, h4 ^= t3, o4 = (w4 = _A(y4, s4, 23) ^ o4) + B4 | 0, B4 = (t3 ^ h4) + I7 | 0, B4 = (w4 = o4 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) + N4 | 0, N4 = B4 = (h4 = o4) >>> 0 > (o4 = o4 + k4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 8 >> 2] = o4, E3[C4 + 12 >> 2] = B4, I7 = _A(c4, f4, 36), B4 = t3, I7 = _A(c4, f4, 30) ^ I7, B4 ^= t3, M4 = _A(c4, f4, 25) ^ I7, I7 = ((e4 | F4) & f4 | e4 & F4) + (t3 ^ B4) | 0, B4 = w4 + ((k4 = M4 + ((Q4 | a4) & c4 | Q4 & a4) | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) | 0, h4 = B4 = (w4 = h4 + k4 | 0) >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 40 >> 2] = w4, E3[C4 + 44 >> 2] = B4, k4 = Q4, B4 = (B4 = n4) + (n4 = E3[(I7 = R4 = (Q4 = 24 | p4) + g6 | 0) >> 2]) | 0, I7 = E3[I7 + 4 >> 2] + S4 | 0, I7 = B4 >>> 0 < n4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (M4 = B4) + (n4 = E3[(B4 = Q4 + 33968 | 0) >> 2]) | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (r4 ^ (r4 ^ s4) & N4) + (B4 = Q4 >>> 0 < n4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = D4 ^ (D4 ^ y4) & o4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(o4, N4, 50), n4 = t3, Q4 = _A(o4, N4, 46) ^ Q4, n4 ^= t3, Q4 = (S4 = _A(o4, N4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ n4) + B4 | 0, B4 = (I7 = Q4 >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7) + F4 | 0, S4 = B4 = (F4 = Q4 + k4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 >> 2] = F4, E3[C4 + 4 >> 2] = B4, B4 = _A(w4, h4, 36), n4 = t3, B4 = _A(w4, h4, 30) ^ B4, k4 = t3 ^ n4, M4 = _A(w4, h4, 25) ^ B4, B4 = ((e4 | f4) & h4 | e4 & f4) + (t3 ^ k4) | 0, I7 = I7 + ((n4 = M4 + ((c4 | a4) & w4 | c4 & a4) | 0) >>> 0 < M4 >>> 0 ? B4 + 1 | 0 : B4) | 0, n4 = I7 = (k4 = Q4 + n4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 32 >> 2] = k4, E3[C4 + 36 >> 2] = I7, Q4 = E3[(B4 = P4 = (I7 = 32 | p4) + g6 | 0) >> 2], B4 = r4 + E3[B4 + 4 >> 2] | 0, B4 = (Q4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (D4 = E3[(I7 = I7 + 33968 | 0) >> 2]) + Q4 | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (s4 ^ (s4 ^ N4) & S4) + (I7 = Q4 >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = y4 ^ (o4 ^ y4) & F4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(F4, S4, 50), D4 = t3, Q4 = _A(F4, S4, 46) ^ Q4, D4 ^= t3, Q4 = (r4 = _A(F4, S4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ D4) + I7 | 0, M4 = B4 = Q4 >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(k4, n4, 36), D4 = t3, B4 = _A(k4, n4, 30) ^ B4, r4 = t3 ^ D4, K4 = _A(k4, n4, 25) ^ B4, B4 = ((f4 | h4) & n4 | f4 & h4) + (t3 ^ r4) | 0, I7 = ((D4 = K4 + ((c4 | w4) & k4 | c4 & w4) | 0) >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, D4 = I7 = (r4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 24 >> 2] = r4, E3[C4 + 28 >> 2] = I7, B4 = e4 + M4 | 0, M4 = B4 = (e4 = Q4 + a4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 56 >> 2] = e4, E3[C4 + 60 >> 2] = B4, Q4 = E3[(I7 = d4 = (B4 = 40 | p4) + g6 | 0) >> 2], I7 = s4 + E3[I7 + 4 >> 2] | 0, I7 = (Q4 = Q4 + y4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (a4 = E3[(B4 = B4 + 33968 | 0) >> 2]) + Q4 | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (N4 ^ (S4 ^ N4) & M4) + (B4 = Q4 >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = o4 ^ (o4 ^ F4) & e4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(e4, M4, 50), a4 = t3, Q4 = _A(e4, M4, 46) ^ Q4, a4 ^= t3, Q4 = (y4 = _A(e4, M4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ a4) + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(r4, D4, 36), a4 = t3, B4 = _A(r4, D4, 30) ^ B4, y4 = t3 ^ a4, s4 = _A(r4, D4, 25) ^ B4, B4 = ((h4 | n4) & D4 | h4 & n4) + (t3 ^ y4) | 0, B4 = ((a4 = s4 + ((w4 | k4) & r4 | w4 & k4) | 0) >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, a4 = B4 = (y4 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 16 >> 2] = y4, E3[C4 + 20 >> 2] = B4, I7 = I7 + f4 | 0, K4 = I7 = (f4 = Q4 + c4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 48 >> 2] = f4, E3[C4 + 52 >> 2] = I7, Q4 = E3[(B4 = Y4 = (I7 = 48 | p4) + g6 | 0) >> 2], B4 = N4 + E3[B4 + 4 >> 2] | 0, B4 = (Q4 = Q4 + o4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (o4 = E3[(I7 = I7 + 33968 | 0) >> 2]) + Q4 | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (S4 ^ (S4 ^ M4) & K4) + (I7 = Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = F4 ^ (e4 ^ F4) & f4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(f4, K4, 50), o4 = t3, Q4 = _A(f4, K4, 46) ^ Q4, o4 ^= t3, Q4 = (c4 = _A(f4, K4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ o4) + I7 | 0, c4 = B4 = Q4 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(y4, a4, 36), o4 = t3, B4 = _A(y4, a4, 30) ^ B4, s4 = t3 ^ o4, N4 = _A(y4, a4, 25) ^ B4, B4 = ((D4 | n4) & a4 | D4 & n4) + (t3 ^ s4) | 0, I7 = ((o4 = N4 + ((r4 | k4) & y4 | r4 & k4) | 0) >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, s4 = I7 = (B4 = o4) >>> 0 > (o4 = Q4 + o4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 8 >> 2] = o4, E3[C4 + 12 >> 2] = I7, B4 = c4 + h4 | 0, N4 = B4 = (G4 = Q4 + w4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 40 >> 2] = G4, E3[C4 + 44 >> 2] = B4, Q4 = E3[(I7 = b4 = (B4 = 56 | p4) + g6 | 0) >> 2], I7 = S4 + E3[I7 + 4 >> 2] | 0, I7 = (Q4 = Q4 + F4 | 0) >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (c4 = E3[(B4 = B4 + 33968 | 0) >> 2]) + Q4 | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (M4 ^ (M4 ^ K4) & N4) + (B4 = Q4 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = e4 ^ (e4 ^ f4) & G4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(G4, N4, 50), c4 = t3, Q4 = _A(G4, N4, 46) ^ Q4, c4 ^= t3, Q4 = (h4 = _A(G4, N4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ c4) + B4 | 0, I7 = Q4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(o4, s4, 36), c4 = t3, B4 = _A(o4, s4, 30) ^ B4, h4 = t3 ^ c4, w4 = _A(o4, s4, 25) ^ B4, B4 = ((D4 | a4) & s4 | D4 & a4) + (t3 ^ h4) | 0, B4 = ((c4 = w4 + ((y4 | r4) & o4 | y4 & r4) | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, h4 = B4 = (h4 = c4) >>> 0 > (c4 = Q4 + c4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 >> 2] = c4, E3[C4 + 4 >> 2] = B4, I7 = I7 + n4 | 0, S4 = I7 = (w4 = Q4 + k4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 32 >> 2] = w4, E3[C4 + 36 >> 2] = I7, Q4 = E3[(B4 = L4 = (I7 = 64 | p4) + g6 | 0) >> 2], B4 = M4 + E3[B4 + 4 >> 2] | 0, B4 = (Q4 = Q4 + e4 | 0) >>> 0 < e4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (e4 = E3[(I7 = I7 + 33968 | 0) >> 2]) + Q4 | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (K4 ^ (N4 ^ K4) & S4) + (I7 = Q4 >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = f4 ^ (f4 ^ G4) & w4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(w4, S4, 50), e4 = t3, Q4 = _A(w4, S4, 46) ^ Q4, e4 ^= t3, Q4 = (F4 = _A(w4, S4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ e4) + I7 | 0, n4 = B4 = Q4 >>> 0 < F4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(c4, h4, 36), e4 = t3, B4 = _A(c4, h4, 30) ^ B4, F4 = t3 ^ e4, k4 = _A(c4, h4, 25) ^ B4, B4 = ((a4 | s4) & h4 | a4 & s4) + (t3 ^ F4) | 0, I7 = ((e4 = k4 + ((o4 | y4) & c4 | o4 & y4) | 0) >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, e4 = I7 = (F4 = Q4 + e4 | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 56 >> 2] = F4, E3[C4 + 60 >> 2] = I7, B4 = D4 + n4 | 0, M4 = B4 = (D4 = Q4 + r4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 24 >> 2] = D4, E3[C4 + 28 >> 2] = B4, Q4 = E3[(I7 = J4 = (B4 = 72 | p4) + g6 | 0) >> 2], I7 = K4 + E3[I7 + 4 >> 2] | 0, I7 = (Q4 = Q4 + f4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (f4 = E3[(B4 = B4 + 33968 | 0) >> 2]) + Q4 | 0, B4 = E3[B4 + 4 >> 2] + I7 | 0, B4 = (N4 ^ (S4 ^ N4) & M4) + (B4 = Q4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (I7 = Q4) + (Q4 = G4 ^ (w4 ^ G4) & D4) | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(D4, M4, 50), f4 = t3, Q4 = _A(D4, M4, 46) ^ Q4, f4 ^= t3, Q4 = (n4 = _A(D4, M4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ f4) + B4 | 0, I7 = Q4 >>> 0 < n4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(F4, e4, 36), f4 = t3, B4 = _A(F4, e4, 30) ^ B4, n4 = t3 ^ f4, k4 = _A(F4, e4, 25) ^ B4, B4 = ((h4 | s4) & e4 | h4 & s4) + (t3 ^ n4) | 0, B4 = ((f4 = k4 + ((o4 | c4) & F4 | o4 & c4) | 0) >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, f4 = B4 = (n4 = Q4 + f4 | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 48 >> 2] = n4, E3[C4 + 52 >> 2] = B4, I7 = I7 + a4 | 0, K4 = I7 = (a4 = Q4 + y4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 16 >> 2] = a4, E3[C4 + 20 >> 2] = I7, I7 = (I7 = G4) + (y4 = E3[(B4 = G4 = (Q4 = 80 | p4) + g6 | 0) >> 2]) | 0, B4 = E3[B4 + 4 >> 2] + N4 | 0, B4 = I7 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (r4 = I7) + (y4 = E3[(I7 = Q4 + 33968 | 0) >> 2]) | 0, I7 = E3[I7 + 4 >> 2] + B4 | 0, I7 = (S4 ^ (S4 ^ M4) & K4) + (I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (B4 = Q4) + (Q4 = w4 ^ (D4 ^ w4) & a4) | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(a4, K4, 50), y4 = t3, Q4 = _A(a4, K4, 46) ^ Q4, y4 ^= t3, Q4 = (k4 = _A(a4, K4, 23) ^ Q4) + B4 | 0, B4 = (t3 ^ y4) + I7 | 0, r4 = B4 = Q4 >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(n4, f4, 36), y4 = t3, B4 = _A(n4, f4, 30) ^ B4, k4 = t3 ^ y4, N4 = _A(n4, f4, 25) ^ B4, B4 = ((e4 | h4) & f4 | e4 & h4) + (t3 ^ k4) | 0, I7 = ((y4 = N4 + ((c4 | F4) & n4 | c4 & F4) | 0) >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, y4 = I7 = (k4 = Q4 + y4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 40 >> 2] = k4, E3[C4 + 44 >> 2] = I7, B4 = r4 + s4 | 0, s4 = B4 = (r4 = Q4 + o4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 8 >> 2] = r4, E3[C4 + 12 >> 2] = B4, B4 = 33968 + (I7 = 88 | p4) | 0, o4 = E3[(I7 = H4 = I7 + g6 | 0) >> 2], Q4 = E3[B4 >> 2] + o4 | 0, I7 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, B4 = S4 + (Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (M4 ^ (M4 ^ K4) & s4) + (B4 = (I7 = Q4 + w4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (Q4 = D4 ^ (D4 ^ a4) & r4) + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(r4, s4, 50), o4 = t3, Q4 = _A(r4, s4, 46) ^ Q4, o4 ^= t3, Q4 = (w4 = _A(r4, s4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ o4) + B4 | 0, I7 = Q4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(k4, y4, 36), o4 = t3, B4 = _A(k4, y4, 30) ^ B4, w4 = t3 ^ o4, N4 = _A(k4, y4, 25) ^ B4, B4 = ((e4 | f4) & y4 | e4 & f4) + (t3 ^ w4) | 0, B4 = ((o4 = N4 + ((n4 | F4) & k4 | n4 & F4) | 0) >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, w4 = B4 = (w4 = o4) >>> 0 > (o4 = Q4 + o4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 32 >> 2] = o4, E3[C4 + 36 >> 2] = B4, I7 = I7 + h4 | 0, h4 = I7 = (B4 = c4) >>> 0 > (c4 = Q4 + c4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[C4 >> 2] = c4, E3[C4 + 4 >> 2] = I7, B4 = 33968 + (I7 = 96 | p4) | 0, N4 = E3[(I7 = x4 = I7 + g6 | 0) >> 2], Q4 = E3[B4 >> 2] + N4 | 0, B4 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, I7 = M4 + (Q4 >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (D4 = a4 ^ (a4 ^ r4) & c4) + B4 | 0, B4 = (K4 ^ (s4 ^ K4) & h4) + I7 | 0, B4 = Q4 >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, I7 = _A(c4, h4, 50), D4 = t3, I7 = _A(c4, h4, 46) ^ I7, D4 ^= t3, M4 = Q4, Q4 = _A(c4, h4, 23) ^ I7, B4 = (t3 ^ D4) + B4 | 0, S4 = B4 = (I7 = M4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = I7, I7 = _A(o4, w4, 36), D4 = t3, I7 = _A(o4, w4, 30) ^ I7, N4 = t3 ^ D4, M4 = _A(o4, w4, 25) ^ I7, I7 = ((y4 | f4) & w4 | y4 & f4) + (t3 ^ N4) | 0, B4 = ((D4 = M4 + ((n4 | k4) & o4 | n4 & k4) | 0) >>> 0 < M4 >>> 0 ? I7 + 1 | 0 : I7) + B4 | 0, D4 = B4 = (N4 = Q4 + D4 | 0) >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 24 >> 2] = N4, E3[C4 + 28 >> 2] = B4, B4 = e4 + S4 | 0, e4 = B4 = (F4 = Q4 + F4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 56 >> 2] = F4, E3[C4 + 60 >> 2] = B4, B4 = 33968 + (I7 = 104 | p4) | 0, S4 = E3[(I7 = m4 = I7 + g6 | 0) >> 2], Q4 = E3[B4 >> 2] + S4 | 0, I7 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, B4 = K4 + (Q4 >>> 0 < S4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (I7 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (a4 = r4 ^ (c4 ^ r4) & F4) + I7 | 0, I7 = (s4 ^ (h4 ^ s4) & e4) + B4 | 0, I7 = Q4 >>> 0 < a4 >>> 0 ? I7 + 1 | 0 : I7, B4 = _A(F4, e4, 50), a4 = t3, B4 = _A(F4, e4, 46) ^ B4, a4 ^= t3, S4 = _A(F4, e4, 23) ^ B4, B4 = (t3 ^ a4) + I7 | 0, M4 = B4 = (Q4 = S4 + Q4 | 0) >>> 0 < S4 >>> 0 ? B4 + 1 | 0 : B4, I7 = B4, B4 = _A(N4, D4, 36), a4 = t3, B4 = _A(N4, D4, 30) ^ B4, S4 = t3 ^ a4, K4 = _A(N4, D4, 25) ^ B4, B4 = ((y4 | w4) & D4 | y4 & w4) + (t3 ^ S4) | 0, I7 = ((a4 = K4 + ((o4 | k4) & N4 | o4 & k4) | 0) >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, a4 = I7 = (S4 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 16 >> 2] = S4, E3[C4 + 20 >> 2] = I7, I7 = f4 + M4 | 0, f4 = I7 = (n4 = Q4 + n4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 + 48 >> 2] = n4, E3[C4 + 52 >> 2] = I7, B4 = 33968 + (I7 = 112 | p4) | 0, M4 = E3[(Q4 = K4 = I7 + g6 | 0) >> 2], I7 = E3[B4 >> 2] + M4 | 0, B4 = E3[B4 + 4 >> 2] + E3[Q4 + 4 >> 2] | 0, B4 = s4 + (I7 >>> 0 < M4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (h4 ^ (e4 ^ h4) & f4) + (B4 = (I7 = I7 + r4 | 0) >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4) | 0, B4 = (I7 = (Q4 = c4 ^ (c4 ^ F4) & n4) + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = _A(n4, f4, 50), r4 = t3, Q4 = _A(n4, f4, 46) ^ Q4, r4 ^= t3, Q4 = (s4 = _A(n4, f4, 23) ^ Q4) + I7 | 0, I7 = (t3 ^ r4) + B4 | 0, M4 = I7 = Q4 >>> 0 < s4 >>> 0 ? I7 + 1 | 0 : I7, B4 = I7, I7 = _A(S4, a4, 36), r4 = t3, I7 = _A(S4, a4, 30) ^ I7, s4 = t3 ^ r4, u4 = _A(S4, a4, 25) ^ I7, I7 = ((D4 | w4) & a4 | D4 & w4) + (t3 ^ s4) | 0, B4 = ((r4 = u4 + ((o4 | N4) & S4 | o4 & N4) | 0) >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7) + B4 | 0, r4 = B4 = (s4 = Q4 + r4 | 0) >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 8 >> 2] = s4, E3[C4 + 12 >> 2] = B4, B4 = y4 + M4 | 0, Q4 = B4 = (y4 = Q4 + k4 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 40 >> 2] = y4, E3[C4 + 44 >> 2] = B4, B4 = 33968 + (I7 = 120 | p4) | 0, p4 = E3[(I7 = k4 = I7 + g6 | 0) >> 2], M4 = E3[B4 >> 2] + p4 | 0, B4 = E3[B4 + 4 >> 2] + E3[I7 + 4 >> 2] | 0, I7 = h4 + (M4 >>> 0 < p4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (e4 ^ (e4 ^ f4) & Q4) + (I7 = (B4 = c4 + M4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7) | 0, I7 = (B4 = (c4 = F4 ^ (n4 ^ F4) & y4) + B4 | 0) >>> 0 < c4 >>> 0 ? I7 + 1 | 0 : I7, c4 = _A(y4, Q4, 50), e4 = t3, c4 = _A(y4, Q4, 46) ^ c4, e4 ^= t3, Q4 = (c4 = _A(y4, Q4, 23) ^ c4) + B4 | 0, B4 = (t3 ^ e4) + I7 | 0, B4 = Q4 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, c4 = Q4, e4 = B4, I7 = B4, B4 = _A(s4, r4, 36), y4 = t3, B4 = _A(s4, r4, 30) ^ B4, f4 = t3 ^ y4, h4 = _A(s4, r4, 25) ^ B4, B4 = ((D4 | a4) & r4 | D4 & a4) + (t3 ^ f4) | 0, I7 = ((y4 = h4 + ((S4 | N4) & s4 | S4 & N4) | 0) >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4) + I7 | 0, I7 = (Q4 = Q4 + y4 | 0) >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, E3[C4 >> 2] = Q4, E3[C4 + 4 >> 2] = I7, B4 = e4 + w4 | 0, B4 = (f4 = o4) >>> 0 > (o4 = o4 + c4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[C4 + 32 >> 2] = o4, E3[C4 + 36 >> 2] = B4, 64 != (0 | q4); ) a4 = ((q4 = q4 + 16 | 0) << 3) + g6 | 0, c4 = E3[_4 >> 2], D4 = E3[_4 + 4 >> 2], u4 = E3[J4 >> 2], e4 = I7 = E3[J4 + 4 >> 2], B4 = I7, Q4 = I7 = E3[K4 + 4 >> 2], I7 = _A(N4 = E3[K4 >> 2], I7, 45), o4 = t3, f4 = ((63 & Q4) << 26 | N4 >>> 6) ^ (I7 = _A(N4, Q4, 3) ^ I7), I7 = (Q4 >>> 6 ^ (y4 = t3 ^ o4)) + B4 | 0, B4 = ((o4 = f4 + u4 | 0) >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7) + D4 | 0, B4 = (I7 = o4 + c4 | 0) >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, c4 = o4 = E3[v4 + 4 >> 2], o4 = _A(D4 = E3[v4 >> 2], o4, 63), y4 = t3, o4 = ((127 & c4) << 25 | D4 >>> 7) ^ _A(D4, c4, 56) ^ o4, B4 = (t3 ^ y4 ^ c4 >>> 7) + B4 | 0, o4 = B4 = o4 >>> 0 > (S4 = o4 + I7 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[a4 >> 2] = S4, E3[a4 + 4 >> 2] = B4, D4 = (K4 = E3[G4 >> 2]) + D4 | 0, I7 = (a4 = E3[G4 + 4 >> 2]) + c4 | 0, B4 = D4 >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7, c4 = I7 = E3[k4 + 4 >> 2], I7 = _A(M4 = E3[k4 >> 2], I7, 45), y4 = t3, f4 = D4, D4 = ((63 & c4) << 26 | M4 >>> 6) ^ _A(M4, c4, 3) ^ I7, B4 = (t3 ^ y4 ^ c4 >>> 6) + B4 | 0, D4 = D4 >>> 0 > (f4 = f4 + D4 | 0) >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(y4 = E3[U4 >> 2], I7 = E3[U4 + 4 >> 2], 63), h4 = t3, r4 = f4, f4 = ((127 & I7) << 25 | y4 >>> 7) ^ _A(y4, I7, 56) ^ B4, B4 = (t3 ^ h4 ^ I7 >>> 7) + D4 | 0, D4 = B4 = f4 >>> 0 > (s4 = r4 + f4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 136 >> 2] = s4, E3[_4 + 140 >> 2] = B4, B4 = (G4 = E3[H4 >> 2]) + y4 | 0, I7 = (y4 = E3[H4 + 4 >> 2]) + I7 | 0, f4 = _A(S4, o4, 45), h4 = t3, f4 = (w4 = ((63 & o4) << 26 | S4 >>> 6) ^ _A(S4, o4, 3) ^ f4) + B4 | 0, B4 = (t3 ^ h4 ^ o4 >>> 6) + (B4 >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = f4 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, h4 = I7 = E3[R4 + 4 >> 2], I7 = _A(w4 = E3[R4 >> 2], I7, 63), F4 = t3, r4 = f4, f4 = ((127 & h4) << 25 | w4 >>> 7) ^ _A(w4, h4, 56) ^ I7, B4 = (t3 ^ F4 ^ h4 >>> 7) + B4 | 0, f4 = B4 = f4 >>> 0 > (p4 = r4 + f4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 144 >> 2] = p4, E3[_4 + 148 >> 2] = B4, w4 = (v4 = E3[x4 >> 2]) + w4 | 0, I7 = (I7 = h4) + (h4 = E3[x4 + 4 >> 2]) | 0, B4 = w4 >>> 0 < v4 >>> 0 ? I7 + 1 | 0 : I7, I7 = _A(s4, D4, 45), F4 = t3, n4 = ((63 & D4) << 26 | s4 >>> 6) ^ _A(s4, D4, 3) ^ I7, B4 = (t3 ^ F4 ^ D4 >>> 6) + B4 | 0, B4 = (w4 = n4 + w4 | 0) >>> 0 < n4 >>> 0 ? B4 + 1 | 0 : B4, F4 = I7 = E3[P4 + 4 >> 2], I7 = _A(n4 = E3[P4 >> 2], I7, 63), k4 = t3, r4 = w4, w4 = ((127 & F4) << 25 | n4 >>> 7) ^ _A(n4, F4, 56) ^ I7, B4 = (t3 ^ k4 ^ F4 >>> 7) + B4 | 0, w4 = B4 = w4 >>> 0 > (U4 = r4 + w4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 152 >> 2] = U4, E3[_4 + 156 >> 2] = B4, I7 = (R4 = E3[m4 >> 2]) + n4 | 0, B4 = (B4 = F4) + (F4 = E3[m4 + 4 >> 2]) | 0, n4 = _A(p4, f4, 45), k4 = t3, n4 = ((63 & f4) << 26 | p4 >>> 6) ^ _A(p4, f4, 3) ^ n4, B4 = (t3 ^ k4 ^ f4 >>> 6) + (I7 >>> 0 < R4 >>> 0 ? B4 + 1 | 0 : B4) | 0, n4 = (r4 = n4 + I7 | 0) >>> 0 < n4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(k4 = E3[d4 >> 2], I7 = E3[d4 + 4 >> 2], 63), P4 = t3, H4 = r4, r4 = ((127 & I7) << 25 | k4 >>> 7) ^ (B4 = _A(k4, I7, 56) ^ B4), B4 = (I7 >>> 7 ^ (d4 = t3 ^ P4)) + n4 | 0, n4 = B4 = r4 >>> 0 > (P4 = H4 + r4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 160 >> 2] = P4, E3[_4 + 164 >> 2] = B4, I7 = I7 + Q4 | 0, I7 = (B4 = k4 + N4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, k4 = _A(U4, w4, 45), r4 = t3, k4 = (d4 = ((63 & w4) << 26 | U4 >>> 6) ^ _A(U4, w4, 3) ^ k4) + B4 | 0, B4 = (t3 ^ r4 ^ w4 >>> 6) + I7 | 0, B4 = k4 >>> 0 < d4 >>> 0 ? B4 + 1 | 0 : B4, r4 = E3[Y4 >> 2], Y4 = I7 = E3[Y4 + 4 >> 2], I7 = _A(r4, I7, 63), d4 = t3, I7 = _A(r4, Y4, 56) ^ I7, H4 = k4, B4 = (Y4 >>> 7 ^ (J4 = t3 ^ d4)) + B4 | 0, k4 = B4 = (k4 = ((127 & Y4) << 25 | r4 >>> 7) ^ I7) >>> 0 > (d4 = H4 + k4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 168 >> 2] = d4, E3[_4 + 172 >> 2] = B4, I7 = c4 + Y4 | 0, I7 = (B4 = r4 + M4 | 0) >>> 0 < r4 >>> 0 ? I7 + 1 | 0 : I7, H4 = r4 = E3[b4 + 4 >> 2], r4 = _A(J4 = E3[b4 >> 2], r4, 63), Y4 = t3, r4 = (b4 = ((127 & H4) << 25 | J4 >>> 7) ^ _A(J4, H4, 56) ^ r4) + B4 | 0, B4 = (t3 ^ Y4 ^ H4 >>> 7) + I7 | 0, I7 = r4 >>> 0 < b4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(P4, n4, 45), Y4 = t3, B4 = _A(P4, n4, 3) ^ B4, b4 = t3 ^ Y4, Y4 = r4, I7 = (n4 >>> 6 ^ b4) + I7 | 0, r4 = I7 = (r4 = ((63 & n4) << 26 | P4 >>> 6) ^ B4) >>> 0 > (Y4 = Y4 + r4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 176 >> 2] = Y4, E3[_4 + 180 >> 2] = I7, x4 = E3[L4 >> 2], L4 = I7 = E3[L4 + 4 >> 2], b4 = I7, I7 = _A(u4, e4, 63), B4 = t3, m4 = ((127 & e4) << 25 | u4 >>> 7) ^ _A(u4, e4, 56) ^ I7, I7 = (t3 ^ B4 ^ e4 >>> 7) + D4 | 0, B4 = ((s4 = m4 + s4 | 0) >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7) + b4 | 0, B4 = (I7 = s4 + x4 | 0) >>> 0 < s4 >>> 0 ? B4 + 1 | 0 : B4, D4 = _A(Y4, r4, 45), s4 = t3, b4 = (D4 = ((63 & r4) << 26 | Y4 >>> 6) ^ _A(Y4, r4, 3) ^ D4) + I7 | 0, I7 = (t3 ^ s4 ^ r4 >>> 6) + B4 | 0, D4 = I7 = D4 >>> 0 > b4 >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 192 >> 2] = b4, E3[_4 + 196 >> 2] = I7, B4 = o4 + H4 | 0, B4 = (I7 = S4 + J4 | 0) >>> 0 < J4 >>> 0 ? B4 + 1 | 0 : B4, s4 = _A(x4, L4, 63), J4 = t3, H4 = ((127 & L4) << 25 | x4 >>> 7) ^ _A(x4, L4, 56) ^ s4, B4 = (t3 ^ J4 ^ L4 >>> 7) + B4 | 0, I7 = (s4 = H4 + I7 | 0) >>> 0 < H4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(d4, k4, 45), J4 = t3, B4 = _A(d4, k4, 3) ^ B4, L4 = s4, I7 = (k4 >>> 6 ^ (H4 = t3 ^ J4)) + I7 | 0, s4 = I7 = (s4 = ((63 & k4) << 26 | d4 >>> 6) ^ B4) >>> 0 > (J4 = L4 + s4 | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 184 >> 2] = J4, E3[_4 + 188 >> 2] = I7, I7 = _A(G4, y4, 63), B4 = t3, I7 = ((127 & y4) << 25 | G4 >>> 7) ^ _A(G4, y4, 56) ^ I7, B4 = (t3 ^ B4 ^ y4 >>> 7) + a4 | 0, I7 = w4 + (I7 >>> 0 > (H4 = I7 + K4 | 0) >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = U4 + H4 | 0) >>> 0 < U4 >>> 0 ? I7 + 1 | 0 : I7, w4 = _A(b4, D4, 45), U4 = t3, w4 = _A(b4, D4, 3) ^ w4, H4 = t3 ^ U4, U4 = (w4 ^= (63 & D4) << 26 | b4 >>> 6) + B4 | 0, B4 = (D4 >>> 6 ^ H4) + I7 | 0, w4 = B4 = w4 >>> 0 > U4 >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 208 >> 2] = U4, E3[_4 + 212 >> 2] = B4, I7 = _A(K4, a4, 63), B4 = t3, H4 = _A(K4, a4, 56) ^ I7, B4 = ((I7 = a4 >>> 7 | 0) ^ t3 ^ B4) + e4 | 0, I7 = f4 + ((a4 = (K4 = H4 ^ ((127 & a4) << 25 | K4 >>> 7)) + u4 | 0) >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = a4 + p4 | 0) >>> 0 < p4 >>> 0 ? I7 + 1 | 0 : I7, e4 = _A(J4, s4, 45), a4 = t3, f4 = (e4 = ((63 & s4) << 26 | J4 >>> 6) ^ _A(J4, s4, 3) ^ e4) + B4 | 0, B4 = (t3 ^ a4 ^ s4 >>> 6) + I7 | 0, e4 = B4 = e4 >>> 0 > f4 >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 200 >> 2] = f4, E3[_4 + 204 >> 2] = B4, I7 = _A(R4, F4, 63), B4 = t3, K4 = ((127 & F4) << 25 | R4 >>> 7) ^ _A(R4, F4, 56) ^ I7, I7 = (t3 ^ B4 ^ F4 >>> 7) + h4 | 0, B4 = k4 + ((a4 = K4 + v4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (I7 = a4 + d4 | 0) >>> 0 < d4 >>> 0 ? B4 + 1 | 0 : B4, a4 = _A(U4, w4, 45), k4 = t3, K4 = I7, I7 = w4 >>> 6 | 0, a4 = ((63 & w4) << 26 | U4 >>> 6) ^ _A(U4, w4, 3) ^ a4, B4 = (I7 ^ t3 ^ k4) + B4 | 0, a4 = B4 = a4 >>> 0 > (w4 = K4 + a4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 224 >> 2] = w4, E3[_4 + 228 >> 2] = B4, I7 = _A(v4, h4, 63), B4 = t3, I7 = _A(v4, h4, 56) ^ I7, k4 = t3 ^ B4, K4 = ((127 & h4) << 25 | v4 >>> 7) ^ I7, I7 = ((B4 = h4 >>> 7 | 0) ^ k4) + y4 | 0, B4 = n4 + ((h4 = K4 + G4 | 0) >>> 0 < K4 >>> 0 ? I7 + 1 | 0 : I7) | 0, B4 = (I7 = h4 + P4 | 0) >>> 0 < P4 >>> 0 ? B4 + 1 | 0 : B4, y4 = _A(f4, e4, 45), h4 = t3, k4 = I7, I7 = e4 >>> 6 | 0, e4 = ((63 & e4) << 26 | f4 >>> 6) ^ _A(f4, e4, 3) ^ y4, I7 = (I7 ^ t3 ^ h4) + B4 | 0, e4 = I7 = (y4 = k4 + e4 | 0) >>> 0 < e4 >>> 0 ? I7 + 1 | 0 : I7, E3[_4 + 216 >> 2] = y4, E3[_4 + 220 >> 2] = I7, I7 = _A(M4, c4, 63), B4 = t3, h4 = ((127 & c4) << 25 | M4 >>> 7) ^ _A(M4, c4, 56) ^ I7, B4 = (t3 ^ B4 ^ c4 >>> 7) + Q4 | 0, B4 = s4 + ((I7 = h4 + N4 | 0) >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (f4 = I7 + J4 | 0) >>> 0 < J4 >>> 0 ? B4 + 1 | 0 : B4, B4 = _A(w4, a4, 45), h4 = t3, k4 = f4, f4 = _A(w4, a4, 3) ^ B4, B4 = a4 >>> 6 | 0, a4 = k4 + (f4 ^= (63 & a4) << 26 | w4 >>> 6) | 0, I7 = (B4 ^ t3 ^ h4) + I7 | 0, E3[_4 + 240 >> 2] = a4, E3[_4 + 244 >> 2] = a4 >>> 0 < f4 >>> 0 ? I7 + 1 | 0 : I7, I7 = _A(N4, Q4, 63), B4 = t3, I7 = _A(N4, Q4, 56) ^ I7, a4 = t3 ^ B4, B4 = ((B4 = Q4 >>> 7 | 0) ^ a4) + F4 | 0, I7 = r4 + ((I7 ^= (127 & Q4) << 25 | N4 >>> 7) >>> 0 > (Q4 = I7 + R4 | 0) >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = Q4 + Y4 | 0) >>> 0 < Y4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = _A(y4, e4, 45), a4 = t3, f4 = B4, B4 = e4 >>> 6 | 0, Q4 = ((63 & e4) << 26 | y4 >>> 6) ^ _A(y4, e4, 3) ^ Q4, B4 = (B4 ^ t3 ^ a4) + I7 | 0, Q4 = B4 = Q4 >>> 0 > (e4 = f4 + Q4 | 0) >>> 0 ? B4 + 1 | 0 : B4, E3[_4 + 232 >> 2] = e4, E3[_4 + 236 >> 2] = B4, I7 = _A(S4, o4, 63), B4 = t3, f4 = _A(S4, o4, 56) ^ I7, B4 = ((I7 = o4 >>> 7 | 0) ^ t3 ^ B4) + c4 | 0, I7 = D4 + ((o4 = (a4 = f4 ^ ((127 & o4) << 25 | S4 >>> 7)) + M4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = (B4 = o4 + b4 | 0) >>> 0 < b4 >>> 0 ? I7 + 1 | 0 : I7, o4 = _A(e4, Q4, 45), c4 = t3, f4 = B4, B4 = Q4 >>> 6 | 0, Q4 = f4 + (o4 = ((63 & Q4) << 26 | e4 >>> 6) ^ _A(e4, Q4, 3) ^ o4) | 0, B4 = (B4 ^ t3 ^ c4) + I7 | 0, E3[_4 + 248 >> 2] = Q4, E3[_4 + 252 >> 2] = Q4 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4; + I7 = I7 + E3[A8 + 4 >> 2] | 0, I7 = (g6 = Q4 + E3[A8 >> 2] | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, E3[A8 >> 2] = g6, E3[A8 + 4 >> 2] = I7, B4 = E3[A8 + 12 >> 2] + E3[C4 + 12 >> 2] | 0, I7 = (g6 = E3[C4 + 8 >> 2]) + E3[A8 + 8 >> 2] | 0, E3[A8 + 8 >> 2] = I7, E3[A8 + 12 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, B4 = E3[A8 + 20 >> 2] + E3[C4 + 20 >> 2] | 0, I7 = (g6 = E3[C4 + 16 >> 2]) + E3[A8 + 16 >> 2] | 0, E3[A8 + 16 >> 2] = I7, E3[A8 + 20 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, I7 = E3[A8 + 28 >> 2] + E3[C4 + 28 >> 2] | 0, g6 = (B4 = E3[C4 + 24 >> 2]) + E3[A8 + 24 >> 2] | 0, E3[A8 + 24 >> 2] = g6, E3[A8 + 28 >> 2] = g6 >>> 0 < B4 >>> 0 ? I7 + 1 | 0 : I7, B4 = E3[A8 + 36 >> 2] + E3[C4 + 36 >> 2] | 0, I7 = (g6 = E3[C4 + 32 >> 2]) + E3[A8 + 32 >> 2] | 0, E3[A8 + 32 >> 2] = I7, E3[A8 + 36 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, I7 = E3[A8 + 44 >> 2] + E3[C4 + 44 >> 2] | 0, g6 = (B4 = E3[C4 + 40 >> 2]) + E3[A8 + 40 >> 2] | 0, E3[A8 + 40 >> 2] = g6, E3[A8 + 44 >> 2] = g6 >>> 0 < B4 >>> 0 ? I7 + 1 | 0 : I7, B4 = E3[A8 + 52 >> 2] + E3[C4 + 52 >> 2] | 0, I7 = (g6 = E3[C4 + 48 >> 2]) + E3[A8 + 48 >> 2] | 0, E3[A8 + 48 >> 2] = I7, E3[A8 + 52 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4, B4 = E3[A8 + 60 >> 2] + E3[C4 + 60 >> 2] | 0, I7 = (g6 = E3[C4 + 56 >> 2]) + E3[A8 + 56 >> 2] | 0, E3[A8 + 56 >> 2] = I7, E3[A8 + 60 >> 2] = I7 >>> 0 < g6 >>> 0 ? B4 + 1 | 0 : B4; + } + function s3(A8) { + var I7, g6, B4, Q4, E4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0; + h4 = (G4 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24) >>> 5 & 2097151, r4 = PA(I7 = (i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24) >>> 3 | 0, 0, -683901, -1), w4 = (e4 = i3[A8 + 44 | 0]) << 16 & 2031616 | i3[A8 + 42 | 0] | i3[A8 + 43 | 0] << 8, e4 = t3, F4 = e4 = w4 >>> 0 > (M4 = r4 + w4 | 0) >>> 0 ? e4 + 1 | 0 : e4, p4 = e4 = e4 - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, r4 = e4 >> 21, e4 = (w4 = h4) + (h4 = (2097151 & e4) << 11 | (n4 = M4 - -1048576 | 0) >>> 21) | 0, w4 = r4, P4 = w4 = e4 >>> 0 < h4 >>> 0 ? w4 + 1 | 0 : w4, z2 = e4, _4 = PA(e4, w4, -683901, -1), S4 = t3, s4 = PA(g6 = (i3[A8 + 49 | 0] | i3[A8 + 50 | 0] << 8 | i3[A8 + 51 | 0] << 16 | i3[A8 + 52 | 0] << 24) >>> 7 & 2097151, 0, -997805, -1), r4 = (e4 = i3[A8 + 27 | 0]) >>> 24 | 0, h4 = e4 << 8 | (H4 = i3[A8 + 23 | 0] | i3[A8 + 24 | 0] << 8 | i3[A8 + 25 | 0] << 16 | i3[A8 + 26 | 0] << 24) >>> 24, w4 = (e4 = i3[A8 + 28 | 0]) >>> 16 | 0, w4 = 2097151 & ((3 & (w4 |= r4)) << 30 | (e4 = h4 | e4 << 16) >>> 2), e4 = t3, e4 = w4 >>> 0 > (r4 = w4 + s4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(q4 = (N4 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24) >>> 4 & 2097151, 0, 654183, 0), e4 = t3 + e4 | 0, s4 = r4 = w4 + r4 | 0, r4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, k4 = (w4 = i3[A8 + 48 | 0]) << 8 | G4 >>> 24, w4 = e4 = w4 >>> 24 | 0, e4 = PA(B4 = 2097151 & ((3 & (G4 = (e4 = (h4 = i3[A8 + 49 | 0]) >>> 16 | 0) | w4)) << 30 | (w4 = (h4 <<= 16) | k4) >>> 2), 0, 136657, 0), r4 = t3 + r4 | 0, r4 = e4 >>> 0 > (w4 = e4 + s4 | 0) >>> 0 ? r4 + 1 | 0 : r4, h4 = (e4 = PA(Q4 = (i3[A8 + 57 | 0] | i3[A8 + 58 | 0] << 8 | i3[A8 + 59 | 0] << 16 | i3[A8 + 60 | 0] << 24) >>> 6 & 2097151, 0, 666643, 0)) + w4 | 0, w4 = t3 + r4 | 0, s4 = h4, r4 = e4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, w4 = (e4 = i3[A8 + 56 | 0]) >>> 24 | 0, k4 = e4 << 8 | N4 >>> 24, w4 = PA(E4 = 2097151 & ((1 & (N4 = (e4 = (h4 = i3[A8 + 57 | 0]) >>> 16 | 0) | w4)) << 31 | (w4 = (h4 <<= 16) | k4) >>> 1), 0, 470296, 0), e4 = t3 + r4 | 0, w4 = (e4 = (r4 = h4 = w4 + s4 | 0) >>> 0 < w4 >>> 0 ? e4 + 1 | 0 : e4) + S4 | 0, w4 = r4 >>> 0 > (h4 = r4 + _4 | 0) >>> 0 ? w4 + 1 | 0 : w4, J4 = r4 - -1048576 | 0, v4 = r4 = e4 - ((r4 >>> 0 < 4293918720) - 1 | 0) | 0, S4 = h4 - (e4 = -2097152 & J4) | 0, _4 = w4 - ((e4 >>> 0 > h4 >>> 0) + r4 | 0) | 0, w4 = PA(g6, 0, 654183, 0), e4 = t3, e4 = w4 >>> 0 > (r4 = w4 + (H4 >>> 5 & 2097151) | 0) >>> 0 ? e4 + 1 | 0 : e4, h4 = (w4 = r4) + (r4 = PA(q4, 0, 470296, 0)) | 0, w4 = t3 + e4 | 0, w4 = r4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(B4, j2, -997805, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + h4 | 0) >>> 0 ? w4 + 1 | 0 : w4, h4 = (e4 = r4) + (r4 = PA(E4, X2, 666643, 0)) | 0, e4 = t3 + w4 | 0, k4 = h4, h4 = r4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, s4 = (r4 = PA(g6, 0, 470296, 0)) + (e4 = (e4 = i3[A8 + 23 | 0]) << 16 & 2031616 | i3[A8 + 21 | 0] | i3[A8 + 22 | 0] << 8) | 0, r4 = t3, r4 = e4 >>> 0 > s4 >>> 0 ? r4 + 1 | 0 : r4, s4 = (w4 = PA(q4, 0, 666643, 0)) + s4 | 0, e4 = t3 + r4 | 0, r4 = PA(B4, j2, 654183, 0), w4 = t3 + (w4 >>> 0 > s4 >>> 0 ? e4 + 1 | 0 : e4) | 0, N4 = w4 = r4 >>> 0 > (H4 = r4 + s4 | 0) >>> 0 ? w4 + 1 | 0 : w4, m4 = w4 = w4 - ((H4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = (e4 = w4 >>> 21 | 0) + h4 | 0, r4 = e4 = (w4 = (2097151 & w4) << 11 | (s4 = H4 - -1048576 | 0) >>> 21) >>> 0 > (k4 = w4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4, K4 = w4 = e4 - ((k4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = S4, S4 = (2097151 & w4) << 11 | (h4 = k4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + _4 | 0, G4 = S4 = (w4 = S4 >>> 0 > (Y4 = e4 + S4 | 0) >>> 0 ? w4 + 1 | 0 : w4) - ((Y4 >>> 0 < 4293918720) - 1 | 0) | 0, l3 = Y4 - (e4 = -2097152 & (_4 = Y4 - -1048576 | 0)) | 0, O2 = w4 - ((e4 >>> 0 > Y4 >>> 0) + S4 | 0) | 0, e4 = PA(z2, P4, 136657, 0), r4 = t3 + r4 | 0, r4 = e4 >>> 0 > (w4 = e4 + k4 | 0) >>> 0 ? r4 + 1 | 0 : r4, b4 = w4 - (e4 = -2097152 & h4) | 0, U4 = r4 - ((e4 >>> 0 > w4 >>> 0) + K4 | 0) | 0, Y4 = M4 - (e4 = -2097152 & n4) | 0, p4 = F4 - ((e4 >>> 0 > M4 >>> 0) + p4 | 0) | 0, F4 = PA(I7, 0, 136657, 0), w4 = (e4 = i3[A8 + 40 | 0]) >>> 24 | 0, h4 = e4 << 8 | (n4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24) >>> 24, r4 = (e4 = i3[A8 + 41 | 0]) >>> 16 | 0, w4 = (r4 |= w4) >>> 3 | 0, r4 = (7 & r4) << 29 | (e4 = h4 | e4 << 16) >>> 3, e4 = w4 + t3 | 0, e4 = r4 >>> 0 > (h4 = r4 + F4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(Q4, 0, -683901, -1), e4 = t3 + e4 | 0, e4 = w4 >>> 0 > (r4 = w4 + h4 | 0) >>> 0 ? e4 + 1 | 0 : e4, k4 = r4, w4 = PA(I7, 0, -997805, -1), r4 = t3, r4 = w4 >>> 0 > (h4 = w4 + (n4 >>> 6 & 2097151) | 0) >>> 0 ? r4 + 1 | 0 : r4, n4 = (w4 = h4) + (h4 = PA(Q4, 0, 136657, 0)) | 0, w4 = t3 + r4 | 0, r4 = PA(E4, X2, -683901, -1), w4 = t3 + (h4 >>> 0 > n4 >>> 0 ? w4 + 1 | 0 : w4) | 0, S4 = w4 = r4 >>> 0 > (R4 = r4 + n4 | 0) >>> 0 ? w4 + 1 | 0 : w4, T2 = r4 = w4 - ((R4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = e4 + (w4 = r4 >> 21) | 0, n4 = e4 = (r4 = (2097151 & r4) << 11 | (M4 = R4 - -1048576 | 0) >>> 21) >>> 0 > (K4 = r4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4, L4 = e4 = e4 - ((K4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (w4 = e4 >> 21) + p4 | 0, u4 = w4 = (e4 = (r4 = (2097151 & e4) << 11 | (k4 = K4 - -1048576 | 0) >>> 21) + Y4 | 0) >>> 0 < r4 >>> 0 ? w4 + 1 | 0 : w4, x4 = e4, w4 = PA(e4, w4, -683901, -1), e4 = t3 + U4 | 0, d4 = r4 = w4 + b4 | 0, h4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, Y4 = H4 - (e4 = -2097152 & s4) | 0, p4 = N4 - ((4095 & m4) + (e4 >>> 0 > H4 >>> 0) | 0) | 0, H4 = PA(g6, 0, 666643, 0), e4 = (w4 = i3[A8 + 19 | 0]) >>> 24 | 0, s4 = w4 << 8 | (N4 = i3[A8 + 15 | 0] | i3[A8 + 16 | 0] << 8 | i3[A8 + 17 | 0] << 16 | i3[A8 + 18 | 0] << 24) >>> 24, r4 = e4, w4 = (7 & (r4 |= w4 = (e4 = i3[A8 + 20 | 0]) >>> 16 | 0)) << 29 | (w4 = (e4 <<= 16) | s4) >>> 3, r4 = t3 + (r4 >>> 3 | 0) | 0, r4 = w4 >>> 0 > (s4 = w4 + H4 | 0) >>> 0 ? r4 + 1 | 0 : r4, e4 = PA(B4, j2, 470296, 0), w4 = t3 + r4 | 0, e4 = e4 >>> 0 > (s4 = e4 + s4 | 0) >>> 0 ? w4 + 1 | 0 : w4, r4 = PA(B4, j2, 666643, 0), w4 = t3, H4 = w4 = r4 >>> 0 > (b4 = r4 + (N4 >>> 6 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, V2 = r4 = w4 - ((b4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = e4 + (w4 = r4 >>> 21 | 0) | 0, N4 = e4 = (r4 = (2097151 & r4) << 11 | (F4 = b4 - -1048576 | 0) >>> 21) >>> 0 > (U4 = r4 + s4 | 0) >>> 0 ? e4 + 1 | 0 : e4, Z2 = e4 = e4 - ((U4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (w4 = e4 >>> 21 | 0) + p4 | 0, w4 = (e4 = (2097151 & e4) << 11 | (s4 = U4 - -1048576 | 0) >>> 21) >>> 0 > (r4 = e4 + Y4 | 0) >>> 0 ? w4 + 1 | 0 : w4, p4 = (e4 = r4) + (r4 = PA(z2, P4, -997805, -1)) | 0, e4 = t3 + w4 | 0, e4 = r4 >>> 0 > p4 >>> 0 ? e4 + 1 | 0 : e4, m4 = w4 = K4 - (r4 = -2097152 & k4) | 0, o4 = k4 = n4 - ((r4 >>> 0 > K4 >>> 0) + L4 | 0) | 0, r4 = PA(x4, u4, 136657, 0), e4 = t3 + e4 | 0, e4 = r4 >>> 0 > (n4 = r4 + p4 | 0) >>> 0 ? e4 + 1 | 0 : e4, r4 = PA(w4, k4, -683901, -1), w4 = t3 + e4 | 0, n4 = w4 = r4 >>> 0 > (p4 = r4 + n4 | 0) >>> 0 ? w4 + 1 | 0 : w4, L4 = e4 = w4 - ((p4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (2097151 & e4) << 11 | (k4 = p4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + h4 | 0, d4 = w4 = (e4 = w4 >>> 0 > (K4 = w4 + d4 | 0) >>> 0 ? e4 + 1 | 0 : e4) - ((K4 >>> 0 < 4293918720) - 1 | 0) | 0, Y4 = (2097151 & w4) << 11 | (h4 = K4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + O2 | 0, D4 = l3 = Y4 + l3 | 0, Y4 = Y4 >>> 0 > l3 >>> 0 ? w4 + 1 | 0 : w4, a4 = K4 - (w4 = -2097152 & h4) | 0, y4 = e4 - ((w4 >>> 0 > K4 >>> 0) + d4 | 0) | 0, l3 = p4 - (e4 = -2097152 & k4) | 0, O2 = n4 - ((e4 >>> 0 > p4 >>> 0) + L4 | 0) | 0, r4 = (e4 = PA(z2, P4, 654183, 0)) + (U4 - (w4 = -2097152 & s4) | 0) | 0, w4 = t3 + (N4 - ((2147483647 & Z2) + (w4 >>> 0 > U4 >>> 0) | 0) | 0) | 0, w4 = e4 >>> 0 > r4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(x4, u4, -997805, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + r4 | 0) >>> 0 ? w4 + 1 | 0 : w4, h4 = (e4 = r4) + (r4 = PA(m4, o4, 136657, 0)) | 0, e4 = t3 + w4 | 0, d4 = h4, n4 = r4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, U4 = R4 - (e4 = -2097152 & M4) | 0, K4 = S4 - ((e4 >>> 0 > R4 >>> 0) + T2 | 0) | 0, N4 = PA(q4, 0, -683901, -1), e4 = (w4 = i3[A8 + 35 | 0]) >>> 24 | 0, h4 = w4 << 8 | (s4 = i3[A8 + 31 | 0] | i3[A8 + 32 | 0] << 8 | i3[A8 + 33 | 0] << 16 | i3[A8 + 34 | 0] << 24) >>> 24, r4 = e4, w4 = (e4 = i3[A8 + 36 | 0]) >>> 16 | 0, w4 |= r4, r4 = t3, r4 = (e4 = 2097151 & ((1 & w4) << 31 | (e4 = e4 << 16 | h4) >>> 1)) >>> 0 > (w4 = e4 + N4 | 0) >>> 0 ? r4 + 1 | 0 : r4, h4 = (e4 = PA(I7, 0, 654183, 0)) + w4 | 0, w4 = t3 + r4 | 0, w4 = e4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, r4 = PA(Q4, 0, -997805, -1), e4 = t3 + w4 | 0, e4 = r4 >>> 0 > (h4 = r4 + h4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(E4, X2, 136657, 0), e4 = t3 + e4 | 0, k4 = r4 = w4 + h4 | 0, h4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(g6, 0, -683901, -1), w4 = t3, w4 = e4 >>> 0 > (r4 = e4 + (s4 >>> 4 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, s4 = (e4 = PA(q4, 0, 136657, 0)) + r4 | 0, r4 = t3 + w4 | 0, r4 = e4 >>> 0 > s4 >>> 0 ? r4 + 1 | 0 : r4, e4 = PA(I7, 0, 470296, 0), w4 = t3 + r4 | 0, w4 = e4 >>> 0 > (s4 = e4 + s4 | 0) >>> 0 ? w4 + 1 | 0 : w4, s4 = (r4 = PA(Q4, 0, 654183, 0)) + s4 | 0, e4 = t3 + w4 | 0, w4 = PA(E4, X2, -997805, -1), e4 = t3 + (r4 >>> 0 > s4 >>> 0 ? e4 + 1 | 0 : e4) | 0, N4 = e4 = w4 >>> 0 > (S4 = w4 + s4 | 0) >>> 0 ? e4 + 1 | 0 : e4, f4 = w4 = e4 - ((S4 >>> 0 < 4293918720) - 1 | 0) | 0, r4 = (e4 = w4 >> 21) + h4 | 0, p4 = w4 = (r4 = (w4 = (2097151 & w4) << 11 | (s4 = S4 - -1048576 | 0) >>> 21) >>> 0 > (M4 = w4 + k4 | 0) >>> 0 ? r4 + 1 | 0 : r4) - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = (e4 = w4 >> 21) + K4 | 0, L4 = e4 = (w4 = (h4 = (2097151 & w4) << 11 | (k4 = M4 - -1048576 | 0) >>> 21) + U4 | 0) >>> 0 < h4 >>> 0 ? e4 + 1 | 0 : e4, h4 = d4, d4 = w4, e4 = PA(w4, e4, -683901, -1), w4 = t3 + n4 | 0, K4 = h4 = h4 + e4 | 0, h4 = e4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, n4 = (e4 = PA(z2, P4, 470296, 0)) + (b4 - (w4 = -2097152 & F4) | 0) | 0, w4 = t3 + (H4 - ((2047 & V2) + (w4 >>> 0 > b4 >>> 0) | 0) | 0) | 0, w4 = e4 >>> 0 > n4 >>> 0 ? w4 + 1 | 0 : w4, F4 = (e4 = n4) + (n4 = PA(x4, u4, 654183, 0)) | 0, e4 = t3 + w4 | 0, e4 = n4 >>> 0 > F4 >>> 0 ? e4 + 1 | 0 : e4, n4 = PA(m4, o4, -997805, -1), w4 = t3 + e4 | 0, w4 = n4 >>> 0 > (F4 = n4 + F4 | 0) >>> 0 ? w4 + 1 | 0 : w4, R4 = k4 = M4 - (e4 = -2097152 & k4) | 0, c4 = n4 = r4 - ((e4 >>> 0 > M4 >>> 0) + p4 | 0) | 0, r4 = PA(d4, L4, 136657, 0), e4 = t3 + w4 | 0, e4 = r4 >>> 0 > (F4 = r4 + F4 | 0) >>> 0 ? e4 + 1 | 0 : e4, r4 = PA(k4, n4, -683901, -1), w4 = t3 + e4 | 0, n4 = w4 = r4 >>> 0 > (H4 = r4 + F4 | 0) >>> 0 ? w4 + 1 | 0 : w4, U4 = e4 = w4 - ((H4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (2097151 & e4) << 11 | (k4 = H4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + h4 | 0, K4 = w4 = (e4 = w4 >>> 0 > (F4 = w4 + K4 | 0) >>> 0 ? e4 + 1 | 0 : e4) - ((F4 >>> 0 < 4293918720) - 1 | 0) | 0, M4 = (2097151 & w4) << 11 | (h4 = F4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + O2 | 0, T2 = p4 = M4 + l3 | 0, p4 = M4 >>> 0 > p4 >>> 0 ? w4 + 1 | 0 : w4, V2 = F4 - (w4 = -2097152 & h4) | 0, Z2 = e4 - ((w4 >>> 0 > F4 >>> 0) + K4 | 0) | 0, l3 = H4 - (e4 = -2097152 & k4) | 0, O2 = n4 - ((e4 >>> 0 > H4 >>> 0) + U4 | 0) | 0, n4 = PA(z2, P4, 666643, 0), e4 = (w4 = i3[A8 + 14 | 0]) >>> 24 | 0, h4 = w4 << 8 | (K4 = i3[A8 + 10 | 0] | i3[A8 + 11 | 0] << 8 | i3[A8 + 12 | 0] << 16 | i3[A8 + 13 | 0] << 24) >>> 24, r4 = e4, w4 = (e4 = i3[A8 + 15 | 0]) >>> 16 | 0, w4 |= r4, r4 = t3, r4 = (e4 = 2097151 & ((1 & w4) << 31 | (e4 = e4 << 16 | h4) >>> 1)) >>> 0 > (w4 = e4 + n4 | 0) >>> 0 ? r4 + 1 | 0 : r4, h4 = (e4 = w4) + (w4 = PA(x4, u4, 470296, 0)) | 0, e4 = t3 + r4 | 0, e4 = w4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(m4, o4, 654183, 0), e4 = t3 + e4 | 0, e4 = w4 >>> 0 > (r4 = w4 + h4 | 0) >>> 0 ? e4 + 1 | 0 : e4, h4 = (w4 = r4) + (r4 = PA(d4, L4, -997805, -1)) | 0, w4 = t3 + e4 | 0, w4 = r4 >>> 0 > h4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(R4, c4, 136657, 0), w4 = t3 + w4 | 0, H4 = r4 = e4 + h4 | 0, h4 = e4 >>> 0 > r4 >>> 0 ? w4 + 1 | 0 : w4, s4 = S4 - (e4 = -2097152 & s4) | 0, n4 = N4 - ((e4 >>> 0 > S4 >>> 0) + f4 | 0) | 0, r4 = PA(g6, 0, 136657, 0), e4 = t3, e4 = (w4 = (i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24) >>> 7 & 2097151) >>> 0 > (r4 = w4 + r4 | 0) >>> 0 ? e4 + 1 | 0 : e4, k4 = (w4 = r4) + (r4 = PA(q4, 0, -997805, -1)) | 0, w4 = t3 + e4 | 0, w4 = r4 >>> 0 > k4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(B4, j2, -683901, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + k4 | 0) >>> 0 ? w4 + 1 | 0 : w4, k4 = (e4 = PA(I7, 0, 666643, 0)) + r4 | 0, r4 = t3 + w4 | 0, r4 = e4 >>> 0 > k4 >>> 0 ? r4 + 1 | 0 : r4, w4 = PA(Q4, 0, 470296, 0), e4 = t3 + r4 | 0, e4 = w4 >>> 0 > (k4 = w4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(E4, X2, 654183, 0), e4 = t3 + e4 | 0, w4 = (v4 >> 21) + (w4 >>> 0 > (r4 = w4 + k4 | 0) >>> 0 ? e4 + 1 | 0 : e4) | 0, M4 = w4 = (k4 = (2097151 & v4) << 11 | J4 >>> 21) >>> 0 > (J4 = k4 + r4 | 0) >>> 0 ? w4 + 1 | 0 : w4, v4 = e4 = w4 - ((J4 >>> 0 < 4293918720) - 1 | 0) | 0, k4 = (2097151 & e4) << 11 | (F4 = J4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + n4 | 0, b4 = e4 = (w4 = k4 + s4 | 0) >>> 0 < k4 >>> 0 ? e4 + 1 | 0 : e4, U4 = w4, w4 = PA(w4, e4, -683901, -1), e4 = t3 + h4 | 0, k4 = r4 = w4 + H4 | 0, h4 = w4 >>> 0 > r4 >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(x4, u4, 666643, 0), w4 = t3, w4 = e4 >>> 0 > (r4 = e4 + (K4 >>> 4 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(m4, o4, 470296, 0), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + r4 | 0) >>> 0 ? w4 + 1 | 0 : w4, n4 = (e4 = PA(d4, L4, 654183, 0)) + r4 | 0, r4 = t3 + w4 | 0, r4 = e4 >>> 0 > n4 >>> 0 ? r4 + 1 | 0 : r4, w4 = PA(R4, c4, -997805, -1), e4 = t3 + r4 | 0, e4 = w4 >>> 0 > (n4 = w4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, w4 = PA(U4, b4, 136657, 0), e4 = t3 + e4 | 0, N4 = e4 = w4 >>> 0 > (S4 = w4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, u4 = w4 = e4 - ((S4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = k4, k4 = (2097151 & w4) << 11 | (s4 = S4 - -1048576 | 0) >>> 21, w4 = (w4 >> 21) + h4 | 0, x4 = h4 = (w4 = (r4 = e4 + k4 | 0) >>> 0 < k4 >>> 0 ? w4 + 1 | 0 : w4) - ((r4 >>> 0 < 4293918720) - 1 | 0) | 0, e4 = (e4 = h4 >> 21) + O2 | 0, z2 = k4 = (h4 = (2097151 & h4) << 11 | (n4 = r4 - -1048576 | 0) >>> 21) + l3 | 0, H4 = h4 >>> 0 > k4 >>> 0 ? e4 + 1 | 0 : e4, k4 = r4, r4 = w4, h4 = (J4 - (w4 = -2097152 & F4) | 0) + (F4 = (2097151 & G4) << 11 | _4 >>> 21) | 0, w4 = (M4 - ((w4 >>> 0 > J4 >>> 0) + v4 | 0) | 0) + (G4 >> 21) | 0, K4 = w4 = h4 >>> 0 < F4 >>> 0 ? w4 + 1 | 0 : w4, q4 = w4 = w4 - ((h4 >>> 0 < 4293918720) - 1 | 0) | 0, _4 = e4 = w4 >> 21, e4 = PA(P4 = (2097151 & w4) << 11 | (v4 = h4 - -1048576 | 0) >>> 21, e4, -683901, -1), r4 = t3 + r4 | 0, r4 = e4 >>> 0 > (w4 = e4 + k4 | 0) >>> 0 ? r4 + 1 | 0 : r4, j2 = w4 - (e4 = -2097152 & n4) | 0, X2 = r4 - ((e4 >>> 0 > w4 >>> 0) + x4 | 0) | 0, e4 = PA(P4, _4, 136657, 0), w4 = N4 + t3 | 0, x4 = (r4 = e4 + S4 | 0) - (e4 = -2097152 & s4) | 0, J4 = (w4 = r4 >>> 0 < S4 >>> 0 ? w4 + 1 | 0 : w4) - ((e4 >>> 0 > r4 >>> 0) + u4 | 0) | 0, w4 = PA(m4, o4, 666643, 0), r4 = t3, r4 = (e4 = (i3[A8 + 7 | 0] | i3[A8 + 8 | 0] << 8 | i3[A8 + 9 | 0] << 16 | i3[A8 + 10 | 0] << 24) >>> 7 & 2097151) >>> 0 > (w4 = e4 + w4 | 0) >>> 0 ? r4 + 1 | 0 : r4, k4 = (e4 = PA(d4, L4, 470296, 0)) + w4 | 0, w4 = t3 + r4 | 0, w4 = e4 >>> 0 > k4 >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(R4, c4, 654183, 0), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + k4 | 0) >>> 0 ? w4 + 1 | 0 : w4, k4 = (e4 = r4) + (r4 = PA(U4, b4, -997805, -1)) | 0, e4 = t3 + w4 | 0, F4 = k4, k4 = r4 >>> 0 > k4 >>> 0 ? e4 + 1 | 0 : e4, N4 = PA(d4, L4, 666643, 0), e4 = (w4 = i3[A8 + 6 | 0]) >>> 24 | 0, n4 = w4 << 8 | (u4 = i3[A8 + 2 | 0] | i3[A8 + 3 | 0] << 8 | i3[A8 + 4 | 0] << 16 | i3[A8 + 5 | 0] << 24) >>> 24, r4 = e4, w4 = (e4 = i3[A8 + 7 | 0]) >>> 16 | 0, w4 = 2097151 & ((3 & (w4 |= r4)) << 30 | (e4 = e4 << 16 | n4) >>> 2), e4 = t3, e4 = w4 >>> 0 > (r4 = w4 + N4 | 0) >>> 0 ? e4 + 1 | 0 : e4, n4 = (w4 = PA(R4, c4, 470296, 0)) + r4 | 0, r4 = t3 + e4 | 0, r4 = w4 >>> 0 > n4 >>> 0 ? r4 + 1 | 0 : r4, w4 = PA(U4, b4, 654183, 0), e4 = t3 + r4 | 0, N4 = e4 = w4 >>> 0 > (M4 = w4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, G4 = e4 = e4 - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, w4 = (r4 = e4 >> 21) + k4 | 0, S4 = e4 = (w4 = (e4 = (2097151 & e4) << 11 | (s4 = M4 - -1048576 | 0) >>> 21) >>> 0 > (n4 = e4 + F4 | 0) >>> 0 ? w4 + 1 | 0 : w4) - ((n4 >>> 0 < 4293918720) - 1 | 0) | 0, F4 = (2097151 & e4) << 11 | (k4 = n4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + J4 | 0, x4 = d4 = F4 + x4 | 0, F4 = F4 >>> 0 > d4 >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(P4, _4, -997805, -1), w4 = t3 + w4 | 0, w4 = e4 >>> 0 > (r4 = e4 + n4 | 0) >>> 0 ? w4 + 1 | 0 : w4, m4 = r4 - (e4 = -2097152 & k4) | 0, L4 = w4 - ((e4 >>> 0 > r4 >>> 0) + S4 | 0) | 0, w4 = PA(P4, _4, 654183, 0), e4 = N4 + t3 | 0, d4 = (r4 = w4 + M4 | 0) - (w4 = -2097152 & s4) | 0, J4 = (e4 = r4 >>> 0 < M4 >>> 0 ? e4 + 1 | 0 : e4) - ((w4 >>> 0 > r4 >>> 0) + G4 | 0) | 0, e4 = PA(R4, c4, 666643, 0), w4 = t3, w4 = e4 >>> 0 > (r4 = e4 + (u4 >>> 5 & 2097151) | 0) >>> 0 ? w4 + 1 | 0 : w4, e4 = PA(U4, b4, 470296, 0), w4 = t3 + w4 | 0, n4 = r4 = e4 + r4 | 0, r4 = e4 >>> 0 > r4 >>> 0 ? w4 + 1 | 0 : w4, k4 = PA(U4, b4, 666643, 0), w4 = (e4 = i3[A8 + 2 | 0]) << 16 & 2031616 | i3[0 | A8] | i3[A8 + 1 | 0] << 8, e4 = t3, N4 = e4 = w4 >>> 0 > (S4 = k4 + w4 | 0) >>> 0 ? e4 + 1 | 0 : e4, b4 = e4 = e4 - ((S4 >>> 0 < 4293918720) - 1 | 0) | 0, k4 = (2097151 & e4) << 11 | (s4 = S4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + r4 | 0, r4 = e4 = k4 >>> 0 > (M4 = k4 + n4 | 0) >>> 0 ? e4 + 1 | 0 : e4, G4 = e4 = e4 - ((M4 >>> 0 < 4293918720) - 1 | 0) | 0, k4 = (2097151 & e4) << 11 | (n4 = M4 - -1048576 | 0) >>> 21, e4 = (e4 >> 21) + J4 | 0, k4 = k4 >>> 0 > (U4 = k4 + d4 | 0) >>> 0 ? e4 + 1 | 0 : e4, e4 = PA(P4, _4, 470296, 0), r4 = r4 + t3 | 0, r4 = (w4 = e4 + M4 | 0) >>> 0 < M4 >>> 0 ? r4 + 1 | 0 : r4, M4 = w4 - (e4 = -2097152 & n4) | 0, n4 = r4 - ((e4 >>> 0 > w4 >>> 0) + G4 | 0) | 0, w4 = PA(P4, _4, 666643, 0), e4 = t3 + (N4 - (((r4 = -2097152 & s4) >>> 0 > S4 >>> 0) + b4 | 0) | 0) | 0, w4 = (r4 = (e4 = w4 >>> 0 > (J4 = w4 + (S4 - r4 | 0) | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + n4 | 0, e4 = (e4 = (w4 = (e4 = (2097151 & e4) << 11 | J4 >>> 21) >>> 0 > (G4 = e4 + M4 | 0) >>> 0 ? w4 + 1 | 0 : w4) >> 21) + k4 | 0, w4 = (w4 = (e4 = (w4 = (2097151 & w4) << 11 | G4 >>> 21) >>> 0 > (_4 = w4 + U4 | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + L4 | 0, r4 = (e4 = (w4 = (e4 = (2097151 & e4) << 11 | _4 >>> 21) >>> 0 > (k4 = e4 + m4 | 0) >>> 0 ? w4 + 1 | 0 : w4) >> 21) + F4 | 0, e4 = (w4 = (r4 = (w4 = (2097151 & w4) << 11 | k4 >>> 21) >>> 0 > (S4 = w4 + x4 | 0) >>> 0 ? r4 + 1 | 0 : r4) >> 21) + X2 | 0, w4 = (r4 = (e4 = (r4 = (2097151 & r4) << 11 | S4 >>> 21) >>> 0 > (M4 = r4 + j2 | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + H4 | 0, H4 = n4 = (e4 = (2097151 & e4) << 11 | M4 >>> 21) + z2 | 0, e4 = (e4 = (w4 = e4 >>> 0 > n4 >>> 0 ? w4 + 1 | 0 : w4) >> 21) + Z2 | 0, w4 = (w4 = (e4 = (w4 = (2097151 & w4) << 11 | n4 >>> 21) >>> 0 > (F4 = w4 + V2 | 0) >>> 0 ? e4 + 1 | 0 : e4) >> 21) + p4 | 0, r4 = (e4 = (w4 = (e4 = (2097151 & e4) << 11 | F4 >>> 21) >>> 0 > (N4 = e4 + T2 | 0) >>> 0 ? w4 + 1 | 0 : w4) >> 21) + y4 | 0, e4 = (w4 = (r4 = (w4 = (2097151 & w4) << 11 | N4 >>> 21) >>> 0 > (s4 = w4 + a4 | 0) >>> 0 ? r4 + 1 | 0 : r4) >> 21) + Y4 | 0, v4 = (p4 = h4 - (w4 = -2097152 & v4) | 0) + ((2097151 & (e4 = (r4 = (2097151 & r4) << 11 | s4 >>> 21) >>> 0 > (n4 = r4 + D4 | 0) >>> 0 ? e4 + 1 | 0 : e4)) << 11 | n4 >>> 21) | 0, e4 = (K4 - ((w4 >>> 0 > h4 >>> 0) + q4 | 0) | 0) + (e4 >> 21) | 0, K4 = w4 = (e4 = p4 >>> 0 > v4 >>> 0 ? e4 + 1 | 0 : e4) >> 21, J4 = (e4 = PA(Y4 = (2097151 & e4) << 11 | v4 >>> 21, w4, 666643, 0)) + (w4 = 2097151 & J4) | 0, e4 = t3, h4 = e4 = w4 >>> 0 > J4 >>> 0 ? e4 + 1 | 0 : e4, C3[0 | A8] = J4, C3[A8 + 1 | 0] = (255 & e4) << 24 | J4 >>> 8, e4 = 2097151 & G4, w4 = PA(Y4, K4, 470296, 0) + e4 | 0, r4 = t3, e4 = (h4 >> 21) + (e4 >>> 0 > w4 >>> 0 ? r4 + 1 | 0 : r4) | 0, e4 = (p4 = (2097151 & h4) << 11 | J4 >>> 21) >>> 0 > (G4 = p4 + w4 | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 4 | 0] = (2047 & e4) << 21 | G4 >>> 11, w4 = e4, r4 = G4, C3[A8 + 3 | 0] = (7 & e4) << 29 | r4 >>> 3, C3[A8 + 2 | 0] = 31 & ((65535 & h4) << 16 | J4 >>> 16) | r4 << 5, h4 = 2097151 & _4, _4 = PA(Y4, K4, 654183, 0) + h4 | 0, e4 = t3, G4 = (2097151 & w4) << 11 | r4 >>> 21, w4 = (w4 >> 21) + (h4 = h4 >>> 0 > _4 >>> 0 ? e4 + 1 | 0 : e4) | 0, e4 = w4 = (_4 = G4 + _4 | 0) >>> 0 < G4 >>> 0 ? w4 + 1 | 0 : w4, C3[A8 + 6 | 0] = (63 & e4) << 26 | _4 >>> 6, h4 = _4, _4 = 0, C3[A8 + 5 | 0] = _4 << 13 | (1572864 & r4) >>> 19 | h4 << 2, r4 = 2097151 & k4, k4 = PA(Y4, K4, -997805, -1) + r4 | 0, w4 = t3, w4 = r4 >>> 0 > k4 >>> 0 ? w4 + 1 | 0 : w4, _4 = (2097151 & (r4 = e4)) << 11 | h4 >>> 21, r4 = (e4 >>= 21) + w4 | 0, r4 = (k4 = _4 + k4 | 0) >>> 0 < _4 >>> 0 ? r4 + 1 | 0 : r4, C3[A8 + 9 | 0] = (511 & r4) << 23 | k4 >>> 9, C3[A8 + 8 | 0] = (1 & r4) << 31 | k4 >>> 1, w4 = 0, C3[A8 + 7 | 0] = w4 << 18 | (2080768 & h4) >>> 14 | k4 << 7, w4 = 2097151 & S4, h4 = PA(Y4, K4, 136657, 0) + w4 | 0, e4 = t3, e4 = w4 >>> 0 > h4 >>> 0 ? e4 + 1 | 0 : e4, S4 = (2097151 & (w4 = r4)) << 11 | k4 >>> 21, w4 = e4 + (r4 = w4 >> 21) | 0, w4 = (h4 = S4 + h4 | 0) >>> 0 < S4 >>> 0 ? w4 + 1 | 0 : w4, C3[A8 + 12 | 0] = (4095 & w4) << 20 | h4 >>> 12, r4 = h4, C3[A8 + 11 | 0] = (15 & w4) << 28 | r4 >>> 4, h4 = 0, C3[A8 + 10 | 0] = h4 << 15 | (1966080 & k4) >>> 17 | r4 << 4, h4 = 2097151 & M4, k4 = PA(Y4, K4, -683901, -1) + h4 | 0, e4 = t3, e4 = h4 >>> 0 > k4 >>> 0 ? e4 + 1 | 0 : e4, h4 = w4, w4 = e4 + (w4 >>= 21) | 0, w4 = (h4 = (d4 = k4) + (k4 = (2097151 & h4) << 11 | r4 >>> 21) | 0) >>> 0 < k4 >>> 0 ? w4 + 1 | 0 : w4, C3[A8 + 14 | 0] = (127 & w4) << 25 | h4 >>> 7, k4 = 0, C3[A8 + 13 | 0] = k4 << 12 | (1048576 & r4) >>> 20 | h4 << 1, e4 = w4 >> 21, r4 = (w4 = (2097151 & w4) << 11 | h4 >>> 21) >>> 0 > (k4 = w4 + (2097151 & H4) | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 17 | 0] = (1023 & r4) << 22 | k4 >>> 10, C3[A8 + 16 | 0] = (3 & r4) << 30 | k4 >>> 2, w4 = 0, C3[A8 + 15 | 0] = w4 << 17 | (2064384 & h4) >>> 15 | k4 << 6, e4 = r4 >> 21, e4 = (w4 = (2097151 & r4) << 11 | k4 >>> 21) >>> 0 > (r4 = w4 + (2097151 & F4) | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 20 | 0] = (8191 & e4) << 19 | r4 >>> 13, C3[A8 + 19 | 0] = (31 & e4) << 27 | r4 >>> 5, h4 = (w4 = 2097151 & N4) + (N4 = (2097151 & e4) << 11 | r4 >>> 21) | 0, w4 = e4 >> 21, w4 = h4 >>> 0 < N4 >>> 0 ? w4 + 1 | 0 : w4, N4 = h4, C3[A8 + 21 | 0] = h4, F4 = 0, C3[A8 + 18 | 0] = F4 << 14 | (1835008 & k4) >>> 18 | r4 << 3, C3[A8 + 22 | 0] = (255 & w4) << 24 | h4 >>> 8, r4 = w4 >> 21, r4 = (h4 = (k4 = (2097151 & w4) << 11 | h4 >>> 21) + (2097151 & s4) | 0) >>> 0 < k4 >>> 0 ? r4 + 1 | 0 : r4, C3[A8 + 25 | 0] = (2047 & r4) << 21 | h4 >>> 11, C3[A8 + 24 | 0] = (7 & r4) << 29 | h4 >>> 3, C3[A8 + 23 | 0] = 31 & ((65535 & w4) << 16 | N4 >>> 16) | h4 << 5, e4 = r4 >> 21, e4 = (w4 = (2097151 & r4) << 11 | h4 >>> 21) >>> 0 > (r4 = w4 + (2097151 & n4) | 0) >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 27 | 0] = (63 & e4) << 26 | r4 >>> 6, k4 = 0, C3[A8 + 26 | 0] = k4 << 13 | (1572864 & h4) >>> 19 | r4 << 2, w4 = e4, e4 >>= 21, w4 = (h4 = (n4 = (2097151 & w4) << 11 | r4 >>> 21) + (k4 = 2097151 & v4) | 0) >>> 0 < k4 >>> 0 ? e4 + 1 | 0 : e4, C3[A8 + 31 | 0] = (131071 & w4) << 15 | h4 >>> 17, e4 = h4, C3[A8 + 30 | 0] = (511 & w4) << 23 | e4 >>> 9, h4 = 0, C3[A8 + 28 | 0] = h4 << 18 | (2080768 & r4) >>> 14 | e4 << 7, C3[A8 + 29 | 0] = n4 + v4 >>> 1; + } + function F3(A8, I7, g6, B4, Q4, o4) { + var D4, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, l3 = 0, z2 = 0, j2 = 0, V2 = 0, Z2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0; + for (r3 = D4 = r3 - 592 | 0, p4 = -1, S4 = A8 + 32 | 0, F4 = 32, N4 = 1; H4 = i3[2656 + (w4 = F4 - 1 | 0) | 0], f4 |= (w4 = ((y4 = i3[w4 + S4 | 0]) ^ H4) - 1 >> 8 & N4) & (t4 = i3[S4 + (F4 = F4 - 2 | 0) | 0]) - (e4 = i3[F4 + 2656 | 0]) >> 8 | y4 - H4 >> 8 & N4, N4 = w4 & (e4 ^ t4) - 1 >> 8, F4; ) ; + if (255 & f4 && !(KA(A8) | !(~((127 & ~i3[Q4 + 31 | 0] | i3[Q4 + 1 | 0] & i3[Q4 + 2 | 0] & i3[Q4 + 3 | 0] & i3[Q4 + 4 | 0] & i3[Q4 + 5 | 0] & i3[Q4 + 6 | 0] & i3[Q4 + 7 | 0] & i3[Q4 + 8 | 0] & i3[Q4 + 9 | 0] & i3[Q4 + 10 | 0] & i3[Q4 + 11 | 0] & i3[Q4 + 12 | 0] & i3[Q4 + 13 | 0] & i3[Q4 + 14 | 0] & i3[Q4 + 15 | 0] & i3[Q4 + 16 | 0] & i3[Q4 + 17 | 0] & i3[Q4 + 18 | 0] & i3[Q4 + 19 | 0] & i3[Q4 + 20 | 0] & i3[Q4 + 21 | 0] & i3[Q4 + 22 | 0] & i3[Q4 + 23 | 0] & i3[Q4 + 24 | 0] & i3[Q4 + 25 | 0] & i3[Q4 + 26 | 0] & i3[Q4 + 27 | 0] & i3[Q4 + 28 | 0] & i3[Q4 + 30 | 0] & i3[Q4 + 29 | 0] ^ 255) - 1 & 236 - i3[0 | Q4]) >>> 8 & 1) || KA(Q4) || q3(w4 = D4 + 128 | 0, Q4))) { + for (MA(y4 = D4 + 384 | 0), o4 && W(y4, 35120, 34, 0), W(y4, A8, 32, 0), W(y4, Q4, 32, 0), W(y4, I7, g6, B4), v3(y4, g6 = D4 + 320 | 0), s3(g6), B4 = D4 + 8 | 0, Q4 = 0, I7 = 0, r3 = a4 = r3 - 2272 | 0; o4 = a4 + 2016 | 0, y4 = i3[g6 + (Q4 >>> 3 | 0) | 0], C3[o4 + Q4 | 0] = y4 >>> (6 & Q4) & 1, C3[(f4 = o4) + (o4 = 1 | Q4) | 0] = y4 >>> (7 & o4) & 1, 256 != (0 | (Q4 = Q4 + 2 | 0)); ) ; + for (; ; ) { + I7 = (g6 = I7) + 1 | 0; + A: if (!(g6 >>> 0 > 254) && i3[0 | (f4 = (Q4 = a4 + 2016 | 0) + g6 | 0)]) { + I: if (Q4 = C3[0 | (e4 = I7 + Q4 | 0)]) if ((0 | (Q4 = (y4 = Q4 << 1) + (o4 = C3[0 | f4]) | 0)) <= 15) C3[0 | f4] = Q4, C3[0 | e4] = 0; + else { + if ((0 | (Q4 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = Q4, Q4 = I7; ; ) { + if (!i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + C3[0 | o4] = 1; + break I; + } + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, !o4) break; + } + } + if (!(g6 >>> 0 > 253)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 2 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 2) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (253 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 3 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 3) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 251)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 4 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 4) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (251 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 5 | 0) + (a4 + 2016 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 5) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 249) && (g6 = C3[0 | (e4 = (Q4 = g6 + 6 | 0) + (a4 + 2016 | 0) | 0)])) if ((0 | (g6 = (y4 = g6 << 6) + (o4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (g6 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = g6; ; ) { + if (i3[0 | (g6 = (a4 + 2016 | 0) + Q4 | 0)]) { + if (C3[0 | g6] = 0, g6 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, g6) continue; + break A; + } + break; + } + C3[0 | g6] = 1; + } else C3[0 | f4] = g6, C3[0 | e4] = 0; + } + } + } + } + } + if (256 == (0 | I7)) break; + } + for (Q4 = 0; I7 = a4 + 1760 | 0, g6 = i3[S4 + (Q4 >>> 3 | 0) | 0], C3[I7 + Q4 | 0] = g6 >>> (6 & Q4) & 1, C3[(o4 = I7) + (I7 = 1 | Q4) | 0] = g6 >>> (7 & I7) & 1, 256 != (0 | (Q4 = Q4 + 2 | 0)); ) ; + for (I7 = 0; ; ) { + I7 = (g6 = I7) + 1 | 0; + A: if (!(g6 >>> 0 > 254) && i3[0 | (f4 = (Q4 = a4 + 1760 | 0) + g6 | 0)]) { + I: if (Q4 = C3[0 | (e4 = I7 + Q4 | 0)]) if ((0 | (Q4 = (y4 = Q4 << 1) + (o4 = C3[0 | f4]) | 0)) <= 15) C3[0 | f4] = Q4, C3[0 | e4] = 0; + else { + if ((0 | (Q4 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = Q4, Q4 = I7; ; ) { + if (!i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + C3[0 | o4] = 1; + break I; + } + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, !o4) break; + } + } + if (!(g6 >>> 0 > 253)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 2 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 2) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (253 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 3 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 3) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 251)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 4 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 4) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (251 != (0 | g6)) { + I: if (o4 = C3[0 | (t4 = (Q4 = g6 + 5 | 0) + (a4 + 1760 | 0) | 0)]) if ((0 | (o4 = (e4 = o4 << 5) + (y4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (o4 = y4 - e4 | 0)) < -15) break A; + for (C3[0 | f4] = o4; ; ) { + if (i3[0 | (o4 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | o4] = 0, o4 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, o4) continue; + break I; + } + break; + } + C3[0 | o4] = 1; + } else C3[0 | f4] = o4, C3[0 | t4] = 0; + if (!(g6 >>> 0 > 249) && (g6 = C3[0 | (e4 = (Q4 = g6 + 6 | 0) + (a4 + 1760 | 0) | 0)])) if ((0 | (g6 = (y4 = g6 << 6) + (o4 = C3[0 | f4]) | 0)) >= 16) { + if ((0 | (g6 = o4 - y4 | 0)) < -15) break A; + for (C3[0 | f4] = g6; ; ) { + if (i3[0 | (g6 = (a4 + 1760 | 0) + Q4 | 0)]) { + if (C3[0 | g6] = 0, g6 = Q4 >>> 0 < 255, Q4 = Q4 + 1 | 0, g6) continue; + break A; + } + break; + } + C3[0 | g6] = 1; + } else C3[0 | f4] = g6, C3[0 | e4] = 0; + } + } + } + } + } + if (256 == (0 | I7)) break; + } + for (DA(Q4 = a4 + 480 | 0, w4), I7 = E3[w4 + 36 >> 2], E3[a4 + 192 >> 2] = E3[w4 + 32 >> 2], E3[a4 + 196 >> 2] = I7, I7 = E3[w4 + 28 >> 2], E3[a4 + 184 >> 2] = E3[w4 + 24 >> 2], E3[a4 + 188 >> 2] = I7, I7 = E3[w4 + 20 >> 2], E3[a4 + 176 >> 2] = E3[w4 + 16 >> 2], E3[a4 + 180 >> 2] = I7, I7 = E3[w4 + 12 >> 2], E3[a4 + 168 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 172 >> 2] = I7, I7 = E3[w4 + 4 >> 2], E3[a4 + 160 >> 2] = E3[w4 >> 2], E3[a4 + 164 >> 2] = I7, I7 = E3[w4 + 52 >> 2], E3[a4 + 208 >> 2] = E3[w4 + 48 >> 2], E3[a4 + 212 >> 2] = I7, I7 = E3[w4 + 60 >> 2], E3[a4 + 216 >> 2] = E3[w4 + 56 >> 2], E3[a4 + 220 >> 2] = I7, I7 = E3[4 + (g6 = w4 - -64 | 0) >> 2], E3[a4 + 224 >> 2] = E3[g6 >> 2], E3[a4 + 228 >> 2] = I7, I7 = E3[w4 + 76 >> 2], E3[a4 + 232 >> 2] = E3[w4 + 72 >> 2], E3[a4 + 236 >> 2] = I7, I7 = E3[w4 + 44 >> 2], E3[a4 + 200 >> 2] = E3[w4 + 40 >> 2], E3[a4 + 204 >> 2] = I7, I7 = E3[w4 + 92 >> 2], E3[a4 + 248 >> 2] = E3[w4 + 88 >> 2], E3[a4 + 252 >> 2] = I7, I7 = E3[w4 + 100 >> 2], E3[a4 + 256 >> 2] = E3[w4 + 96 >> 2], E3[a4 + 260 >> 2] = I7, I7 = E3[w4 + 108 >> 2], E3[a4 + 264 >> 2] = E3[w4 + 104 >> 2], E3[a4 + 268 >> 2] = I7, I7 = E3[w4 + 116 >> 2], E3[a4 + 272 >> 2] = E3[w4 + 112 >> 2], E3[a4 + 276 >> 2] = I7, I7 = E3[w4 + 84 >> 2], E3[a4 + 240 >> 2] = E3[w4 + 80 >> 2], E3[a4 + 244 >> 2] = I7, _3(o4 = a4 + 320 | 0, g6 = a4 + 160 | 0), M3(a4, o4, h4 = a4 + 440 | 0), M3(a4 + 40 | 0, k4 = a4 + 360 | 0, n4 = a4 + 400 | 0), M3(a4 + 80 | 0, n4, h4), M3(a4 + 120 | 0, o4, k4), X(o4, a4, Q4), M3(g6, o4, h4), M3(G4 = a4 + 200 | 0, k4, n4), M3(J4 = a4 + 240 | 0, n4, h4), M3(K4 = a4 + 280 | 0, o4, k4), DA(I7 = a4 + 640 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 800 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 960 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 1120 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 1280 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(I7 = a4 + 1440 | 0, g6), X(o4, a4, I7), M3(g6, o4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, o4, k4), DA(a4 + 1600 | 0, g6), E3[B4 + 32 >> 2] = 0, E3[B4 + 36 >> 2] = 0, E3[B4 + 24 >> 2] = 0, E3[B4 + 28 >> 2] = 0, E3[B4 + 16 >> 2] = 0, E3[B4 + 20 >> 2] = 0, E3[B4 + 8 >> 2] = 0, E3[B4 + 12 >> 2] = 0, E3[B4 >> 2] = 0, E3[B4 + 4 >> 2] = 0, E3[B4 + 44 >> 2] = 0, E3[B4 + 48 >> 2] = 0, E3[B4 + 40 >> 2] = 1, E3[B4 + 52 >> 2] = 0, E3[B4 + 56 >> 2] = 0, E3[B4 + 60 >> 2] = 0, E3[B4 + 64 >> 2] = 0, E3[B4 + 68 >> 2] = 0, E3[B4 + 72 >> 2] = 0, E3[B4 + 84 >> 2] = 0, E3[B4 + 88 >> 2] = 0, E3[B4 + 76 >> 2] = 0, E3[B4 + 80 >> 2] = 1, E3[B4 + 92 >> 2] = 0, E3[B4 + 96 >> 2] = 0, E3[B4 + 100 >> 2] = 0, E3[B4 + 104 >> 2] = 0, E3[B4 + 108 >> 2] = 0, E3[B4 + 112 >> 2] = 0, E3[B4 + 116 >> 2] = 0, $2 = B4 + 80 | 0, AA2 = B4 + 40 | 0, I7 = 255; ; ) { + A: { + I: { + if (!i3[(g6 = a4 + 2016 | 0) + I7 | 0] && !i3[(Q4 = a4 + 1760 | 0) + I7 | 0]) { + if (!(i3[(o4 = g6) + (g6 = I7 - 1 | 0) | 0] | i3[g6 + Q4 | 0])) break I; + I7 = g6; + } + if ((0 | I7) < 0) break A; + for (; _3(Q4 = a4 + 320 | 0, B4), (0 | (o4 = C3[(g6 = I7) + (a4 + 2016 | 0) | 0])) > 0 ? (M3(I7 = a4 + 160 | 0, Q4, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, Q4, k4), X(Q4, I7, (a4 + 480 | 0) + c3((254 & o4) >>> 1 | 0, 160) | 0)) : (0 | o4) >= 0 || (M3(I7 = a4 + 160 | 0, Q4 = a4 + 320 | 0, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, Q4, k4), O(Q4, I7, (a4 + 480 | 0) + c3((0 - o4 & 254) >>> 1 | 0, 160) | 0)), (0 | (x4 = C3[g6 + (a4 + 1760 | 0) | 0])) > 0 ? (M3(I7 = a4 + 160 | 0, Q4 = a4 + 320 | 0, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, Q4, k4), T(Q4, I7, c3((254 & x4) >>> 1 | 0, 120) + 1472 | 0)) : (0 | x4) >= 0 || (M3(a4 + 160 | 0, u4 = a4 + 320 | 0, h4), M3(G4, k4, n4), M3(J4, n4, h4), M3(K4, u4, k4), Y4 = E3[a4 + 160 >> 2], U4 = E3[a4 + 200 >> 2], d4 = E3[a4 + 164 >> 2], b4 = E3[a4 + 204 >> 2], P4 = E3[a4 + 168 >> 2], R4 = E3[a4 + 208 >> 2], L4 = E3[a4 + 172 >> 2], F4 = E3[a4 + 212 >> 2], S4 = E3[a4 + 176 >> 2], N4 = E3[a4 + 216 >> 2], p4 = E3[a4 + 180 >> 2], H4 = E3[a4 + 220 >> 2], f4 = E3[a4 + 184 >> 2], t4 = E3[a4 + 224 >> 2], e4 = E3[a4 + 188 >> 2], y4 = E3[a4 + 228 >> 2], w4 = E3[a4 + 192 >> 2], o4 = E3[a4 + 232 >> 2], Q4 = E3[a4 + 236 >> 2], I7 = E3[a4 + 196 >> 2], E3[a4 + 396 >> 2] = Q4 - I7, E3[a4 + 392 >> 2] = o4 - w4, E3[a4 + 388 >> 2] = y4 - e4, E3[a4 + 384 >> 2] = t4 - f4, E3[a4 + 380 >> 2] = H4 - p4, E3[a4 + 376 >> 2] = N4 - S4, E3[a4 + 372 >> 2] = F4 - L4, E3[a4 + 368 >> 2] = R4 - P4, E3[a4 + 364 >> 2] = b4 - d4, E3[a4 + 360 >> 2] = U4 - Y4, E3[a4 + 356 >> 2] = I7 + Q4, E3[a4 + 352 >> 2] = o4 + w4, E3[a4 + 348 >> 2] = y4 + e4, E3[a4 + 344 >> 2] = f4 + t4, E3[a4 + 340 >> 2] = p4 + H4, E3[a4 + 336 >> 2] = S4 + N4, E3[a4 + 332 >> 2] = F4 + L4, E3[a4 + 328 >> 2] = P4 + R4, E3[a4 + 324 >> 2] = d4 + b4, E3[a4 + 320 >> 2] = Y4 + U4, M3(n4, u4, 40 + (I7 = c3((0 - x4 & 254) >>> 1 | 0, 120) + 1472 | 0) | 0), M3(k4, k4, I7), M3(h4, I7 + 80 | 0, K4), IA2 = E3[a4 + 276 >> 2], gA2 = E3[a4 + 272 >> 2], x4 = E3[a4 + 268 >> 2], u4 = E3[a4 + 264 >> 2], f4 = E3[a4 + 260 >> 2], t4 = E3[a4 + 256 >> 2], e4 = E3[a4 + 252 >> 2], y4 = E3[a4 + 248 >> 2], w4 = E3[a4 + 244 >> 2], o4 = E3[a4 + 240 >> 2], m4 = E3[a4 + 360 >> 2], l3 = E3[a4 + 400 >> 2], z2 = E3[a4 + 364 >> 2], j2 = E3[a4 + 404 >> 2], V2 = E3[a4 + 368 >> 2], Z2 = E3[a4 + 408 >> 2], Y4 = E3[a4 + 372 >> 2], U4 = E3[a4 + 412 >> 2], d4 = E3[a4 + 376 >> 2], b4 = E3[a4 + 416 >> 2], P4 = E3[a4 + 380 >> 2], R4 = E3[a4 + 420 >> 2], L4 = E3[a4 + 384 >> 2], F4 = E3[a4 + 424 >> 2], S4 = E3[a4 + 388 >> 2], N4 = E3[a4 + 428 >> 2], p4 = E3[a4 + 392 >> 2], H4 = E3[a4 + 432 >> 2], Q4 = E3[a4 + 396 >> 2], I7 = E3[a4 + 436 >> 2], E3[a4 + 396 >> 2] = Q4 + I7, E3[a4 + 392 >> 2] = p4 + H4, E3[a4 + 388 >> 2] = S4 + N4, E3[a4 + 384 >> 2] = F4 + L4, E3[a4 + 380 >> 2] = P4 + R4, E3[a4 + 376 >> 2] = d4 + b4, E3[a4 + 372 >> 2] = Y4 + U4, E3[a4 + 368 >> 2] = V2 + Z2, E3[a4 + 364 >> 2] = z2 + j2, E3[a4 + 360 >> 2] = m4 + l3, E3[a4 + 356 >> 2] = I7 - Q4, E3[a4 + 352 >> 2] = H4 - p4, E3[a4 + 348 >> 2] = N4 - S4, E3[a4 + 344 >> 2] = F4 - L4, E3[a4 + 340 >> 2] = R4 - P4, E3[a4 + 336 >> 2] = b4 - d4, E3[a4 + 332 >> 2] = U4 - Y4, E3[a4 + 328 >> 2] = Z2 - V2, E3[a4 + 324 >> 2] = j2 - z2, E3[a4 + 320 >> 2] = l3 - m4, Y4 = o4 << 1, U4 = E3[a4 + 440 >> 2], E3[a4 + 400 >> 2] = Y4 - U4, d4 = w4 << 1, b4 = E3[a4 + 444 >> 2], E3[a4 + 404 >> 2] = d4 - b4, P4 = y4 << 1, R4 = E3[a4 + 448 >> 2], E3[a4 + 408 >> 2] = P4 - R4, L4 = e4 << 1, F4 = E3[a4 + 452 >> 2], E3[a4 + 412 >> 2] = L4 - F4, S4 = t4 << 1, N4 = E3[a4 + 456 >> 2], E3[a4 + 416 >> 2] = S4 - N4, p4 = f4 << 1, H4 = E3[a4 + 460 >> 2], E3[a4 + 420 >> 2] = p4 - H4, f4 = u4 << 1, t4 = E3[a4 + 464 >> 2], E3[a4 + 424 >> 2] = f4 - t4, e4 = x4 << 1, y4 = E3[a4 + 468 >> 2], E3[a4 + 428 >> 2] = e4 - y4, w4 = gA2 << 1, o4 = E3[a4 + 472 >> 2], E3[a4 + 432 >> 2] = w4 - o4, Q4 = IA2 << 1, I7 = E3[a4 + 476 >> 2], E3[a4 + 436 >> 2] = Q4 - I7, E3[a4 + 440 >> 2] = Y4 + U4, E3[a4 + 444 >> 2] = d4 + b4, E3[a4 + 448 >> 2] = P4 + R4, E3[a4 + 452 >> 2] = F4 + L4, E3[a4 + 456 >> 2] = S4 + N4, E3[a4 + 460 >> 2] = p4 + H4, E3[a4 + 464 >> 2] = f4 + t4, E3[a4 + 468 >> 2] = y4 + e4, E3[a4 + 472 >> 2] = o4 + w4, E3[a4 + 476 >> 2] = I7 + Q4), M3(B4, a4 + 320 | 0, h4), M3(AA2, k4, n4), M3($2, n4, h4), I7 = g6 - 1 | 0, (0 | g6) > 0; ) ; + break A; + } + if (I7 = I7 - 2 | 0, g6) continue; + } + break; + } + r3 = a4 + 2272 | 0, mA(I7 = D4 + 288 | 0, B4), CA2 = -1, BA2 = UA(I7, A8), p4 = ((0 | A8) == (0 | I7) ? CA2 : BA2) | NA(A8, I7, 32); + } + return r3 = D4 + 592 | 0, p4; + } + function S3(A8, I7, g6) { + var C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0; + for (r3 = C4 = r3 - 800 | 0, S4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, N4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, _4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, p4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, s4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, H4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, G4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, Q4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, o4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, c4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, D4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, a4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, y4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, f4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, F4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = g6 - -64 | 0, e4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[I7 >> 2] = 33620224 ^ e4, E3[g6 + 56 >> 2] = 1496785429, E3[g6 + 60 >> 2] = 1652156816, E3[(A8 = g6 + 48 | 0) >> 2] = 33620224, E3[A8 + 4 >> 2] = 218629379, E3[g6 + 40 >> 2] = 1110511904, E3[g6 + 44 >> 2] = -584534669, E3[(B4 = g6 + 32 | 0) >> 2] = 1427652059, E3[B4 + 4 >> 2] = -248528275, w4 = F4 ^ e4, E3[g6 >> 2] = w4, E3[g6 + 92 >> 2] = -584534669 ^ f4, E3[g6 + 88 >> 2] = 1110511904 ^ y4, E3[g6 + 84 >> 2] = -248528275 ^ a4, E3[(F4 = g6 + 80 | 0) >> 2] = 1427652059 ^ D4, E3[g6 + 76 >> 2] = 1652156816 ^ c4, E3[g6 + 72 >> 2] = 1496785429 ^ o4, E3[g6 + 68 >> 2] = 218629379 ^ Q4, G4 ^= f4, E3[g6 + 28 >> 2] = G4, H4 ^= y4, E3[g6 + 24 >> 2] = H4, t4 = s4 ^ a4, E3[g6 + 20 >> 2] = t4, p4 ^= D4, E3[(s4 = g6 + 16 | 0) >> 2] = p4, _4 ^= c4, E3[g6 + 12 >> 2] = _4, h4 = N4 ^ o4, E3[g6 + 8 >> 2] = h4, k4 = S4 ^ Q4, E3[g6 + 4 >> 2] = k4, N4 = 0; S4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = S4, S4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = S4, S4 = E3[I7 + 12 >> 2], E3[C4 + 760 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 764 >> 2] = S4, S4 = E3[I7 + 4 >> 2], E3[C4 + 752 >> 2] = E3[I7 >> 2], E3[C4 + 756 >> 2] = S4, S4 = E3[F4 + 12 >> 2], E3[C4 + 744 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 748 >> 2] = S4, S4 = E3[F4 + 4 >> 2], E3[C4 + 736 >> 2] = E3[F4 >> 2], E3[C4 + 740 >> 2] = S4, aA(S4 = C4 + 768 | 0, C4 + 752 | 0, C4 + 736 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 728 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 732 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 720 >> 2] = E3[A8 >> 2], E3[C4 + 724 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 712 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 716 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 704 >> 2] = E3[I7 >> 2], E3[C4 + 708 >> 2] = n4, aA(S4, C4 + 720 | 0, C4 + 704 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 696 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 700 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 688 >> 2] = E3[B4 >> 2], E3[C4 + 692 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 680 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 684 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 672 >> 2] = E3[A8 >> 2], E3[C4 + 676 >> 2] = n4, aA(S4, C4 + 688 | 0, C4 + 672 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 664 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 668 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 656 >> 2] = E3[s4 >> 2], E3[C4 + 660 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 648 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 652 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 640 >> 2] = E3[B4 >> 2], E3[C4 + 644 >> 2] = n4, aA(S4, C4 + 656 | 0, C4 + 640 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 632 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 636 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 624 >> 2] = E3[g6 >> 2], E3[C4 + 628 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 616 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 620 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 608 >> 2] = E3[s4 >> 2], E3[C4 + 612 >> 2] = n4, aA(S4, C4 + 624 | 0, C4 + 608 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 600 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 604 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 592 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 596 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 584 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 588 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 576 >> 2] = E3[g6 >> 2], E3[C4 + 580 >> 2] = n4, aA(S4, C4 + 592 | 0, C4 + 576 | 0), n4 = E3[C4 + 768 >> 2], M4 = E3[C4 + 772 >> 2], K4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = E3[C4 + 780 >> 2] ^ c4, E3[g6 + 8 >> 2] = K4 ^ o4, E3[g6 + 4 >> 2] = M4 ^ Q4, E3[g6 >> 2] = n4 ^ e4, n4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 568 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 572 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 560 >> 2] = E3[I7 >> 2], E3[C4 + 564 >> 2] = n4, n4 = E3[F4 + 12 >> 2], E3[C4 + 552 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 556 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 544 >> 2] = E3[F4 >> 2], E3[C4 + 548 >> 2] = n4, aA(S4, C4 + 560 | 0, C4 + 544 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 536 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 540 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 528 >> 2] = E3[A8 >> 2], E3[C4 + 532 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 520 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 524 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 512 >> 2] = E3[I7 >> 2], E3[C4 + 516 >> 2] = n4, aA(S4, C4 + 528 | 0, C4 + 512 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 504 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 508 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 496 >> 2] = E3[B4 >> 2], E3[C4 + 500 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 488 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 492 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 480 >> 2] = E3[A8 >> 2], E3[C4 + 484 >> 2] = n4, aA(S4, C4 + 496 | 0, C4 + 480 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 472 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 476 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 464 >> 2] = E3[s4 >> 2], E3[C4 + 468 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 456 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 460 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 448 >> 2] = E3[B4 >> 2], E3[C4 + 452 >> 2] = n4, aA(S4, C4 + 464 | 0, C4 + 448 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 440 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 444 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 432 >> 2] = E3[g6 >> 2], E3[C4 + 436 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 424 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 428 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 416 >> 2] = E3[s4 >> 2], E3[C4 + 420 >> 2] = n4, aA(S4, C4 + 432 | 0, C4 + 416 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 408 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 412 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 400 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 404 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 392 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 396 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 384 >> 2] = E3[g6 >> 2], E3[C4 + 388 >> 2] = n4, aA(S4, C4 + 400 | 0, C4 + 384 | 0), n4 = E3[C4 + 768 >> 2], M4 = E3[C4 + 772 >> 2], K4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = E3[C4 + 780 >> 2] ^ f4, E3[g6 + 8 >> 2] = K4 ^ y4, E3[g6 + 4 >> 2] = M4 ^ a4, E3[g6 >> 2] = n4 ^ D4, n4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 376 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 380 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 368 >> 2] = E3[I7 >> 2], E3[C4 + 372 >> 2] = n4, n4 = E3[F4 + 12 >> 2], E3[C4 + 360 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 364 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 352 >> 2] = E3[F4 >> 2], E3[C4 + 356 >> 2] = n4, aA(S4, C4 + 368 | 0, C4 + 352 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 344 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 348 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 336 >> 2] = E3[A8 >> 2], E3[C4 + 340 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 328 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 332 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 320 >> 2] = E3[I7 >> 2], E3[C4 + 324 >> 2] = n4, aA(S4, C4 + 336 | 0, C4 + 320 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 312 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 316 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 304 >> 2] = E3[B4 >> 2], E3[C4 + 308 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 296 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 300 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 288 >> 2] = E3[A8 >> 2], E3[C4 + 292 >> 2] = n4, aA(S4, C4 + 304 | 0, C4 + 288 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 280 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 284 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 272 >> 2] = E3[s4 >> 2], E3[C4 + 276 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 264 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 268 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 256 >> 2] = E3[B4 >> 2], E3[C4 + 260 >> 2] = n4, aA(S4, C4 + 272 | 0, C4 + 256 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 248 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 252 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 240 >> 2] = E3[g6 >> 2], E3[C4 + 244 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 232 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 236 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 224 >> 2] = E3[s4 >> 2], E3[C4 + 228 >> 2] = n4, aA(S4, C4 + 240 | 0, C4 + 224 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 216 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 220 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 208 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 212 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 200 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 204 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 192 >> 2] = E3[g6 >> 2], E3[C4 + 196 >> 2] = n4, aA(S4, C4 + 208 | 0, C4 + 192 | 0), n4 = E3[C4 + 768 >> 2], M4 = E3[C4 + 772 >> 2], K4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = _4 ^ E3[C4 + 780 >> 2], E3[g6 + 8 >> 2] = K4 ^ h4, E3[g6 + 4 >> 2] = M4 ^ k4, E3[g6 >> 2] = n4 ^ w4, n4 = E3[F4 + 12 >> 2], E3[C4 + 792 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 796 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 784 >> 2] = E3[F4 >> 2], E3[C4 + 788 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 184 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 188 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 176 >> 2] = E3[I7 >> 2], E3[C4 + 180 >> 2] = n4, n4 = E3[F4 + 12 >> 2], E3[C4 + 168 >> 2] = E3[F4 + 8 >> 2], E3[C4 + 172 >> 2] = n4, n4 = E3[F4 + 4 >> 2], E3[C4 + 160 >> 2] = E3[F4 >> 2], E3[C4 + 164 >> 2] = n4, aA(S4, C4 + 176 | 0, C4 + 160 | 0), n4 = E3[C4 + 780 >> 2], E3[F4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[F4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[F4 >> 2] = E3[C4 + 768 >> 2], E3[F4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 152 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 156 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 144 >> 2] = E3[A8 >> 2], E3[C4 + 148 >> 2] = n4, n4 = E3[I7 + 12 >> 2], E3[C4 + 136 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 140 >> 2] = n4, n4 = E3[I7 + 4 >> 2], E3[C4 + 128 >> 2] = E3[I7 >> 2], E3[C4 + 132 >> 2] = n4, aA(S4, C4 + 144 | 0, C4 + 128 | 0), n4 = E3[C4 + 780 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 776 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[I7 >> 2] = E3[C4 + 768 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 120 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 124 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 112 >> 2] = E3[B4 >> 2], E3[C4 + 116 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 104 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 108 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 96 >> 2] = E3[A8 >> 2], E3[C4 + 100 >> 2] = n4, aA(S4, C4 + 112 | 0, C4 + 96 | 0), n4 = E3[C4 + 780 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 776 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[A8 >> 2] = E3[C4 + 768 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 88 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 92 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 80 >> 2] = E3[s4 >> 2], E3[C4 + 84 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 72 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 76 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 64 >> 2] = E3[B4 >> 2], E3[C4 + 68 >> 2] = n4, aA(S4, C4 + 80 | 0, C4 - -64 | 0), n4 = E3[C4 + 780 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[B4 >> 2] = E3[C4 + 768 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 60 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 48 >> 2] = E3[g6 >> 2], E3[C4 + 52 >> 2] = n4, n4 = E3[s4 + 12 >> 2], E3[C4 + 40 >> 2] = E3[s4 + 8 >> 2], E3[C4 + 44 >> 2] = n4, n4 = E3[s4 + 4 >> 2], E3[C4 + 32 >> 2] = E3[s4 >> 2], E3[C4 + 36 >> 2] = n4, aA(S4, C4 + 48 | 0, C4 + 32 | 0), n4 = E3[C4 + 780 >> 2], E3[s4 + 8 >> 2] = E3[C4 + 776 >> 2], E3[s4 + 12 >> 2] = n4, n4 = E3[C4 + 772 >> 2], E3[s4 >> 2] = E3[C4 + 768 >> 2], E3[s4 + 4 >> 2] = n4, n4 = E3[C4 + 796 >> 2], E3[C4 + 24 >> 2] = E3[C4 + 792 >> 2], E3[C4 + 28 >> 2] = n4, n4 = E3[C4 + 788 >> 2], E3[C4 + 16 >> 2] = E3[C4 + 784 >> 2], E3[C4 + 20 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 12 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 >> 2] = E3[g6 >> 2], E3[C4 + 4 >> 2] = n4, aA(S4, C4 + 16 | 0, C4), S4 = E3[C4 + 768 >> 2], n4 = E3[C4 + 772 >> 2], M4 = E3[C4 + 776 >> 2], E3[g6 + 12 >> 2] = G4 ^ E3[C4 + 780 >> 2], E3[g6 + 8 >> 2] = M4 ^ H4, E3[g6 + 4 >> 2] = n4 ^ t4, E3[g6 >> 2] = S4 ^ p4, 4 != (0 | (N4 = N4 + 1 | 0)); ) ; + r3 = C4 + 800 | 0; + } + function M3(A8, I7, g6) { + var C4, B4, Q4, i4, o4, D4, a4, y4, f4, e4, w4, r4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, v4, R4, L4, x4, u4, m4, q4, l3, z2, j2, X2, O2, T2, V2, Z2, W2, $2, AA2, IA2, gA2, CA2, BA2, QA2 = 0, EA2 = 0, iA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, eA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, SA2 = 0, MA2 = 0, NA2 = 0, KA2 = 0, _A2 = 0, pA2 = 0, HA2 = 0; + QA2 = PA(C4 = E3[g6 + 4 >> 2], e4 = C4 >> 31, sA2 = (s4 = E3[I7 + 20 >> 2]) << 1, P4 = sA2 >> 31), iA2 = t3, EA2 = (tA2 = PA(kA2 = E3[g6 >> 2], Q4 = kA2 >> 31, B4 = E3[I7 + 24 >> 2], i4 = B4 >> 31)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < tA2 >>> 0 ? QA2 + 1 | 0 : QA2, fA2 = PA(o4 = E3[g6 + 8 >> 2], h4 = o4 >> 31, tA2 = E3[I7 + 16 >> 2], D4 = tA2 >> 31), iA2 = t3 + QA2 | 0, iA2 = (EA2 = fA2 + EA2 | 0) >>> 0 < fA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = (fA2 = PA(w4 = E3[g6 + 12 >> 2], F4 = w4 >> 31, H4 = (S4 = E3[I7 + 12 >> 2]) << 1, v4 = H4 >> 31)) + EA2 | 0, EA2 = t3 + iA2 | 0, EA2 = QA2 >>> 0 < fA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (hA2 = PA(k4 = E3[g6 + 16 >> 2], G4 = k4 >> 31, fA2 = E3[I7 + 8 >> 2], a4 = fA2 >> 31)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < hA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(M4 = E3[g6 + 20 >> 2], R4 = M4 >> 31, J4 = (N4 = E3[I7 + 4 >> 2]) << 1, L4 = J4 >> 31), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, Z2 = aA2 = E3[g6 + 24 >> 2], iA2 = (eA2 = PA(aA2, T2 = aA2 >> 31, hA2 = E3[I7 >> 2], y4 = hA2 >> 31)) + EA2 | 0, EA2 = t3 + QA2 | 0, EA2 = iA2 >>> 0 < eA2 >>> 0 ? EA2 + 1 | 0 : EA2, x4 = E3[g6 + 28 >> 2], QA2 = (eA2 = PA(rA2 = c3(x4, 19), K4 = rA2 >> 31, Y4 = (_4 = E3[I7 + 36 >> 2]) << 1, u4 = Y4 >> 31)) + iA2 | 0, iA2 = t3 + EA2 | 0, iA2 = QA2 >>> 0 < eA2 >>> 0 ? iA2 + 1 | 0 : iA2, NA2 = E3[g6 + 32 >> 2], EA2 = (yA2 = PA(oA2 = c3(NA2, 19), n4 = oA2 >> 31, eA2 = E3[I7 + 32 >> 2], f4 = eA2 >> 31)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < yA2 >>> 0 ? QA2 + 1 | 0 : QA2, W2 = E3[g6 + 36 >> 2], g6 = PA(yA2 = c3(W2, 19), r4 = yA2 >> 31, U4 = (p4 = E3[I7 + 28 >> 2]) << 1, m4 = U4 >> 31), QA2 = t3 + QA2 | 0, cA2 = I7 = g6 + EA2 | 0, g6 = I7 >>> 0 < g6 >>> 0 ? QA2 + 1 | 0 : QA2, I7 = PA(tA2, D4, C4, e4), QA2 = t3, EA2 = PA(kA2, Q4, s4, q4 = s4 >> 31), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(o4, h4, S4, l3 = S4 >> 31), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(fA2, a4, w4, F4), QA2 = t3 + EA2 | 0, QA2 = (I7 = iA2 + I7 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(k4, G4, N4, z2 = N4 >> 31), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(hA2, y4, M4, R4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(aA2 = c3(aA2, 19), d4 = aA2 >> 31, _4, j2 = _4 >> 31), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(eA2, f4, rA2, K4), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(oA2, n4, p4, X2 = p4 >> 31), QA2 = t3 + EA2 | 0, QA2 = (I7 = iA2 + I7 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(yA2, r4, B4, i4), QA2 = t3 + QA2 | 0, _A2 = I7 = EA2 + I7 | 0, FA2 = I7 >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, I7 = PA(C4, e4, H4, v4), QA2 = t3, EA2 = PA(kA2, Q4, tA2, D4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(fA2, a4, o4, h4), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(w4, F4, J4, L4), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(hA2, y4, k4, G4), QA2 = t3 + EA2 | 0, QA2 = (I7 = iA2 + I7 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(b4 = c3(M4, 19), O2 = b4 >> 31, Y4, u4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(eA2, f4, aA2, d4), QA2 = t3 + QA2 | 0, QA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(rA2, K4, U4, m4), iA2 = t3 + QA2 | 0, iA2 = (I7 = EA2 + I7 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = PA(oA2, n4, B4, i4), EA2 = t3 + iA2 | 0, EA2 = (I7 = QA2 + I7 | 0) >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(yA2, r4, sA2, P4), QA2 = t3 + EA2 | 0, $2 = I7 = iA2 + I7 | 0, AA2 = QA2 = I7 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, IA2 = I7 = I7 + 33554432 | 0, gA2 = QA2 = I7 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, iA2 = (67108863 & QA2) << 6 | I7 >>> 26, QA2 = (QA2 >> 26) + FA2 | 0, _A2 = I7 = iA2 + _A2 | 0, QA2 = I7 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, CA2 = I7 = I7 + 16777216 | 0, QA2 = g6 + (EA2 = (iA2 = I7 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2) >> 25) | 0, QA2 = (I7 = (iA2 = (33554431 & iA2) << 7 | I7 >>> 25) + cA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, SA2 = g6 = (EA2 = I7) + 33554432 | 0, I7 = QA2 = g6 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, E3[A8 + 24 >> 2] = EA2 - (-67108864 & g6), g6 = PA(C4, e4, J4, L4), QA2 = t3, EA2 = PA(kA2, Q4, fA2, a4), iA2 = t3 + QA2 | 0, iA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = (QA2 = g6) + (g6 = PA(hA2, y4, o4, h4)) | 0, QA2 = t3 + iA2 | 0, QA2 = g6 >>> 0 > EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(g6 = c3(w4, 19), MA2 = g6 >> 31, Y4, u4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = (cA2 = PA(eA2, f4, FA2 = c3(k4, 19), V2 = FA2 >> 31)) + EA2 | 0, EA2 = t3 + QA2 | 0, EA2 = iA2 >>> 0 < cA2 >>> 0 ? EA2 + 1 | 0 : EA2, cA2 = PA(U4, m4, b4, O2), QA2 = t3 + EA2 | 0, QA2 = (iA2 = cA2 + iA2 | 0) >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (cA2 = PA(B4, i4, aA2, d4)) + iA2 | 0, iA2 = t3 + QA2 | 0, iA2 = EA2 >>> 0 < cA2 >>> 0 ? iA2 + 1 | 0 : iA2, cA2 = PA(rA2, K4, sA2, P4), QA2 = t3 + iA2 | 0, QA2 = (EA2 = cA2 + EA2 | 0) >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(oA2, n4, tA2, D4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = (cA2 = PA(yA2, r4, H4, v4)) + EA2 | 0, EA2 = t3 + QA2 | 0, wA2 = iA2, pA2 = iA2 >>> 0 < cA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = PA(hA2, y4, C4, e4), EA2 = t3, iA2 = (cA2 = PA(kA2, Q4, N4, z2)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2, cA2 = EA2 = c3(o4, 19), EA2 = (DA2 = PA(EA2, KA2 = EA2 >> 31, _4, j2)) + iA2 | 0, iA2 = t3 + QA2 | 0, iA2 = EA2 >>> 0 < DA2 >>> 0 ? iA2 + 1 | 0 : iA2, DA2 = PA(eA2, f4, g6, MA2), QA2 = t3 + iA2 | 0, QA2 = (EA2 = DA2 + EA2 | 0) >>> 0 < DA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(FA2, V2, p4, X2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = (DA2 = PA(B4, i4, b4, O2)) + EA2 | 0, EA2 = t3 + QA2 | 0, EA2 = iA2 >>> 0 < DA2 >>> 0 ? EA2 + 1 | 0 : EA2, DA2 = PA(aA2, d4, s4, q4), QA2 = t3 + EA2 | 0, QA2 = (iA2 = DA2 + iA2 | 0) >>> 0 < DA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (DA2 = PA(tA2, D4, rA2, K4)) + iA2 | 0, iA2 = t3 + QA2 | 0, iA2 = EA2 >>> 0 < DA2 >>> 0 ? iA2 + 1 | 0 : iA2, DA2 = PA(oA2, n4, S4, l3), QA2 = t3 + iA2 | 0, QA2 = (EA2 = DA2 + EA2 | 0) >>> 0 < DA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(yA2, r4, fA2, a4), QA2 = t3 + QA2 | 0, HA2 = EA2 = iA2 + EA2 | 0, DA2 = EA2 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, QA2 = PA(QA2 = c3(C4, 19), QA2 >> 31, Y4, u4), EA2 = t3, iA2 = PA(kA2, Q4, hA2, y4), EA2 = t3 + EA2 | 0, EA2 = (QA2 = iA2 + QA2 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (cA2 = PA(eA2, f4, cA2, KA2)) + QA2 | 0, QA2 = t3 + EA2 | 0, g6 = (EA2 = PA(g6, MA2, U4, m4)) + iA2 | 0, iA2 = t3 + (iA2 >>> 0 < cA2 >>> 0 ? QA2 + 1 | 0 : QA2) | 0, iA2 = g6 >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(B4, i4, FA2, V2), QA2 = t3 + iA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(sA2, P4, b4, O2), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(tA2, D4, aA2, d4), EA2 = t3 + QA2 | 0, EA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = PA(rA2, K4, H4, v4), QA2 = t3 + EA2 | 0, QA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(oA2, n4, fA2, a4), iA2 = t3 + QA2 | 0, iA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(yA2, r4, J4, L4), QA2 = t3 + iA2 | 0, cA2 = g6 = EA2 + g6 | 0, MA2 = QA2 = g6 >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, KA2 = g6 = g6 + 33554432 | 0, BA2 = QA2 = g6 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, EA2 = (iA2 = QA2 >> 26) + DA2 | 0, DA2 = g6 = (QA2 = (67108863 & QA2) << 6 | g6 >>> 26) + HA2 | 0, QA2 = g6 >>> 0 < QA2 >>> 0 ? EA2 + 1 | 0 : EA2, HA2 = g6 = g6 + 16777216 | 0, EA2 = (33554431 & (QA2 = g6 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2)) << 7 | g6 >>> 25, QA2 = (QA2 >> 25) + pA2 | 0, QA2 = (g6 = EA2 + wA2 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, pA2 = EA2 = (iA2 = g6) + 33554432 | 0, g6 = QA2 = EA2 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, E3[A8 + 8 >> 2] = iA2 - (-67108864 & EA2), QA2 = PA(B4, i4, C4, e4), iA2 = t3, EA2 = (wA2 = PA(kA2, Q4, p4, X2)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < wA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(o4, h4, s4, q4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(tA2, D4, w4, F4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, wA2 = PA(k4, G4, S4, l3), iA2 = t3 + QA2 | 0, iA2 = (EA2 = wA2 + EA2 | 0) >>> 0 < wA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = (wA2 = PA(fA2, a4, M4, R4)) + EA2 | 0, EA2 = t3 + iA2 | 0, EA2 = QA2 >>> 0 < wA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (wA2 = PA(N4, z2, Z2, T2)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < wA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(hA2, y4, x4, wA2 = x4 >> 31), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(oA2, n4, _4, j2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, nA2 = PA(yA2, r4, eA2, f4), iA2 = t3 + QA2 | 0, QA2 = I7 >> 26, I7 = (SA2 = (67108863 & I7) << 6 | SA2 >>> 26) + (EA2 = nA2 + EA2 | 0) | 0, EA2 = QA2 + (EA2 >>> 0 < nA2 >>> 0 ? iA2 + 1 | 0 : iA2) | 0, QA2 = (iA2 = I7) >>> 0 < SA2 >>> 0 ? EA2 + 1 | 0 : EA2, SA2 = EA2 = iA2 + 16777216 | 0, I7 = QA2 = EA2 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2, E3[A8 + 28 >> 2] = iA2 - (-33554432 & EA2), QA2 = PA(fA2, a4, C4, e4), EA2 = t3, nA2 = PA(kA2, Q4, S4, l3), iA2 = t3 + EA2 | 0, iA2 = (QA2 = nA2 + QA2 | 0) >>> 0 < nA2 >>> 0 ? iA2 + 1 | 0 : iA2, nA2 = PA(o4, h4, N4, z2), EA2 = t3 + iA2 | 0, EA2 = (QA2 = nA2 + QA2 | 0) >>> 0 < nA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (nA2 = PA(hA2, y4, w4, F4)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < nA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(FA2, V2, _4, j2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(eA2, f4, b4, O2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (aA2 = PA(aA2, d4, p4, X2)) + EA2 | 0, iA2 = t3 + QA2 | 0, QA2 = (rA2 = PA(B4, i4, rA2, K4)) + EA2 | 0, EA2 = t3 + (EA2 >>> 0 < aA2 >>> 0 ? iA2 + 1 | 0 : iA2) | 0, iA2 = (oA2 = PA(oA2, n4, s4, q4)) + QA2 | 0, QA2 = t3 + (QA2 >>> 0 < rA2 >>> 0 ? EA2 + 1 | 0 : EA2) | 0, QA2 = iA2 >>> 0 < oA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(yA2, r4, tA2, D4), QA2 = t3 + QA2 | 0, oA2 = EA2 = EA2 + iA2 | 0, QA2 = (QA2 = EA2 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2) + (EA2 = g6 >> 26) | 0, oA2 = g6 = oA2 + (iA2 = (67108863 & g6) << 6 | pA2 >>> 26) | 0, QA2 = g6 >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, rA2 = EA2 = g6 + 16777216 | 0, g6 = iA2 = EA2 >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2, E3[A8 + 12 >> 2] = oA2 - (-33554432 & EA2), QA2 = PA(C4, e4, U4, m4), iA2 = t3, EA2 = (oA2 = PA(kA2, Q4, eA2, f4)) + QA2 | 0, QA2 = t3 + iA2 | 0, QA2 = EA2 >>> 0 < oA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(B4, i4, o4, h4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, oA2 = PA(w4, F4, sA2, P4), iA2 = t3 + QA2 | 0, iA2 = (EA2 = oA2 + EA2 | 0) >>> 0 < oA2 >>> 0 ? iA2 + 1 | 0 : iA2, QA2 = (oA2 = PA(tA2, D4, k4, G4)) + EA2 | 0, EA2 = t3 + iA2 | 0, EA2 = QA2 >>> 0 < oA2 >>> 0 ? EA2 + 1 | 0 : EA2, iA2 = (oA2 = PA(H4, v4, M4, R4)) + QA2 | 0, QA2 = t3 + EA2 | 0, QA2 = iA2 >>> 0 < oA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = iA2, iA2 = PA(fA2, a4, Z2, T2), QA2 = t3 + QA2 | 0, QA2 = (EA2 = EA2 + iA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(x4, wA2, J4, L4), QA2 = t3 + QA2 | 0, QA2 = (EA2 = iA2 + EA2 | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = (sA2 = PA(hA2, y4, oA2 = NA2, aA2 = oA2 >> 31)) + EA2 | 0, iA2 = t3 + QA2 | 0, QA2 = (yA2 = PA(yA2, r4, Y4, u4)) + EA2 | 0, EA2 = t3 + (EA2 >>> 0 < sA2 >>> 0 ? iA2 + 1 | 0 : iA2) | 0, EA2 = QA2 >>> 0 < yA2 >>> 0 ? EA2 + 1 | 0 : EA2, NA2 = QA2, QA2 = (QA2 = I7 >> 25) + EA2 | 0, QA2 = (I7 = NA2 + (iA2 = (33554431 & I7) << 7 | SA2 >>> 25) | 0) >>> 0 < iA2 >>> 0 ? QA2 + 1 | 0 : QA2, yA2 = EA2 = (iA2 = I7) + 33554432 | 0, I7 = QA2 = EA2 >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2, E3[A8 + 32 >> 2] = iA2 - (-67108864 & EA2), EA2 = g6 >> 25, g6 = (rA2 = (33554431 & g6) << 7 | rA2 >>> 25) + ($2 - (QA2 = -67108864 & IA2) | 0) | 0, QA2 = EA2 + (AA2 - ((QA2 >>> 0 > $2 >>> 0) + gA2 | 0) | 0) | 0, QA2 = g6 >>> 0 < rA2 >>> 0 ? QA2 + 1 | 0 : QA2, QA2 = ((67108863 & (QA2 = (g6 = (EA2 = g6) + 33554432 | 0) >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2)) << 6 | g6 >>> 26) + (iA2 = _A2 - (-33554432 & CA2) | 0) | 0, E3[A8 + 20 >> 2] = QA2, E3[A8 + 16 >> 2] = EA2 - (-67108864 & g6), g6 = PA(eA2, f4, C4, e4), QA2 = t3, EA2 = PA(kA2, Q4, _4, j2), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(o4, h4, p4, X2), EA2 = t3 + QA2 | 0, EA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = PA(B4, i4, w4, F4), iA2 = t3 + EA2 | 0, iA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(k4, G4, s4, q4), QA2 = t3 + iA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(tA2, D4, M4, R4), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, EA2 = PA(S4, l3, Z2, T2), QA2 = t3 + QA2 | 0, QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2, iA2 = PA(fA2, a4, x4, wA2), EA2 = t3 + QA2 | 0, EA2 = (g6 = iA2 + g6 | 0) >>> 0 < iA2 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = PA(oA2, aA2, N4, z2), iA2 = t3 + EA2 | 0, iA2 = (g6 = QA2 + g6 | 0) >>> 0 < QA2 >>> 0 ? iA2 + 1 | 0 : iA2, EA2 = PA(hA2, y4, W2, W2 >> 31), QA2 = t3 + iA2 | 0, QA2 = (QA2 = (g6 = EA2 + g6 | 0) >>> 0 < EA2 >>> 0 ? QA2 + 1 | 0 : QA2) + (EA2 = I7 >> 26) | 0, QA2 = (I7 = (iA2 = g6) + (g6 = (67108863 & I7) << 6 | yA2 >>> 26) | 0) >>> 0 < g6 >>> 0 ? QA2 + 1 | 0 : QA2, QA2 = (I7 = (g6 = I7) + 16777216 | 0) >>> 0 < 16777216 ? QA2 + 1 | 0 : QA2, E3[A8 + 36 >> 2] = g6 - (-33554432 & I7), iA2 = DA2 - (-33554432 & HA2) | 0, EA2 = cA2 - (g6 = -67108864 & KA2) | 0, kA2 = MA2 - ((g6 >>> 0 > cA2 >>> 0) + BA2 | 0) | 0, I7 = (g6 = PA((33554431 & (g6 = QA2)) << 7 | I7 >>> 25, QA2 >>= 25, 19, 0)) + EA2 | 0, EA2 = t3 + kA2 | 0, QA2 = I7 >>> 0 < g6 >>> 0 ? EA2 + 1 | 0 : EA2, QA2 = ((67108863 & (QA2 = (I7 = (g6 = I7) + 33554432 | 0) >>> 0 < 33554432 ? QA2 + 1 | 0 : QA2)) << 6 | I7 >>> 26) + iA2 | 0, E3[A8 + 4 >> 2] = QA2, E3[A8 >> 2] = g6 - (-67108864 & I7); + } + function N3(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4 = 0, F4 = 0, S4 = 0; + r3 = g6 = r3 - 544 | 0, C4 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24, B4 = i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24, Q4 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24, o4 = i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24, c4 = i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24, D4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, a4 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, y4 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24, s4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, f4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, e4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, w4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, t4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, h4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, k4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, n4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, A8 = E3[I7 + 124 >> 2], E3[g6 + 536 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 540 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 528 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 532 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 504 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 508 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 496 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 500 >> 2] = A8, A8 = E3[I7 + 124 >> 2], E3[g6 + 488 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 492 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 480 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 484 >> 2] = A8, aA(S4 = g6 + 512 | 0, g6 + 496 | 0, g6 + 480 | 0), A8 = E3[g6 + 524 >> 2], E3[I7 + 120 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 124 >> 2] = A8, A8 = E3[g6 + 516 >> 2], E3[I7 + 112 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 116 >> 2] = A8, A8 = E3[I7 + 92 >> 2], E3[g6 + 472 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 476 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 464 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 468 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 456 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 460 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 448 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 452 >> 2] = A8, aA(S4, g6 + 464 | 0, g6 + 448 | 0), A8 = E3[g6 + 524 >> 2], E3[I7 + 104 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 108 >> 2] = A8, A8 = E3[g6 + 516 >> 2], E3[I7 + 96 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 100 >> 2] = A8, A8 = E3[I7 + 76 >> 2], E3[g6 + 440 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 444 >> 2] = A8, F4 = E3[4 + (A8 = I7 - -64 | 0) >> 2], E3[g6 + 432 >> 2] = E3[A8 >> 2], E3[g6 + 436 >> 2] = F4, F4 = E3[I7 + 92 >> 2], E3[g6 + 424 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 428 >> 2] = F4, F4 = E3[I7 + 84 >> 2], E3[g6 + 416 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 420 >> 2] = F4, aA(S4, g6 + 432 | 0, g6 + 416 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 92 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 84 >> 2] = F4, F4 = E3[I7 + 60 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 412 >> 2] = F4, F4 = E3[I7 + 52 >> 2], E3[g6 + 400 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 404 >> 2] = F4, F4 = E3[I7 + 76 >> 2], E3[g6 + 392 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 396 >> 2] = F4, F4 = E3[A8 + 4 >> 2], E3[g6 + 384 >> 2] = E3[A8 >> 2], E3[g6 + 388 >> 2] = F4, aA(S4, g6 + 400 | 0, g6 + 384 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 76 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[A8 >> 2] = E3[g6 + 512 >> 2], E3[A8 + 4 >> 2] = F4, F4 = E3[I7 + 44 >> 2], E3[g6 + 376 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 380 >> 2] = F4, F4 = E3[I7 + 36 >> 2], E3[g6 + 368 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 372 >> 2] = F4, F4 = E3[I7 + 60 >> 2], E3[g6 + 360 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 364 >> 2] = F4, F4 = E3[I7 + 52 >> 2], E3[g6 + 352 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 356 >> 2] = F4, aA(S4, g6 + 368 | 0, g6 + 352 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 60 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 52 >> 2] = F4, F4 = E3[I7 + 28 >> 2], E3[g6 + 344 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 348 >> 2] = F4, F4 = E3[I7 + 20 >> 2], E3[g6 + 336 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 340 >> 2] = F4, F4 = E3[I7 + 44 >> 2], E3[g6 + 328 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 332 >> 2] = F4, F4 = E3[I7 + 36 >> 2], E3[g6 + 320 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 324 >> 2] = F4, aA(S4, g6 + 336 | 0, g6 + 320 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 44 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 36 >> 2] = F4, F4 = E3[I7 + 12 >> 2], E3[g6 + 312 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 316 >> 2] = F4, F4 = E3[I7 + 4 >> 2], E3[g6 + 304 >> 2] = E3[I7 >> 2], E3[g6 + 308 >> 2] = F4, F4 = E3[I7 + 28 >> 2], E3[g6 + 296 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 300 >> 2] = F4, F4 = E3[I7 + 20 >> 2], E3[g6 + 288 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 292 >> 2] = F4, aA(S4, g6 + 304 | 0, g6 + 288 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 28 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 20 >> 2] = F4, F4 = E3[g6 + 540 >> 2], E3[g6 + 280 >> 2] = E3[g6 + 536 >> 2], E3[g6 + 284 >> 2] = F4, F4 = E3[g6 + 532 >> 2], E3[g6 + 272 >> 2] = E3[g6 + 528 >> 2], E3[g6 + 276 >> 2] = F4, F4 = E3[I7 + 12 >> 2], E3[g6 + 264 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 268 >> 2] = F4, F4 = E3[I7 + 4 >> 2], E3[g6 + 256 >> 2] = E3[I7 >> 2], E3[g6 + 260 >> 2] = F4, aA(S4, g6 + 272 | 0, g6 + 256 | 0), F4 = E3[g6 + 524 >> 2], E3[I7 + 8 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 12 >> 2] = F4, F4 = E3[g6 + 516 >> 2], E3[I7 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 4 >> 2] = F4, E3[I7 + 12 >> 2] = (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ k4, E3[I7 + 8 >> 2] = (i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24) ^ h4, E3[I7 + 4 >> 2] = (i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) ^ t4, E3[I7 >> 2] = (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) ^ n4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ w4, E3[I7 + 68 >> 2] = (i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24) ^ e4, E3[I7 + 72 >> 2] = (i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) ^ f4, E3[I7 + 76 >> 2] = (i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) ^ s4, s4 = E3[I7 + 124 >> 2], E3[g6 + 536 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 540 >> 2] = s4, s4 = E3[I7 + 116 >> 2], E3[g6 + 528 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 532 >> 2] = s4, s4 = E3[I7 + 108 >> 2], E3[g6 + 248 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 252 >> 2] = s4, s4 = E3[I7 + 100 >> 2], E3[g6 + 240 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 244 >> 2] = s4, s4 = E3[I7 + 124 >> 2], E3[g6 + 232 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 236 >> 2] = s4, s4 = E3[I7 + 116 >> 2], E3[g6 + 224 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 228 >> 2] = s4, aA(S4, g6 + 240 | 0, g6 + 224 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 120 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 124 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 112 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 116 >> 2] = s4, s4 = E3[I7 + 92 >> 2], E3[g6 + 216 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 220 >> 2] = s4, s4 = E3[I7 + 84 >> 2], E3[g6 + 208 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 212 >> 2] = s4, s4 = E3[I7 + 108 >> 2], E3[g6 + 200 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 204 >> 2] = s4, s4 = E3[I7 + 100 >> 2], E3[g6 + 192 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 196 >> 2] = s4, aA(S4, g6 + 208 | 0, g6 + 192 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 104 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 108 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 96 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 100 >> 2] = s4, s4 = E3[I7 + 76 >> 2], E3[g6 + 184 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 188 >> 2] = s4, s4 = E3[A8 + 4 >> 2], E3[g6 + 176 >> 2] = E3[A8 >> 2], E3[g6 + 180 >> 2] = s4, s4 = E3[I7 + 92 >> 2], E3[g6 + 168 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 172 >> 2] = s4, s4 = E3[I7 + 84 >> 2], E3[g6 + 160 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 164 >> 2] = s4, aA(S4, g6 + 176 | 0, g6 + 160 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 92 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 84 >> 2] = s4, s4 = E3[I7 + 60 >> 2], E3[g6 + 152 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 156 >> 2] = s4, s4 = E3[I7 + 52 >> 2], E3[g6 + 144 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 148 >> 2] = s4, s4 = E3[I7 + 76 >> 2], E3[g6 + 136 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 140 >> 2] = s4, s4 = E3[A8 + 4 >> 2], E3[g6 + 128 >> 2] = E3[A8 >> 2], E3[g6 + 132 >> 2] = s4, aA(S4, g6 + 144 | 0, g6 + 128 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 76 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[A8 >> 2] = E3[g6 + 512 >> 2], E3[A8 + 4 >> 2] = s4, s4 = E3[I7 + 44 >> 2], E3[g6 + 120 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 124 >> 2] = s4, s4 = E3[I7 + 36 >> 2], E3[g6 + 112 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 116 >> 2] = s4, s4 = E3[I7 + 60 >> 2], E3[g6 + 104 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 108 >> 2] = s4, s4 = E3[I7 + 52 >> 2], E3[g6 + 96 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 100 >> 2] = s4, aA(S4, g6 + 112 | 0, g6 + 96 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 60 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 52 >> 2] = s4, s4 = E3[I7 + 28 >> 2], E3[g6 + 88 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 92 >> 2] = s4, s4 = E3[I7 + 20 >> 2], E3[g6 + 80 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 84 >> 2] = s4, s4 = E3[I7 + 44 >> 2], E3[g6 + 72 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 76 >> 2] = s4, s4 = E3[I7 + 36 >> 2], E3[g6 + 64 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 68 >> 2] = s4, aA(S4, g6 + 80 | 0, g6 - -64 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 44 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 36 >> 2] = s4, s4 = E3[I7 + 12 >> 2], E3[g6 + 56 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 60 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[g6 + 48 >> 2] = E3[I7 >> 2], E3[g6 + 52 >> 2] = s4, s4 = E3[I7 + 28 >> 2], E3[g6 + 40 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 44 >> 2] = s4, s4 = E3[I7 + 20 >> 2], E3[g6 + 32 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 36 >> 2] = s4, aA(S4, g6 + 48 | 0, g6 + 32 | 0), s4 = E3[g6 + 524 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 28 >> 2] = s4, s4 = E3[g6 + 516 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 20 >> 2] = s4, s4 = E3[g6 + 540 >> 2], E3[g6 + 24 >> 2] = E3[g6 + 536 >> 2], E3[g6 + 28 >> 2] = s4, s4 = E3[g6 + 532 >> 2], E3[g6 + 16 >> 2] = E3[g6 + 528 >> 2], E3[g6 + 20 >> 2] = s4, s4 = E3[I7 + 12 >> 2], E3[g6 + 8 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 12 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[g6 >> 2] = E3[I7 >> 2], E3[g6 + 4 >> 2] = s4, aA(S4, g6 + 16 | 0, g6), S4 = E3[g6 + 524 >> 2], E3[I7 + 8 >> 2] = E3[g6 + 520 >> 2], E3[I7 + 12 >> 2] = S4, S4 = E3[g6 + 516 >> 2], E3[I7 >> 2] = E3[g6 + 512 >> 2], E3[I7 + 4 >> 2] = S4, E3[I7 + 12 >> 2] = (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ y4, E3[I7 + 8 >> 2] = (i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24) ^ a4, E3[I7 + 4 >> 2] = (i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) ^ D4, E3[I7 >> 2] = (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) ^ c4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ o4, E3[I7 + 68 >> 2] = (i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24) ^ Q4, E3[I7 + 72 >> 2] = (i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) ^ B4, E3[I7 + 76 >> 2] = (i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) ^ C4, r3 = g6 + 544 | 0; + } + function K3(A8, I7, g6, B4, Q4) { + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0; + for (r3 = o4 = r3 - 288 | 0, h4 = (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ B4 >>> 29, k4 = (i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24) ^ B4 << 3, n4 = (i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24) ^ g6 >>> 29, B4 = (i3[0 | (a4 = Q4 + 32 | 0)] | i3[a4 + 1 | 0] << 8 | i3[a4 + 2 | 0] << 16 | i3[a4 + 3 | 0] << 24) ^ g6 << 3, w4 = Q4 + 16 | 0, f4 = Q4 + 48 | 0, D4 = Q4 - -64 | 0, e4 = Q4 + 80 | 0, c4 = Q4 + 96 | 0, y4 = Q4 + 112 | 0; g6 = E3[y4 + 12 >> 2], E3[o4 + 280 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 284 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 272 >> 2] = E3[y4 >> 2], E3[o4 + 276 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 248 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 252 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 240 >> 2] = E3[c4 >> 2], E3[o4 + 244 >> 2] = g6, g6 = E3[y4 + 12 >> 2], E3[o4 + 232 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 236 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 224 >> 2] = E3[y4 >> 2], E3[o4 + 228 >> 2] = g6, aA(t4 = o4 + 256 | 0, o4 + 240 | 0, o4 + 224 | 0), g6 = E3[o4 + 268 >> 2], E3[y4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[y4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[y4 >> 2] = E3[o4 + 256 >> 2], E3[y4 + 4 >> 2] = g6, g6 = E3[e4 + 12 >> 2], E3[o4 + 216 >> 2] = E3[e4 + 8 >> 2], E3[o4 + 220 >> 2] = g6, g6 = E3[e4 + 4 >> 2], E3[o4 + 208 >> 2] = E3[e4 >> 2], E3[o4 + 212 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 200 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 204 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 192 >> 2] = E3[c4 >> 2], E3[o4 + 196 >> 2] = g6, aA(t4, o4 + 208 | 0, o4 + 192 | 0), g6 = E3[o4 + 268 >> 2], E3[c4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[c4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[c4 >> 2] = E3[o4 + 256 >> 2], E3[c4 + 4 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 184 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 188 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 176 >> 2] = E3[D4 >> 2], E3[o4 + 180 >> 2] = g6, g6 = E3[e4 + 12 >> 2], E3[o4 + 168 >> 2] = E3[e4 + 8 >> 2], E3[o4 + 172 >> 2] = g6, g6 = E3[e4 + 4 >> 2], E3[o4 + 160 >> 2] = E3[e4 >> 2], E3[o4 + 164 >> 2] = g6, aA(t4, o4 + 176 | 0, o4 + 160 | 0), g6 = E3[o4 + 268 >> 2], E3[e4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[e4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[e4 >> 2] = E3[o4 + 256 >> 2], E3[e4 + 4 >> 2] = g6, g6 = E3[f4 + 12 >> 2], E3[o4 + 152 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 156 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 144 >> 2] = E3[f4 >> 2], E3[o4 + 148 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 136 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 140 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 128 >> 2] = E3[D4 >> 2], E3[o4 + 132 >> 2] = g6, aA(t4, o4 + 144 | 0, o4 + 128 | 0), g6 = E3[o4 + 268 >> 2], E3[D4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[D4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[D4 >> 2] = E3[o4 + 256 >> 2], E3[D4 + 4 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 120 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 124 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 112 >> 2] = E3[a4 >> 2], E3[o4 + 116 >> 2] = g6, g6 = E3[f4 + 12 >> 2], E3[o4 + 104 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 108 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 96 >> 2] = E3[f4 >> 2], E3[o4 + 100 >> 2] = g6, aA(t4, o4 + 112 | 0, o4 + 96 | 0), g6 = E3[o4 + 268 >> 2], E3[f4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[f4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[f4 >> 2] = E3[o4 + 256 >> 2], E3[f4 + 4 >> 2] = g6, g6 = E3[w4 + 12 >> 2], E3[o4 + 88 >> 2] = E3[w4 + 8 >> 2], E3[o4 + 92 >> 2] = g6, g6 = E3[w4 + 4 >> 2], E3[o4 + 80 >> 2] = E3[w4 >> 2], E3[o4 + 84 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 72 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 76 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 64 >> 2] = E3[a4 >> 2], E3[o4 + 68 >> 2] = g6, aA(t4, o4 + 80 | 0, o4 - -64 | 0), g6 = E3[o4 + 268 >> 2], E3[a4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[a4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[a4 >> 2] = E3[o4 + 256 >> 2], E3[a4 + 4 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 56 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 60 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 + 48 >> 2] = E3[Q4 >> 2], E3[o4 + 52 >> 2] = g6, g6 = E3[w4 + 12 >> 2], E3[o4 + 40 >> 2] = E3[w4 + 8 >> 2], E3[o4 + 44 >> 2] = g6, g6 = E3[w4 + 4 >> 2], E3[o4 + 32 >> 2] = E3[w4 >> 2], E3[o4 + 36 >> 2] = g6, aA(t4, o4 + 48 | 0, o4 + 32 | 0), g6 = E3[o4 + 268 >> 2], E3[w4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[w4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[w4 >> 2] = E3[o4 + 256 >> 2], E3[w4 + 4 >> 2] = g6, g6 = E3[o4 + 284 >> 2], E3[o4 + 24 >> 2] = E3[o4 + 280 >> 2], E3[o4 + 28 >> 2] = g6, g6 = E3[o4 + 276 >> 2], E3[o4 + 16 >> 2] = E3[o4 + 272 >> 2], E3[o4 + 20 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 8 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 12 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 >> 2] = E3[Q4 >> 2], E3[o4 + 4 >> 2] = g6, aA(t4, o4 + 16 | 0, o4), g6 = E3[o4 + 268 >> 2], E3[Q4 + 8 >> 2] = E3[o4 + 264 >> 2], E3[Q4 + 12 >> 2] = g6, g6 = E3[o4 + 260 >> 2], E3[Q4 >> 2] = E3[o4 + 256 >> 2], E3[Q4 + 4 >> 2] = g6, F4 = h4 ^ (i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24), E3[Q4 + 12 >> 2] = F4, S4 = k4 ^ (i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24), E3[Q4 + 8 >> 2] = S4, M4 = n4 ^ (i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24), E3[Q4 + 4 >> 2] = M4, N4 = B4 ^ (i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), E3[Q4 >> 2] = N4, K4 = B4 ^ (i3[0 | D4] | i3[D4 + 1 | 0] << 8 | i3[D4 + 2 | 0] << 16 | i3[D4 + 3 | 0] << 24), E3[D4 >> 2] = K4, _4 = n4 ^ (i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24), E3[Q4 + 68 >> 2] = _4, p4 = k4 ^ (i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24), E3[Q4 + 72 >> 2] = p4, H4 = h4 ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24), E3[Q4 + 76 >> 2] = H4, 7 != (0 | (s4 = s4 + 1 | 0)); ) ; + A: { + I: { + g: { + if (g6 = I7 - 16 | 0) { + if (16 == (0 | g6)) break g; + break I; + } + D4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, a4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, w4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, f4 = i3[Q4 + 96 | 0] | i3[Q4 + 97 | 0] << 8 | i3[Q4 + 98 | 0] << 16 | i3[Q4 + 99 | 0] << 24, e4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, c4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, y4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, t4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, h4 = i3[Q4 + 100 | 0] | i3[Q4 + 101 | 0] << 8 | i3[Q4 + 102 | 0] << 16 | i3[Q4 + 103 | 0] << 24, k4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, n4 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, s4 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, B4 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, g6 = i3[Q4 + 104 | 0] | i3[Q4 + 105 | 0] << 8 | i3[Q4 + 106 | 0] << 16 | i3[Q4 + 107 | 0] << 24, I7 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, Q4 = F4 ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24) ^ (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 108 | 0] | i3[Q4 + 109 | 0] << 8 | i3[Q4 + 110 | 0] << 16 | i3[Q4 + 111 | 0] << 24) ^ H4, C3[A8 + 12 | 0] = Q4, C3[A8 + 13 | 0] = Q4 >>> 8, C3[A8 + 14 | 0] = Q4 >>> 16, C3[A8 + 15 | 0] = Q4 >>> 24, I7 = n4 ^ s4 ^ B4 ^ I7 ^ g6 ^ p4 ^ S4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = c4 ^ y4 ^ t4 ^ h4 ^ k4 ^ _4 ^ M4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = D4 ^ a4 ^ w4 ^ f4 ^ e4 ^ K4 ^ N4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24; + break A; + } + y4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, t4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, h4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, k4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, n4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, s4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, B4 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, g6 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, I7 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, c4 = F4 ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24) ^ (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24), C3[A8 + 12 | 0] = c4, C3[A8 + 13 | 0] = c4 >>> 8, C3[A8 + 14 | 0] = c4 >>> 16, C3[A8 + 15 | 0] = c4 >>> 24, I7 = B4 ^ I7 ^ g6 ^ S4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = k4 ^ n4 ^ s4 ^ M4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = y4 ^ t4 ^ h4 ^ N4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, f4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, e4 = i3[0 | (I7 = Q4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, c4 = i3[Q4 + 112 | 0] | i3[Q4 + 113 | 0] << 8 | i3[Q4 + 114 | 0] << 16 | i3[Q4 + 115 | 0] << 24, y4 = i3[Q4 + 96 | 0] | i3[Q4 + 97 | 0] << 8 | i3[Q4 + 98 | 0] << 16 | i3[Q4 + 99 | 0] << 24, t4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, h4 = i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24, k4 = i3[Q4 + 116 | 0] | i3[Q4 + 117 | 0] << 8 | i3[Q4 + 118 | 0] << 16 | i3[Q4 + 119 | 0] << 24, n4 = i3[Q4 + 100 | 0] | i3[Q4 + 101 | 0] << 8 | i3[Q4 + 102 | 0] << 16 | i3[Q4 + 103 | 0] << 24, s4 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, B4 = i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24, g6 = i3[Q4 + 120 | 0] | i3[Q4 + 121 | 0] << 8 | i3[Q4 + 122 | 0] << 16 | i3[Q4 + 123 | 0] << 24, I7 = i3[Q4 + 104 | 0] | i3[Q4 + 105 | 0] << 8 | i3[Q4 + 106 | 0] << 16 | i3[Q4 + 107 | 0] << 24, Q4 = (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24) ^ (i3[Q4 + 124 | 0] | i3[Q4 + 125 | 0] << 8 | i3[Q4 + 126 | 0] << 16 | i3[Q4 + 127 | 0] << 24) ^ (i3[Q4 + 108 | 0] | i3[Q4 + 109 | 0] << 8 | i3[Q4 + 110 | 0] << 16 | i3[Q4 + 111 | 0] << 24), C3[A8 + 28 | 0] = Q4, C3[A8 + 29 | 0] = Q4 >>> 8, C3[A8 + 30 | 0] = Q4 >>> 16, C3[A8 + 31 | 0] = Q4 >>> 24, I7 = s4 ^ B4 ^ I7 ^ g6, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = t4 ^ h4 ^ k4 ^ n4, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = f4 ^ e4 ^ c4 ^ y4, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24; + break A; + } + VA(A8, 0, I7); + } + r3 = o4 + 288 | 0; + } + function _3(A8, I7) { + var g6, C4, B4, Q4, i4, o4, D4, a4, y4, f4, e4, w4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, iA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0; + r3 = g6 = r3 - 48 | 0, U3(A8, I7), U3(A8 + 80 | 0, I7 + 40 | 0), H4 = PA(m4 = (IA2 = E3[I7 + 92 >> 2]) << 1, i4 = m4 >> 31, v4 = (Y4 = E3[I7 + 84 >> 2]) << 1, C4 = v4 >> 31), J4 = t3, AA2 = z2 = E3[I7 + 88 >> 2], G4 = (x4 = PA(z2, O2 = z2 >> 31, z2, O2)) + H4 | 0, H4 = t3 + J4 | 0, H4 = G4 >>> 0 < x4 >>> 0 ? H4 + 1 | 0 : H4, J4 = PA(d4 = E3[I7 + 96 >> 2], o4 = d4 >> 31, x4 = (R4 = E3[I7 + 80 >> 2]) << 1, B4 = x4 >> 31), H4 = t3 + H4 | 0, H4 = (G4 = J4 + G4 | 0) >>> 0 < J4 >>> 0 ? H4 + 1 | 0 : H4, CA2 = E3[I7 + 108 >> 2], J4 = PA(u4 = c3(CA2, 38), e4 = u4 >> 31, CA2, k4 = CA2 >> 31), H4 = t3 + H4 | 0, H4 = (G4 = J4 + G4 | 0) >>> 0 < J4 >>> 0 ? H4 + 1 | 0 : H4, J4 = G4, W2 = E3[I7 + 112 >> 2], L4 = PA(b4 = c3(W2, 19), D4 = b4 >> 31, G4 = (T2 = E3[I7 + 104 >> 2]) << 1, G4 >> 31), G4 = t3 + H4 | 0, G4 = (J4 = J4 + L4 | 0) >>> 0 < L4 >>> 0 ? G4 + 1 | 0 : G4, EA2 = E3[I7 + 116 >> 2], H4 = PA(L4 = c3(EA2, 38), Q4 = L4 >> 31, X2 = (Z2 = E3[I7 + 100 >> 2]) << 1, y4 = X2 >> 31), G4 = t3 + G4 | 0, iA2 = H4 = (H4 >>> 0 > (J4 = H4 + J4 | 0) >>> 0 ? G4 + 1 : G4) << 1 | J4 >>> 31, oA2 = J4 = 33554432 + (n4 = J4 << 1) | 0, cA2 = H4 = J4 >>> 0 < 33554432 ? H4 + 1 | 0 : H4, P4 = (67108863 & H4) << 6 | J4 >>> 26, V2 = H4 >> 26, H4 = PA(v4, C4, d4, o4), J4 = t3, G4 = ($2 = PA(z2 <<= 1, f4 = z2 >> 31, IA2, s4 = IA2 >> 31)) + H4 | 0, H4 = t3 + J4 | 0, H4 = G4 >>> 0 < $2 >>> 0 ? H4 + 1 | 0 : H4, J4 = ($2 = PA(Z2, w4 = Z2 >> 31, x4, B4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = J4 >>> 0 < $2 >>> 0 ? G4 + 1 | 0 : G4, BA2 = PA(b4, D4, $2 = CA2 << 1, F4 = $2 >> 31), H4 = t3 + G4 | 0, H4 = (J4 = BA2 + J4 | 0) >>> 0 < BA2 >>> 0 ? H4 + 1 | 0 : H4, G4 = PA(L4, Q4, T2, a4 = T2 >> 31), H4 = t3 + H4 | 0, G4 = (G4 = (G4 >>> 0 > (J4 = G4 + J4 | 0) >>> 0 ? H4 + 1 : H4) << 1 | J4 >>> 31) + V2 | 0, BA2 = J4 = (H4 = J4 << 1) + P4 | 0, H4 = G4 = H4 >>> 0 > J4 >>> 0 ? G4 + 1 | 0 : G4, DA2 = J4 = J4 + 16777216 | 0, P4 = (33554431 & (H4 = J4 >>> 0 < 16777216 ? H4 + 1 | 0 : H4)) << 7 | J4 >>> 25, V2 = H4 >> 25, H4 = PA(m4, i4, IA2, s4), J4 = t3, G4 = (j2 = PA(d4, o4, z2, f4)) + H4 | 0, H4 = t3 + J4 | 0, H4 = G4 >>> 0 < j2 >>> 0 ? H4 + 1 | 0 : H4, J4 = PA(v4, C4, X2, y4), H4 = t3 + H4 | 0, H4 = (G4 = J4 + G4 | 0) >>> 0 < J4 >>> 0 ? H4 + 1 | 0 : H4, J4 = (j2 = PA(x4, B4, T2, a4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = J4 >>> 0 < j2 >>> 0 ? G4 + 1 | 0 : G4, j2 = PA(b4, D4, W2, h4 = W2 >> 31), H4 = t3 + G4 | 0, H4 = (J4 = j2 + J4 | 0) >>> 0 < j2 >>> 0 ? H4 + 1 | 0 : H4, j2 = PA(L4, Q4, $2, F4), G4 = t3 + H4 | 0, G4 = ((J4 = j2 + J4 | 0) >>> 0 < j2 >>> 0 ? G4 + 1 : G4) << 1 | J4 >>> 31, J4 = (H4 = P4) + (P4 = J4 << 1) | 0, H4 = G4 + V2 | 0, H4 = J4 >>> 0 < P4 >>> 0 ? H4 + 1 | 0 : H4, V2 = J4, j2 = G4 = J4 + 33554432 | 0, J4 = H4 = G4 >>> 0 < 33554432 ? H4 + 1 | 0 : H4, E3[A8 + 144 >> 2] = V2 - (-67108864 & G4), V2 = PA(H4 = c3(Z2, 38), H4 >> 31, Z2, w4), P4 = t3, R4 = PA(H4 = R4, G4 = H4 >> 31, H4, G4), G4 = t3 + P4 | 0, G4 = (H4 = R4 + V2 | 0) >>> 0 < R4 >>> 0 ? G4 + 1 | 0 : G4, P4 = (gA2 = PA(R4 = c3(T2, 19), S4 = R4 >> 31, V2 = d4 << 1, M4 = V2 >> 31)) + H4 | 0, H4 = t3 + G4 | 0, H4 = P4 >>> 0 < gA2 >>> 0 ? H4 + 1 | 0 : H4, G4 = P4, P4 = PA(m4, i4, u4, e4), H4 = t3 + H4 | 0, H4 = (G4 = G4 + P4 | 0) >>> 0 < P4 >>> 0 ? H4 + 1 | 0 : H4, P4 = (gA2 = PA(b4, D4, z2, f4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = P4 >>> 0 < gA2 >>> 0 ? G4 + 1 | 0 : G4, gA2 = PA(v4, C4, L4, Q4), H4 = t3 + G4 | 0, gA2 = H4 = ((P4 = gA2 + P4 | 0) >>> 0 < gA2 >>> 0 ? H4 + 1 : H4) << 1 | P4 >>> 31, _4 = G4 = (P4 = 33554432 + (N4 = P4 << 1) | 0) >>> 0 < 33554432 ? H4 + 1 | 0 : H4, QA2 = (67108863 & G4) << 6 | P4 >>> 26, aA2 = G4 >> 26, H4 = PA(R4, S4, X2, y4), q4 = t3, l3 = Y4, G4 = (Y4 = PA(x4, B4, Y4, K4 = Y4 >> 31)) + H4 | 0, H4 = t3 + q4 | 0, H4 = G4 >>> 0 < Y4 >>> 0 ? H4 + 1 | 0 : H4, Y4 = (q4 = PA(d4, o4, u4, e4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = Y4 >>> 0 < q4 >>> 0 ? G4 + 1 | 0 : G4, q4 = PA(b4, D4, m4, i4), H4 = t3 + G4 | 0, H4 = (Y4 = q4 + Y4 | 0) >>> 0 < q4 >>> 0 ? H4 + 1 | 0 : H4, q4 = PA(L4, Q4, AA2, O2), G4 = t3 + H4 | 0, G4 = ((Y4 = q4 + Y4 | 0) >>> 0 < q4 >>> 0 ? G4 + 1 : G4) << 1 | Y4 >>> 31, Y4 = (H4 = QA2) + (QA2 = Y4 << 1) | 0, H4 = G4 + aA2 | 0, H4 = Y4 >>> 0 < QA2 >>> 0 ? H4 + 1 | 0 : H4, aA2 = Y4, QA2 = Y4 = Y4 + 16777216 | 0, p4 = (33554431 & (H4 = Y4 >>> 0 < 16777216 ? H4 + 1 | 0 : H4)) << 7 | Y4 >>> 25, q4 = H4 >> 25, H4 = PA(x4, B4, AA2, O2), Y4 = t3, G4 = (l3 = PA(v4, C4, l3, K4)) + H4 | 0, H4 = t3 + Y4 | 0, Y4 = (R4 = PA(R4, S4, T2, a4)) + G4 | 0, G4 = t3 + (G4 >>> 0 < l3 >>> 0 ? H4 + 1 | 0 : H4) | 0, G4 = Y4 >>> 0 < R4 >>> 0 ? G4 + 1 | 0 : G4, R4 = PA(X2, y4, u4, e4), H4 = t3 + G4 | 0, H4 = (Y4 = R4 + Y4 | 0) >>> 0 < R4 >>> 0 ? H4 + 1 | 0 : H4, G4 = Y4, Y4 = PA(b4, D4, V2, M4), H4 = t3 + H4 | 0, H4 = (G4 = G4 + Y4 | 0) >>> 0 < Y4 >>> 0 ? H4 + 1 | 0 : H4, Y4 = (R4 = PA(L4, Q4, m4, i4)) + G4 | 0, G4 = t3 + H4 | 0, H4 = (H4 = (Y4 >>> 0 < R4 >>> 0 ? G4 + 1 : G4) << 1 | Y4 >>> 31) + q4 | 0, l3 = Y4 = (G4 = Y4 << 1) + p4 | 0, H4 = G4 >>> 0 > Y4 >>> 0 ? H4 + 1 | 0 : H4, Y4 = (R4 = Y4 + 33554432 | 0) >>> 0 < 33554432 ? H4 + 1 | 0 : H4, E3[A8 + 128 >> 2] = l3 - (-67108864 & R4), H4 = PA(z2, f4, Z2, w4), G4 = t3, l3 = PA(d4, o4, m4, i4), G4 = t3 + G4 | 0, G4 = (H4 = l3 + H4 | 0) >>> 0 < l3 >>> 0 ? G4 + 1 | 0 : G4, l3 = (q4 = PA(v4, C4, T2, a4)) + H4 | 0, H4 = t3 + G4 | 0, H4 = l3 >>> 0 < q4 >>> 0 ? H4 + 1 | 0 : H4, q4 = PA(x4, B4, CA2, k4), G4 = t3 + H4 | 0, G4 = (l3 = q4 + l3 | 0) >>> 0 < q4 >>> 0 ? G4 + 1 | 0 : G4, q4 = PA(L4, Q4, W2, h4), H4 = t3 + G4 | 0, H4 = (G4 = J4 >> 26) + (((l3 = q4 + l3 | 0) >>> 0 < q4 >>> 0 ? H4 + 1 : H4) << 1 | l3 >>> 31) | 0, H4 = (J4 = (j2 = (67108863 & J4) << 6 | j2 >>> 26) + (l3 << 1) | 0) >>> 0 < j2 >>> 0 ? H4 + 1 | 0 : H4, j2 = J4, G4 = H4, l3 = H4 = J4 + 16777216 | 0, J4 = G4 = H4 >>> 0 < 16777216 ? G4 + 1 | 0 : G4, E3[A8 + 148 >> 2] = j2 - (-33554432 & H4), H4 = PA(x4, B4, IA2, s4), IA2 = t3, G4 = (O2 = PA(v4, C4, AA2, O2)) + H4 | 0, H4 = t3 + IA2 | 0, H4 = G4 >>> 0 < O2 >>> 0 ? H4 + 1 | 0 : H4, u4 = PA(T2, a4, u4, e4), H4 = t3 + H4 | 0, H4 = (G4 = u4 + G4 | 0) >>> 0 < u4 >>> 0 ? H4 + 1 | 0 : H4, b4 = (u4 = PA(b4, D4, X2, y4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = b4 >>> 0 < u4 >>> 0 ? G4 + 1 | 0 : G4, H4 = b4, b4 = PA(L4, Q4, d4, o4), G4 = t3 + G4 | 0, G4 = ((H4 = H4 + b4 | 0) >>> 0 < b4 >>> 0 ? G4 + 1 : G4) << 1, b4 = H4, H4 = (H4 = G4 | H4 >>> 31) + (G4 = Y4 >> 26) | 0, H4 = (Y4 = (j2 = b4 << 1) + (b4 = (67108863 & Y4) << 6 | R4 >>> 26) | 0) >>> 0 < b4 >>> 0 ? H4 + 1 | 0 : H4, b4 = Y4, u4 = G4 = Y4 + 16777216 | 0, Y4 = H4 = G4 >>> 0 < 16777216 ? H4 + 1 | 0 : H4, E3[A8 + 132 >> 2] = b4 - (-33554432 & G4), H4 = PA(T2, a4, z2, f4), b4 = t3, G4 = (d4 = PA(d4, o4, d4, o4)) + H4 | 0, H4 = t3 + b4 | 0, H4 = G4 >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = PA(m4, i4, X2, y4), H4 = t3 + H4 | 0, H4 = (G4 = d4 + G4 | 0) >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = PA(v4, C4, $2, F4), H4 = t3 + H4 | 0, H4 = (G4 = d4 + G4 | 0) >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = (b4 = PA(x4, B4, W2, h4)) + G4 | 0, G4 = t3 + H4 | 0, G4 = d4 >>> 0 < b4 >>> 0 ? G4 + 1 | 0 : G4, H4 = d4, d4 = PA(d4 = L4, Q4, L4 = EA2, X2 = L4 >> 31), G4 = t3 + G4 | 0, G4 = ((H4 = H4 + d4 | 0) >>> 0 < d4 >>> 0 ? G4 + 1 : G4) << 1, d4 = H4, H4 = (H4 = G4 | H4 >>> 31) + (G4 = J4 >> 25) | 0, H4 = (J4 = (b4 = d4 << 1) + (d4 = (33554431 & J4) << 7 | l3 >>> 25) | 0) >>> 0 < d4 >>> 0 ? H4 + 1 | 0 : H4, d4 = J4, b4 = G4 = J4 + 33554432 | 0, J4 = H4 = G4 >>> 0 < 33554432 ? H4 + 1 | 0 : H4, E3[A8 + 152 >> 2] = d4 - (-67108864 & G4), G4 = n4 - (H4 = -67108864 & oA2) | 0, d4 = iA2 - ((H4 >>> 0 > n4 >>> 0) + cA2 | 0) | 0, H4 = Y4 >> 25, Y4 = (u4 = (33554431 & Y4) << 7 | u4 >>> 25) + G4 | 0, G4 = H4 + d4 | 0, d4 = Y4, H4 = G4 = Y4 >>> 0 < u4 >>> 0 ? G4 + 1 | 0 : G4, H4 = ((67108863 & (H4 = (Y4 = Y4 + 33554432 | 0) >>> 0 < 33554432 ? H4 + 1 | 0 : H4)) << 6 | Y4 >>> 26) + (O2 = BA2 - (-33554432 & DA2) | 0) | 0, E3[A8 + 140 >> 2] = H4, E3[A8 + 136 >> 2] = d4 - (-67108864 & Y4), H4 = PA(m4, i4, T2, a4), G4 = t3, Y4 = PA(Z2, w4, V2, M4), G4 = t3 + G4 | 0, G4 = (H4 = Y4 + H4 | 0) >>> 0 < Y4 >>> 0 ? G4 + 1 | 0 : G4, Y4 = (m4 = PA(z2, f4, CA2, k4)) + H4 | 0, H4 = t3 + G4 | 0, H4 = Y4 >>> 0 < m4 >>> 0 ? H4 + 1 | 0 : H4, v4 = PA(v4, C4, W2, h4), G4 = t3 + H4 | 0, G4 = (Y4 = v4 + Y4 | 0) >>> 0 < v4 >>> 0 ? G4 + 1 | 0 : G4, v4 = PA(x4, B4, L4, X2), H4 = t3 + G4 | 0, H4 = (H4 = ((Y4 = v4 + Y4 | 0) >>> 0 < v4 >>> 0 ? H4 + 1 : H4) << 1 | Y4 >>> 31) + (G4 = J4 >> 26) | 0, G4 = (J4 = (d4 = Y4 << 1) + (Y4 = (67108863 & J4) << 6 | b4 >>> 26) | 0) >>> 0 < Y4 >>> 0 ? H4 + 1 | 0 : H4, G4 = (H4 = J4 + 16777216 | 0) >>> 0 < 16777216 ? G4 + 1 | 0 : G4, E3[A8 + 156 >> 2] = J4 - (-33554432 & H4), Y4 = aA2 - (-33554432 & QA2) | 0, v4 = N4 - (J4 = -67108864 & P4) | 0, x4 = gA2 - ((J4 >>> 0 > N4 >>> 0) + _4 | 0) | 0, J4 = PA((33554431 & G4) << 7 | H4 >>> 25, G4 >> 25, 19, 0), G4 = t3 + x4 | 0, G4 = (H4 = J4 + v4 | 0) >>> 0 < J4 >>> 0 ? G4 + 1 | 0 : G4, J4 = H4, G4 = ((67108863 & (G4 = (H4 = H4 + 33554432 | 0) >>> 0 < 33554432 ? G4 + 1 | 0 : G4)) << 6 | H4 >>> 26) + Y4 | 0, E3[A8 + 124 >> 2] = G4, E3[A8 + 120 >> 2] = J4 - (-67108864 & H4), H4 = E3[I7 + 44 >> 2], G4 = E3[I7 + 4 >> 2], J4 = E3[I7 + 48 >> 2], Y4 = E3[I7 + 8 >> 2], v4 = E3[I7 + 52 >> 2], x4 = E3[I7 + 12 >> 2], L4 = E3[I7 + 56 >> 2], m4 = E3[I7 + 16 >> 2], d4 = E3[I7 + 60 >> 2], b4 = E3[I7 + 20 >> 2], T2 = E3[I7 - -64 >> 2], X2 = E3[I7 + 24 >> 2], z2 = E3[I7 + 68 >> 2], u4 = E3[I7 + 28 >> 2], O2 = E3[I7 + 72 >> 2], Z2 = E3[I7 + 32 >> 2], W2 = E3[I7 + 40 >> 2], AA2 = E3[I7 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] + E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = O2 + Z2, E3[A8 + 68 >> 2] = u4 + z2, E3[(CA2 = A8 - -64 | 0) >> 2] = T2 + X2, E3[A8 + 60 >> 2] = d4 + b4, E3[A8 + 56 >> 2] = L4 + m4, E3[A8 + 52 >> 2] = v4 + x4, E3[A8 + 48 >> 2] = J4 + Y4, E3[A8 + 44 >> 2] = H4 + G4, E3[A8 + 40 >> 2] = W2 + AA2, U3(g6, A8 + 40 | 0), I7 = E3[A8 + 4 >> 2], H4 = E3[A8 + 84 >> 2], G4 = E3[A8 + 8 >> 2], J4 = E3[A8 + 88 >> 2], Y4 = E3[A8 + 12 >> 2], v4 = E3[A8 + 92 >> 2], x4 = E3[A8 + 16 >> 2], L4 = E3[A8 + 96 >> 2], m4 = E3[A8 + 20 >> 2], d4 = E3[A8 + 100 >> 2], b4 = E3[A8 + 24 >> 2], T2 = E3[A8 + 104 >> 2], X2 = E3[A8 + 28 >> 2], z2 = E3[A8 + 108 >> 2], u4 = E3[A8 + 32 >> 2], O2 = E3[A8 + 112 >> 2], Z2 = E3[A8 >> 2], W2 = E3[A8 + 80 >> 2], $2 = (AA2 = E3[A8 + 116 >> 2]) - (IA2 = E3[A8 + 36 >> 2]) | 0, E3[A8 + 116 >> 2] = $2, R4 = O2 - u4 | 0, E3[A8 + 112 >> 2] = R4, V2 = z2 - X2 | 0, E3[A8 + 108 >> 2] = V2, P4 = T2 - b4 | 0, E3[A8 + 104 >> 2] = P4, EA2 = d4 - m4 | 0, E3[A8 + 100 >> 2] = EA2, iA2 = L4 - x4 | 0, E3[A8 + 96 >> 2] = iA2, oA2 = v4 - Y4 | 0, E3[A8 + 92 >> 2] = oA2, cA2 = J4 - G4 | 0, E3[A8 + 88 >> 2] = cA2, BA2 = H4 - I7 | 0, E3[A8 + 84 >> 2] = BA2, DA2 = W2 - Z2 | 0, E3[A8 + 80 >> 2] = DA2, AA2 = AA2 + IA2 | 0, E3[A8 + 76 >> 2] = AA2, u4 = u4 + O2 | 0, E3[A8 + 72 >> 2] = u4, X2 = z2 + X2 | 0, E3[A8 + 68 >> 2] = X2, b4 = b4 + T2 | 0, E3[CA2 >> 2] = b4, m4 = d4 + m4 | 0, E3[A8 + 60 >> 2] = m4, x4 = L4 + x4 | 0, E3[A8 + 56 >> 2] = x4, Y4 = Y4 + v4 | 0, E3[A8 + 52 >> 2] = Y4, G4 = G4 + J4 | 0, E3[A8 + 48 >> 2] = G4, I7 = I7 + H4 | 0, E3[A8 + 44 >> 2] = I7, H4 = Z2 + W2 | 0, E3[A8 + 40 >> 2] = H4, J4 = E3[g6 >> 2], v4 = E3[g6 + 4 >> 2], L4 = E3[g6 + 8 >> 2], d4 = E3[g6 + 12 >> 2], T2 = E3[g6 + 16 >> 2], z2 = E3[g6 + 20 >> 2], O2 = E3[g6 + 24 >> 2], Z2 = E3[g6 + 28 >> 2], W2 = E3[g6 + 32 >> 2], E3[A8 + 36 >> 2] = E3[g6 + 36 >> 2] - AA2, E3[A8 + 32 >> 2] = W2 - u4, E3[A8 + 28 >> 2] = Z2 - X2, E3[A8 + 24 >> 2] = O2 - b4, E3[A8 + 20 >> 2] = z2 - m4, E3[A8 + 16 >> 2] = T2 - x4, E3[A8 + 12 >> 2] = d4 - Y4, E3[A8 + 8 >> 2] = L4 - G4, E3[A8 + 4 >> 2] = v4 - I7, E3[A8 >> 2] = J4 - H4, I7 = E3[A8 + 124 >> 2], H4 = E3[A8 + 128 >> 2], G4 = E3[A8 + 132 >> 2], J4 = E3[A8 + 136 >> 2], Y4 = E3[A8 + 140 >> 2], v4 = E3[A8 + 144 >> 2], x4 = E3[A8 + 148 >> 2], L4 = E3[A8 + 152 >> 2], m4 = E3[A8 + 120 >> 2], E3[A8 + 156 >> 2] = E3[A8 + 156 >> 2] - $2, E3[A8 + 152 >> 2] = L4 - R4, E3[A8 + 148 >> 2] = x4 - V2, E3[A8 + 144 >> 2] = v4 - P4, E3[A8 + 140 >> 2] = Y4 - EA2, E3[A8 + 136 >> 2] = J4 - iA2, E3[A8 + 132 >> 2] = G4 - oA2, E3[A8 + 128 >> 2] = H4 - cA2, E3[A8 + 124 >> 2] = I7 - BA2, E3[A8 + 120 >> 2] = m4 - DA2, r3 = g6 + 48 | 0; + } + function p3(A8, I7, g6, C4) { + var B4 = 0, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0; + for (B4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, E3[g6 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, E3[g6 + 4 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, E3[g6 + 8 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, E3[g6 + 12 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, E3[g6 + 16 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, E3[g6 + 20 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, E3[g6 + 24 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, E3[g6 + 28 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 32 | 0] | i3[I7 + 33 | 0] << 8 | i3[I7 + 34 | 0] << 16 | i3[I7 + 35 | 0] << 24, E3[g6 + 32 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 36 | 0] | i3[I7 + 37 | 0] << 8 | i3[I7 + 38 | 0] << 16 | i3[I7 + 39 | 0] << 24, E3[g6 + 36 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24, E3[g6 + 40 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, E3[g6 + 44 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 48 | 0] | i3[I7 + 49 | 0] << 8 | i3[I7 + 50 | 0] << 16 | i3[I7 + 51 | 0] << 24, E3[g6 + 48 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 52 | 0] | i3[I7 + 53 | 0] << 8 | i3[I7 + 54 | 0] << 16 | i3[I7 + 55 | 0] << 24, E3[g6 + 52 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, B4 = i3[I7 + 56 | 0] | i3[I7 + 57 | 0] << 8 | i3[I7 + 58 | 0] << 16 | i3[I7 + 59 | 0] << 24, E3[g6 + 56 >> 2] = B4 << 24 | (65280 & B4) << 8 | B4 >>> 8 & 65280 | B4 >>> 24, I7 = i3[I7 + 60 | 0] | i3[I7 + 61 | 0] << 8 | i3[I7 + 62 | 0] << 16 | i3[I7 + 63 | 0] << 24, E3[g6 + 60 >> 2] = I7 << 24 | (65280 & I7) << 8 | I7 >>> 8 & 65280 | I7 >>> 24, I7 = E3[A8 + 28 >> 2], E3[C4 + 24 >> 2] = E3[A8 + 24 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[A8 + 20 >> 2], E3[C4 + 16 >> 2] = E3[A8 + 16 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[A8 + 12 >> 2], E3[C4 + 8 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 12 >> 2] = I7, I7 = E3[A8 + 4 >> 2], E3[C4 >> 2] = E3[A8 >> 2], E3[C4 + 4 >> 2] = I7; D4 = E3[C4 + 28 >> 2], B4 = (I7 = F4 << 2) + g6 | 0, o4 = E3[C4 + 16 >> 2], a4 = E3[B4 >> 2] + (gI(o4, 26) ^ gI(o4, 21) ^ gI(o4, 7)) | 0, f4 = (D4 = ((Q4 = E3[I7 + 34784 >> 2] + a4 | 0) + (o4 & ((a4 = E3[C4 + 24 >> 2]) ^ (e4 = E3[C4 + 20 >> 2])) ^ a4) | 0) + D4 | 0) + E3[C4 + 12 >> 2] | 0, E3[C4 + 12 >> 2] = f4, D4 = (r4 = D4 + (gI(y4 = E3[C4 >> 2], 30) ^ gI(y4, 19) ^ gI(y4, 10)) | 0) + (y4 & ((Q4 = E3[C4 + 8 >> 2]) | (c4 = E3[C4 + 4 >> 2])) | Q4 & c4) | 0, E3[C4 + 28 >> 2] = D4, Q4 = (r4 = Q4) + (a4 = (E3[(h4 = (Q4 = 4 | I7) + g6 | 0) >> 2] + ((a4 + (e4 ^ f4 & (o4 ^ e4)) | 0) + (gI(f4, 26) ^ gI(f4, 21) ^ gI(f4, 7)) | 0) | 0) + E3[Q4 + 34784 >> 2] | 0) | 0, E3[C4 + 8 >> 2] = Q4, a4 = (a4 + (D4 & (c4 | y4) | c4 & y4) | 0) + (gI(D4, 30) ^ gI(D4, 19) ^ gI(D4, 10)) | 0, E3[C4 + 24 >> 2] = a4, e4 = (r4 = c4) + (c4 = (((e4 + E3[(s4 = (c4 = 8 | I7) + g6 | 0) >> 2] | 0) + E3[c4 + 34784 >> 2] | 0) + (o4 ^ Q4 & (o4 ^ f4)) | 0) + (gI(Q4, 26) ^ gI(Q4, 21) ^ gI(Q4, 7)) | 0) | 0, E3[C4 + 4 >> 2] = e4, c4 = c4 + ((a4 & (D4 | y4) | D4 & y4) + (gI(a4, 30) ^ gI(a4, 19) ^ gI(a4, 10)) | 0) | 0, E3[C4 + 20 >> 2] = c4, o4 = (r4 = y4) + (y4 = (((o4 + E3[(S4 = (y4 = 12 | I7) + g6 | 0) >> 2] | 0) + E3[y4 + 34784 >> 2] | 0) + (f4 ^ e4 & (Q4 ^ f4)) | 0) + (gI(e4, 26) ^ gI(e4, 21) ^ gI(e4, 7)) | 0) | 0, E3[C4 >> 2] = o4, y4 = y4 + ((c4 & (D4 | a4) | D4 & a4) + (gI(c4, 30) ^ gI(c4, 19) ^ gI(c4, 10)) | 0) | 0, E3[C4 + 16 >> 2] = y4, f4 = (w4 = ((((r4 = f4) + E3[(M4 = (f4 = 16 | I7) + g6 | 0) >> 2] | 0) + E3[f4 + 34784 >> 2] | 0) + (Q4 ^ o4 & (Q4 ^ e4)) | 0) + (gI(o4, 26) ^ gI(o4, 21) ^ gI(o4, 7)) | 0) + ((y4 & (c4 | a4) | c4 & a4) + (gI(y4, 30) ^ gI(y4, 19) ^ gI(y4, 10)) | 0) | 0, E3[C4 + 12 >> 2] = f4, w4 = D4 + w4 | 0, E3[C4 + 28 >> 2] = w4, D4 = (Q4 = (((Q4 + E3[(N4 = (D4 = 20 | I7) + g6 | 0) >> 2] | 0) + E3[D4 + 34784 >> 2] | 0) + (e4 ^ w4 & (o4 ^ e4)) | 0) + (gI(w4, 26) ^ gI(w4, 21) ^ gI(w4, 7)) | 0) + ((f4 & (c4 | y4) | c4 & y4) + (gI(f4, 30) ^ gI(f4, 19) ^ gI(f4, 10)) | 0) | 0, E3[C4 + 8 >> 2] = D4, Q4 = Q4 + a4 | 0, E3[C4 + 24 >> 2] = Q4, a4 = (e4 = (((e4 + E3[(K4 = (a4 = 24 | I7) + g6 | 0) >> 2] | 0) + E3[a4 + 34784 >> 2] | 0) + (o4 ^ Q4 & (o4 ^ w4)) | 0) + (gI(Q4, 26) ^ gI(Q4, 21) ^ gI(Q4, 7)) | 0) + ((D4 & (y4 | f4) | y4 & f4) + (gI(D4, 30) ^ gI(D4, 19) ^ gI(D4, 10)) | 0) | 0, E3[C4 + 4 >> 2] = a4, e4 = c4 + e4 | 0, E3[C4 + 20 >> 2] = e4, c4 = (o4 = (((o4 + E3[(_4 = (c4 = 28 | I7) + g6 | 0) >> 2] | 0) + E3[c4 + 34784 >> 2] | 0) + (w4 ^ e4 & (Q4 ^ w4)) | 0) + (gI(e4, 26) ^ gI(e4, 21) ^ gI(e4, 7)) | 0) + ((a4 & (D4 | f4) | D4 & f4) + (gI(a4, 30) ^ gI(a4, 19) ^ gI(a4, 10)) | 0) | 0, E3[C4 >> 2] = c4, o4 = o4 + y4 | 0, E3[C4 + 16 >> 2] = o4, y4 = (w4 = (((w4 + E3[(p4 = (y4 = 32 | I7) + g6 | 0) >> 2] | 0) + E3[y4 + 34784 >> 2] | 0) + (Q4 ^ o4 & (Q4 ^ e4)) | 0) + (gI(o4, 26) ^ gI(o4, 21) ^ gI(o4, 7)) | 0) + ((c4 & (D4 | a4) | D4 & a4) + (gI(c4, 30) ^ gI(c4, 19) ^ gI(c4, 10)) | 0) | 0, E3[C4 + 28 >> 2] = y4, w4 = f4 + w4 | 0, E3[C4 + 12 >> 2] = w4, f4 = (Q4 = (((Q4 + E3[(H4 = (f4 = 36 | I7) + g6 | 0) >> 2] | 0) + E3[f4 + 34784 >> 2] | 0) + (e4 ^ w4 & (o4 ^ e4)) | 0) + (gI(w4, 26) ^ gI(w4, 21) ^ gI(w4, 7)) | 0) + ((y4 & (c4 | a4) | c4 & a4) + (gI(y4, 30) ^ gI(y4, 19) ^ gI(y4, 10)) | 0) | 0, E3[C4 + 24 >> 2] = f4, Q4 = Q4 + D4 | 0, E3[C4 + 8 >> 2] = Q4, D4 = (e4 = (((e4 + E3[(G4 = (D4 = 40 | I7) + g6 | 0) >> 2] | 0) + E3[D4 + 34784 >> 2] | 0) + (o4 ^ Q4 & (o4 ^ w4)) | 0) + (gI(Q4, 26) ^ gI(Q4, 21) ^ gI(Q4, 7)) | 0) + ((f4 & (c4 | y4) | c4 & y4) + (gI(f4, 30) ^ gI(f4, 19) ^ gI(f4, 10)) | 0) | 0, E3[C4 + 20 >> 2] = D4, e4 = a4 + e4 | 0, E3[C4 + 4 >> 2] = e4, r4 = (a4 = 44 | I7) + g6 | 0, a4 = (o4 = ((o4 + (E3[a4 + 34784 >> 2] + E3[r4 >> 2] | 0) | 0) + (w4 ^ e4 & (Q4 ^ w4)) | 0) + (gI(e4, 26) ^ gI(e4, 21) ^ gI(e4, 7)) | 0) + ((D4 & (y4 | f4) | y4 & f4) + (gI(D4, 30) ^ gI(D4, 19) ^ gI(D4, 10)) | 0) | 0, E3[C4 + 16 >> 2] = a4, c4 = c4 + o4 | 0, E3[C4 >> 2] = c4, n4 = (o4 = 48 | I7) + g6 | 0, o4 = (w4 = ((w4 + (E3[o4 + 34784 >> 2] + E3[n4 >> 2] | 0) | 0) + (Q4 ^ c4 & (Q4 ^ e4)) | 0) + (gI(c4, 26) ^ gI(c4, 21) ^ gI(c4, 7)) | 0) + ((a4 & (D4 | f4) | D4 & f4) + (gI(a4, 30) ^ gI(a4, 19) ^ gI(a4, 10)) | 0) | 0, E3[C4 + 12 >> 2] = o4, y4 = y4 + w4 | 0, E3[C4 + 28 >> 2] = y4, k4 = (w4 = 52 | I7) + g6 | 0, Q4 = (w4 = (((E3[w4 + 34784 >> 2] + E3[k4 >> 2] | 0) + Q4 | 0) + (e4 ^ y4 & (c4 ^ e4)) | 0) + (gI(y4, 26) ^ gI(y4, 21) ^ gI(y4, 7)) | 0) + ((o4 & (D4 | a4) | D4 & a4) + (gI(o4, 30) ^ gI(o4, 19) ^ gI(o4, 10)) | 0) | 0, E3[C4 + 8 >> 2] = Q4, f4 = f4 + w4 | 0, E3[C4 + 24 >> 2] = f4, w4 = (t4 = 56 | I7) + g6 | 0, e4 = (t4 = (((E3[t4 + 34784 >> 2] + E3[w4 >> 2] | 0) + e4 | 0) + (c4 ^ f4 & (c4 ^ y4)) | 0) + (gI(f4, 26) ^ gI(f4, 21) ^ gI(f4, 7)) | 0) + ((Q4 & (a4 | o4) | a4 & o4) + (gI(Q4, 30) ^ gI(Q4, 19) ^ gI(Q4, 10)) | 0) | 0, E3[C4 + 4 >> 2] = e4, D4 = D4 + t4 | 0, E3[C4 + 20 >> 2] = D4, t4 = (I7 |= 60) + g6 | 0, D4 = (I7 = ((c4 + (E3[I7 + 34784 >> 2] + E3[t4 >> 2] | 0) | 0) + (y4 ^ D4 & (y4 ^ f4)) | 0) + (gI(D4, 26) ^ gI(D4, 21) ^ gI(D4, 7)) | 0) + ((e4 & (Q4 | o4) | Q4 & o4) + (gI(e4, 30) ^ gI(e4, 19) ^ gI(e4, 10)) | 0) | 0, E3[C4 >> 2] = D4, E3[C4 + 16 >> 2] = I7 + a4, 48 != (0 | F4); ) c4 = E3[H4 >> 2], F4 = F4 + 16 | 0, I7 = E3[w4 >> 2], D4 = (Q4 = E3[B4 >> 2] + (c4 + (gI(I7, 15) ^ gI(I7, 13) ^ I7 >>> 10) | 0) | 0) + (gI(a4 = E3[h4 >> 2], 25) ^ gI(a4, 14) ^ a4 >>> 3) | 0, E3[(F4 << 2) + g6 >> 2] = D4, f4 = (o4 = (Q4 = (y4 = E3[G4 >> 2]) + a4 | 0) + (gI(a4 = E3[t4 >> 2], 15) ^ gI(a4, 13) ^ a4 >>> 10) | 0) + (gI(Q4 = E3[s4 >> 2], 25) ^ gI(Q4, 14) ^ Q4 >>> 3) | 0, E3[B4 + 68 >> 2] = f4, e4 = (r4 = ((o4 = Q4) + (Q4 = E3[r4 >> 2]) | 0) + (gI(D4, 15) ^ gI(D4, 13) ^ D4 >>> 10) | 0) + (gI(o4 = E3[S4 >> 2], 25) ^ gI(o4, 14) ^ o4 >>> 3) | 0, E3[B4 + 72 >> 2] = e4, w4 = (t4 = ((r4 = o4) + (o4 = E3[n4 >> 2]) | 0) + (gI(f4, 15) ^ gI(f4, 13) ^ f4 >>> 10) | 0) + (gI(r4 = E3[M4 >> 2], 25) ^ gI(r4, 14) ^ r4 >>> 3) | 0, E3[B4 + 76 >> 2] = w4, n4 = (t4 = ((t4 = r4) + (r4 = E3[k4 >> 2]) | 0) + (gI(e4, 15) ^ gI(e4, 13) ^ e4 >>> 10) | 0) + (gI(k4 = E3[N4 >> 2], 25) ^ gI(k4, 14) ^ k4 >>> 3) | 0, E3[B4 + 80 >> 2] = n4, k4 = (h4 = (I7 + k4 | 0) + (gI(w4, 15) ^ gI(w4, 13) ^ w4 >>> 10) | 0) + (gI(t4 = E3[K4 >> 2], 25) ^ gI(t4, 14) ^ t4 >>> 3) | 0, E3[B4 + 84 >> 2] = k4, t4 = ((a4 + t4 | 0) + (gI(s4 = E3[_4 >> 2], 25) ^ gI(s4, 14) ^ s4 >>> 3) | 0) + (gI(n4, 15) ^ gI(n4, 13) ^ n4 >>> 10) | 0, E3[B4 + 88 >> 2] = t4, f4 = ((h4 = E3[p4 >> 2]) + (f4 + (gI(c4, 25) ^ gI(c4, 14) ^ c4 >>> 3) | 0) | 0) + (gI(t4, 15) ^ gI(t4, 13) ^ t4 >>> 10) | 0, E3[B4 + 96 >> 2] = f4, h4 = ((D4 + s4 | 0) + (gI(h4, 25) ^ gI(h4, 14) ^ h4 >>> 3) | 0) + (gI(k4, 15) ^ gI(k4, 13) ^ k4 >>> 10) | 0, E3[B4 + 92 >> 2] = h4, w4 = (w4 + (y4 + (gI(Q4, 25) ^ gI(Q4, 14) ^ Q4 >>> 3) | 0) | 0) + (gI(f4, 15) ^ gI(f4, 13) ^ f4 >>> 10) | 0, E3[B4 + 104 >> 2] = w4, c4 = (e4 + (c4 + (gI(y4, 25) ^ gI(y4, 14) ^ y4 >>> 3) | 0) | 0) + (gI(h4, 15) ^ gI(h4, 13) ^ h4 >>> 10) | 0, E3[B4 + 100 >> 2] = c4, y4 = (k4 + (o4 + (gI(r4, 25) ^ gI(r4, 14) ^ r4 >>> 3) | 0) | 0) + (gI(w4, 15) ^ gI(w4, 13) ^ w4 >>> 10) | 0, E3[B4 + 112 >> 2] = y4, c4 = (n4 + (Q4 + (gI(o4, 25) ^ gI(o4, 14) ^ o4 >>> 3) | 0) | 0) + (gI(c4, 15) ^ gI(c4, 13) ^ c4 >>> 10) | 0, E3[B4 + 108 >> 2] = c4, J4 = B4, Y4 = (h4 + (I7 + (gI(a4, 25) ^ gI(a4, 14) ^ a4 >>> 3) | 0) | 0) + (gI(y4, 15) ^ gI(y4, 13) ^ y4 >>> 10) | 0, E3[J4 + 120 >> 2] = Y4, I7 = (t4 + (r4 + (gI(I7, 25) ^ gI(I7, 14) ^ I7 >>> 3) | 0) | 0) + (gI(c4, 15) ^ gI(c4, 13) ^ c4 >>> 10) | 0, E3[B4 + 116 >> 2] = I7, J4 = B4, Y4 = (f4 + (a4 + (gI(D4, 25) ^ gI(D4, 14) ^ D4 >>> 3) | 0) | 0) + (gI(I7, 15) ^ gI(I7, 13) ^ I7 >>> 10) | 0, E3[J4 + 124 >> 2] = Y4; + E3[A8 >> 2] = D4 + E3[A8 >> 2], E3[A8 + 4 >> 2] = E3[A8 + 4 >> 2] + E3[C4 + 4 >> 2], E3[A8 + 8 >> 2] = E3[A8 + 8 >> 2] + E3[C4 + 8 >> 2], E3[A8 + 12 >> 2] = E3[A8 + 12 >> 2] + E3[C4 + 12 >> 2], E3[A8 + 16 >> 2] = E3[A8 + 16 >> 2] + E3[C4 + 16 >> 2], E3[A8 + 20 >> 2] = E3[A8 + 20 >> 2] + E3[C4 + 20 >> 2], E3[A8 + 24 >> 2] = E3[A8 + 24 >> 2] + E3[C4 + 24 >> 2], E3[A8 + 28 >> 2] = E3[A8 + 28 >> 2] + E3[C4 + 28 >> 2]; + } + function H3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0; + r3 = B4 = r3 - 288 | 0, y4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, f4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, e4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, w4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, t4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, h4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, k4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, n4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, d4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, s4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, F4 = i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24, J4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, b4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, S4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, M4 = i3[g6 + 112 | 0] | i3[g6 + 113 | 0] << 8 | i3[g6 + 114 | 0] << 16 | i3[g6 + 115 | 0] << 24, G4 = i3[g6 + 96 | 0] | i3[g6 + 97 | 0] << 8 | i3[g6 + 98 | 0] << 16 | i3[g6 + 99 | 0] << 24, Y4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, P4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, N4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, K4 = i3[g6 + 116 | 0] | i3[g6 + 117 | 0] << 8 | i3[g6 + 118 | 0] << 16 | i3[g6 + 119 | 0] << 24, o4 = i3[g6 + 100 | 0] | i3[g6 + 101 | 0] << 8 | i3[g6 + 102 | 0] << 16 | i3[g6 + 103 | 0] << 24, U4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, v4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, _4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, p4 = i3[g6 + 120 | 0] | i3[g6 + 121 | 0] << 8 | i3[g6 + 122 | 0] << 16 | i3[g6 + 123 | 0] << 24, c4 = i3[g6 + 104 | 0] | i3[g6 + 105 | 0] << 8 | i3[g6 + 106 | 0] << 16 | i3[g6 + 107 | 0] << 24, H4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, Q4 = (D4 = i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) ^ (a4 = i3[g6 + 108 | 0] | i3[g6 + 109 | 0] << 8 | i3[g6 + 110 | 0] << 16 | i3[g6 + 111 | 0] << 24) & (i3[g6 + 124 | 0] | i3[g6 + 125 | 0] << 8 | i3[g6 + 126 | 0] << 16 | i3[g6 + 127 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24) ^ (i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24), C3[A8 + 28 | 0] = Q4, C3[A8 + 29 | 0] = Q4 >>> 8, C3[A8 + 30 | 0] = Q4 >>> 16, C3[A8 + 31 | 0] = Q4 >>> 24, v4 = U4 ^ c4 & p4 ^ v4 ^ _4, C3[A8 + 24 | 0] = v4, C3[A8 + 25 | 0] = v4 >>> 8, C3[A8 + 26 | 0] = v4 >>> 16, C3[A8 + 27 | 0] = v4 >>> 24, P4 = Y4 ^ o4 & K4 ^ P4 ^ N4, C3[A8 + 20 | 0] = P4, C3[A8 + 21 | 0] = P4 >>> 8, C3[A8 + 22 | 0] = P4 >>> 16, C3[A8 + 23 | 0] = P4 >>> 24, b4 = J4 ^ G4 & M4 ^ b4 ^ S4, C3[A8 + 16 | 0] = b4, C3[A8 + 17 | 0] = b4 >>> 8, C3[A8 + 18 | 0] = b4 >>> 16, C3[A8 + 19 | 0] = b4 >>> 24, d4 = F4 & D4 ^ d4 ^ s4 ^ a4, C3[A8 + 12 | 0] = d4, C3[A8 + 13 | 0] = d4 >>> 8, C3[A8 + 14 | 0] = d4 >>> 16, C3[A8 + 15 | 0] = d4 >>> 24, U4 = U4 & n4 ^ h4 ^ k4 ^ c4, C3[A8 + 8 | 0] = U4, C3[A8 + 9 | 0] = U4 >>> 8, C3[A8 + 10 | 0] = U4 >>> 16, C3[A8 + 11 | 0] = U4 >>> 24, Y4 = Y4 & t4 ^ e4 ^ w4 ^ o4, C3[A8 + 4 | 0] = Y4, C3[A8 + 5 | 0] = Y4 >>> 8, C3[A8 + 6 | 0] = Y4 >>> 16, C3[A8 + 7 | 0] = Y4 >>> 24, J4 = G4 ^ J4 & f4 ^ y4 ^ H4, C3[0 | A8] = J4, C3[A8 + 1 | 0] = J4 >>> 8, C3[A8 + 2 | 0] = J4 >>> 16, C3[A8 + 3 | 0] = J4 >>> 24, A8 = E3[g6 + 124 >> 2], E3[B4 + 280 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 284 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 272 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 276 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 248 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 252 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 240 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 244 >> 2] = A8, A8 = E3[g6 + 124 >> 2], E3[B4 + 232 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 224 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 228 >> 2] = A8, aA(I7 = B4 + 256 | 0, B4 + 240 | 0, B4 + 224 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 120 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 124 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 112 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 116 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 200 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 204 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 192 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 196 >> 2] = A8, aA(I7, B4 + 208 | 0, B4 + 192 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 104 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 108 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 96 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 100 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, G4 = E3[4 + (A8 = g6 - -64 | 0) >> 2], E3[B4 + 176 >> 2] = E3[A8 >> 2], E3[B4 + 180 >> 2] = G4, G4 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = G4, G4 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = G4, aA(I7, B4 + 176 | 0, B4 + 160 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 92 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 84 >> 2] = G4, G4 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = G4, G4 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = G4, G4 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = G4, G4 = E3[A8 + 4 >> 2], E3[B4 + 128 >> 2] = E3[A8 >> 2], E3[B4 + 132 >> 2] = G4, aA(I7, B4 + 144 | 0, B4 + 128 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 76 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[A8 >> 2] = E3[B4 + 256 >> 2], E3[A8 + 4 >> 2] = G4, G4 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = G4, G4 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = G4, G4 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = G4, G4 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = G4, aA(I7, B4 + 112 | 0, B4 + 96 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 60 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 52 >> 2] = G4, G4 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = G4, G4 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = G4, G4 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = G4, G4 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = G4, aA(I7, B4 + 80 | 0, B4 - -64 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 44 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 36 >> 2] = G4, G4 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = G4, G4 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = G4, G4 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = G4, G4 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = G4, aA(I7, B4 + 48 | 0, B4 + 32 | 0), G4 = E3[B4 + 268 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 28 >> 2] = G4, G4 = E3[B4 + 260 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 20 >> 2] = G4, G4 = E3[B4 + 284 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 280 >> 2], E3[B4 + 28 >> 2] = G4, G4 = E3[B4 + 276 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 272 >> 2], E3[B4 + 20 >> 2] = G4, G4 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = G4, G4 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = G4, aA(I7, B4 + 16 | 0, B4), I7 = E3[B4 + 268 >> 2], E3[g6 + 8 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 12 >> 2] = I7, I7 = E3[B4 + 260 >> 2], E3[g6 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 4 >> 2] = I7, E3[g6 + 12 >> 2] = d4 ^ (i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24), E3[g6 + 8 >> 2] = U4 ^ (i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24), E3[g6 + 4 >> 2] = Y4 ^ (i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24), E3[g6 >> 2] = J4 ^ (i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24), E3[A8 >> 2] = b4 ^ (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24), E3[g6 + 68 >> 2] = P4 ^ (i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24), E3[g6 + 72 >> 2] = v4 ^ (i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24), E3[g6 + 76 >> 2] = Q4 ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24), r3 = B4 + 288 | 0; + } + function G3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, v4 = 0; + r3 = B4 = r3 - 288 | 0, S4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, M4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, Q4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, N4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, K4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, o4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, _4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, p4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, c4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, H4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, G4 = i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24, v4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, D4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, J4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, Y4 = i3[g6 + 112 | 0] | i3[g6 + 113 | 0] << 8 | i3[g6 + 114 | 0] << 16 | i3[g6 + 115 | 0] << 24, a4 = i3[g6 + 96 | 0] | i3[g6 + 97 | 0] << 8 | i3[g6 + 98 | 0] << 16 | i3[g6 + 99 | 0] << 24, y4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, f4 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, U4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, d4 = i3[g6 + 116 | 0] | i3[g6 + 117 | 0] << 8 | i3[g6 + 118 | 0] << 16 | i3[g6 + 119 | 0] << 24, e4 = i3[g6 + 100 | 0] | i3[g6 + 101 | 0] << 8 | i3[g6 + 102 | 0] << 16 | i3[g6 + 103 | 0] << 24, w4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, t4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, b4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, P4 = i3[g6 + 120 | 0] | i3[g6 + 121 | 0] << 8 | i3[g6 + 122 | 0] << 16 | i3[g6 + 123 | 0] << 24, h4 = i3[g6 + 104 | 0] | i3[g6 + 105 | 0] << 8 | i3[g6 + 106 | 0] << 16 | i3[g6 + 107 | 0] << 24, k4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = (n4 = i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) ^ (s4 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24) ^ (F4 = i3[g6 + 108 | 0] | i3[g6 + 109 | 0] << 8 | i3[g6 + 110 | 0] << 16 | i3[g6 + 111 | 0] << 24) & (i3[g6 + 124 | 0] | i3[g6 + 125 | 0] << 8 | i3[g6 + 126 | 0] << 16 | i3[g6 + 127 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24), C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = h4 & P4 ^ b4 ^ t4 ^ w4, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = e4 & d4 ^ U4 ^ f4 ^ y4, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = v4 ^ a4 & Y4 ^ J4 ^ D4, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, I7 = G4 & n4 ^ H4 ^ c4 ^ F4, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = w4 & p4 ^ _4 ^ o4 ^ h4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = y4 & K4 ^ N4 ^ Q4 ^ e4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = v4 & M4 ^ S4 ^ k4 ^ a4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, A8 = E3[g6 + 124 >> 2], E3[B4 + 280 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 284 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 272 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 276 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 248 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 252 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 240 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 244 >> 2] = A8, A8 = E3[g6 + 124 >> 2], E3[B4 + 232 >> 2] = E3[g6 + 120 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[g6 + 116 >> 2], E3[B4 + 224 >> 2] = E3[g6 + 112 >> 2], E3[B4 + 228 >> 2] = A8, aA(I7 = B4 + 256 | 0, B4 + 240 | 0, B4 + 224 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 120 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 124 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 112 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 116 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 108 >> 2], E3[B4 + 200 >> 2] = E3[g6 + 104 >> 2], E3[B4 + 204 >> 2] = A8, A8 = E3[g6 + 100 >> 2], E3[B4 + 192 >> 2] = E3[g6 + 96 >> 2], E3[B4 + 196 >> 2] = A8, aA(I7, B4 + 208 | 0, B4 + 192 | 0), A8 = E3[B4 + 268 >> 2], E3[g6 + 104 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 108 >> 2] = A8, A8 = E3[B4 + 260 >> 2], E3[g6 + 96 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 100 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, v4 = E3[4 + (A8 = g6 - -64 | 0) >> 2], E3[B4 + 176 >> 2] = E3[A8 >> 2], E3[B4 + 180 >> 2] = v4, v4 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = v4, v4 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = v4, aA(I7, B4 + 176 | 0, B4 + 160 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 92 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 84 >> 2] = v4, v4 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = v4, v4 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = v4, v4 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = v4, v4 = E3[A8 + 4 >> 2], E3[B4 + 128 >> 2] = E3[A8 >> 2], E3[B4 + 132 >> 2] = v4, aA(I7, B4 + 144 | 0, B4 + 128 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 76 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[A8 >> 2] = E3[B4 + 256 >> 2], E3[A8 + 4 >> 2] = v4, v4 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = v4, v4 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = v4, v4 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = v4, v4 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = v4, aA(I7, B4 + 112 | 0, B4 + 96 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 60 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 52 >> 2] = v4, v4 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = v4, v4 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = v4, v4 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = v4, v4 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = v4, aA(I7, B4 + 80 | 0, B4 - -64 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 44 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 36 >> 2] = v4, v4 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = v4, v4 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = v4, v4 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = v4, v4 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = v4, aA(I7, B4 + 48 | 0, B4 + 32 | 0), v4 = E3[B4 + 268 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 28 >> 2] = v4, v4 = E3[B4 + 260 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 20 >> 2] = v4, v4 = E3[B4 + 284 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 280 >> 2], E3[B4 + 28 >> 2] = v4, v4 = E3[B4 + 276 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 272 >> 2], E3[B4 + 20 >> 2] = v4, v4 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = v4, v4 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = v4, aA(I7, B4 + 16 | 0, B4), I7 = E3[B4 + 268 >> 2], E3[g6 + 8 >> 2] = E3[B4 + 264 >> 2], E3[g6 + 12 >> 2] = I7, I7 = E3[B4 + 260 >> 2], E3[g6 >> 2] = E3[B4 + 256 >> 2], E3[g6 + 4 >> 2] = I7, E3[g6 + 12 >> 2] = (i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24) ^ c4, E3[g6 + 8 >> 2] = (i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24) ^ o4, E3[g6 + 4 >> 2] = (i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24) ^ Q4, E3[g6 >> 2] = (i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24) ^ k4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ D4, E3[g6 + 68 >> 2] = (i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24) ^ f4, E3[g6 + 72 >> 2] = (i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24) ^ t4, E3[g6 + 76 >> 2] = s4 ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24), r3 = B4 + 288 | 0; + } + function J3(A8, I7, g6, B4, Q4) { + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0; + for (r3 = o4 = r3 - 224 | 0, k4 = (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ B4 >>> 29, n4 = (i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24) ^ B4 << 3, e4 = (i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24) ^ g6 >>> 29, t4 = (i3[0 | (c4 = Q4 + 48 | 0)] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24) ^ g6 << 3, D4 = Q4 + 16 | 0, a4 = Q4 + 32 | 0, y4 = Q4 - -64 | 0, f4 = Q4 + 80 | 0; g6 = E3[f4 + 12 >> 2], E3[o4 + 216 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 220 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 208 >> 2] = E3[f4 >> 2], E3[o4 + 212 >> 2] = g6, g6 = E3[y4 + 12 >> 2], E3[o4 + 184 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 188 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 176 >> 2] = E3[y4 >> 2], E3[o4 + 180 >> 2] = g6, g6 = E3[f4 + 12 >> 2], E3[o4 + 168 >> 2] = E3[f4 + 8 >> 2], E3[o4 + 172 >> 2] = g6, g6 = E3[f4 + 4 >> 2], E3[o4 + 160 >> 2] = E3[f4 >> 2], E3[o4 + 164 >> 2] = g6, aA(B4 = o4 + 192 | 0, o4 + 176 | 0, o4 + 160 | 0), g6 = E3[o4 + 204 >> 2], E3[f4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[f4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[f4 >> 2] = E3[o4 + 192 >> 2], E3[f4 + 4 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 152 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 156 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 144 >> 2] = E3[c4 >> 2], E3[o4 + 148 >> 2] = g6, g6 = E3[y4 + 12 >> 2], E3[o4 + 136 >> 2] = E3[y4 + 8 >> 2], E3[o4 + 140 >> 2] = g6, g6 = E3[y4 + 4 >> 2], E3[o4 + 128 >> 2] = E3[y4 >> 2], E3[o4 + 132 >> 2] = g6, aA(B4, o4 + 144 | 0, o4 + 128 | 0), g6 = E3[o4 + 204 >> 2], E3[y4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[y4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[y4 >> 2] = E3[o4 + 192 >> 2], E3[y4 + 4 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 120 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 124 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 112 >> 2] = E3[a4 >> 2], E3[o4 + 116 >> 2] = g6, g6 = E3[c4 + 12 >> 2], E3[o4 + 104 >> 2] = E3[c4 + 8 >> 2], E3[o4 + 108 >> 2] = g6, g6 = E3[c4 + 4 >> 2], E3[o4 + 96 >> 2] = E3[c4 >> 2], E3[o4 + 100 >> 2] = g6, aA(B4, o4 + 112 | 0, o4 + 96 | 0), g6 = E3[o4 + 204 >> 2], E3[c4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[c4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[c4 >> 2] = E3[o4 + 192 >> 2], E3[c4 + 4 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 88 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 92 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 80 >> 2] = E3[D4 >> 2], E3[o4 + 84 >> 2] = g6, g6 = E3[a4 + 12 >> 2], E3[o4 + 72 >> 2] = E3[a4 + 8 >> 2], E3[o4 + 76 >> 2] = g6, g6 = E3[a4 + 4 >> 2], E3[o4 + 64 >> 2] = E3[a4 >> 2], E3[o4 + 68 >> 2] = g6, aA(B4, o4 + 80 | 0, o4 - -64 | 0), g6 = E3[o4 + 204 >> 2], E3[a4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[a4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[a4 >> 2] = E3[o4 + 192 >> 2], E3[a4 + 4 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 56 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 60 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 + 48 >> 2] = E3[Q4 >> 2], E3[o4 + 52 >> 2] = g6, g6 = E3[D4 + 12 >> 2], E3[o4 + 40 >> 2] = E3[D4 + 8 >> 2], E3[o4 + 44 >> 2] = g6, g6 = E3[D4 + 4 >> 2], E3[o4 + 32 >> 2] = E3[D4 >> 2], E3[o4 + 36 >> 2] = g6, aA(B4, o4 + 48 | 0, o4 + 32 | 0), g6 = E3[o4 + 204 >> 2], E3[D4 + 8 >> 2] = E3[o4 + 200 >> 2], E3[D4 + 12 >> 2] = g6, g6 = E3[o4 + 196 >> 2], E3[D4 >> 2] = E3[o4 + 192 >> 2], E3[D4 + 4 >> 2] = g6, g6 = E3[o4 + 220 >> 2], E3[o4 + 24 >> 2] = E3[o4 + 216 >> 2], E3[o4 + 28 >> 2] = g6, g6 = E3[o4 + 212 >> 2], E3[o4 + 16 >> 2] = E3[o4 + 208 >> 2], E3[o4 + 20 >> 2] = g6, g6 = E3[Q4 + 12 >> 2], E3[o4 + 8 >> 2] = E3[Q4 + 8 >> 2], E3[o4 + 12 >> 2] = g6, g6 = E3[Q4 + 4 >> 2], E3[o4 >> 2] = E3[Q4 >> 2], E3[o4 + 4 >> 2] = g6, aA(B4, o4 + 16 | 0, o4), h4 = E3[o4 + 192 >> 2], B4 = E3[o4 + 196 >> 2], g6 = E3[o4 + 200 >> 2], s4 = k4 ^ E3[o4 + 204 >> 2], E3[Q4 + 12 >> 2] = s4, F4 = g6 ^ n4, E3[Q4 + 8 >> 2] = F4, S4 = B4 ^ e4, E3[Q4 + 4 >> 2] = S4, M4 = t4 ^ h4, E3[Q4 >> 2] = M4, 7 != (0 | (w4 = w4 + 1 | 0)); ) ; + A: { + I: { + g: { + if (g6 = I7 - 16 | 0) { + if (16 == (0 | g6)) break g; + break I; + } + N4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, c4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, D4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, a4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, y4 = i3[0 | (I7 = Q4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, f4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, k4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, n4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, e4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, t4 = i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24, h4 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, w4 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, B4 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, g6 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, I7 = i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24, Q4 = s4 ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24) ^ (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24), C3[A8 + 12 | 0] = Q4, C3[A8 + 13 | 0] = Q4 >>> 8, C3[A8 + 14 | 0] = Q4 >>> 16, C3[A8 + 15 | 0] = Q4 >>> 24, I7 = F4 ^ h4 ^ I7 ^ g6 ^ B4 ^ w4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = S4 ^ f4 ^ k4 ^ n4 ^ e4 ^ t4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = M4 ^ N4 ^ c4 ^ D4 ^ a4 ^ y4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24; + break A; + } + t4 = i3[Q4 + 32 | 0] | i3[Q4 + 33 | 0] << 8 | i3[Q4 + 34 | 0] << 16 | i3[Q4 + 35 | 0] << 24, h4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, w4 = i3[Q4 + 36 | 0] | i3[Q4 + 37 | 0] << 8 | i3[Q4 + 38 | 0] << 16 | i3[Q4 + 39 | 0] << 24, B4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, g6 = i3[Q4 + 40 | 0] | i3[Q4 + 41 | 0] << 8 | i3[Q4 + 42 | 0] << 16 | i3[Q4 + 43 | 0] << 24, I7 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, e4 = s4 ^ (i3[Q4 + 44 | 0] | i3[Q4 + 45 | 0] << 8 | i3[Q4 + 46 | 0] << 16 | i3[Q4 + 47 | 0] << 24) ^ (i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24), C3[A8 + 12 | 0] = e4, C3[A8 + 13 | 0] = e4 >>> 8, C3[A8 + 14 | 0] = e4 >>> 16, C3[A8 + 15 | 0] = e4 >>> 24, I7 = F4 ^ I7 ^ g6, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = S4 ^ B4 ^ w4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = M4 ^ t4 ^ h4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, k4 = i3[Q4 + 48 | 0] | i3[Q4 + 49 | 0] << 8 | i3[Q4 + 50 | 0] << 16 | i3[Q4 + 51 | 0] << 24, n4 = i3[Q4 + 80 | 0] | i3[Q4 + 81 | 0] << 8 | i3[Q4 + 82 | 0] << 16 | i3[Q4 + 83 | 0] << 24, e4 = i3[0 | (I7 = Q4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, t4 = i3[Q4 + 52 | 0] | i3[Q4 + 53 | 0] << 8 | i3[Q4 + 54 | 0] << 16 | i3[Q4 + 55 | 0] << 24, h4 = i3[Q4 + 84 | 0] | i3[Q4 + 85 | 0] << 8 | i3[Q4 + 86 | 0] << 16 | i3[Q4 + 87 | 0] << 24, w4 = i3[Q4 + 68 | 0] | i3[Q4 + 69 | 0] << 8 | i3[Q4 + 70 | 0] << 16 | i3[Q4 + 71 | 0] << 24, B4 = i3[Q4 + 56 | 0] | i3[Q4 + 57 | 0] << 8 | i3[Q4 + 58 | 0] << 16 | i3[Q4 + 59 | 0] << 24, g6 = i3[Q4 + 88 | 0] | i3[Q4 + 89 | 0] << 8 | i3[Q4 + 90 | 0] << 16 | i3[Q4 + 91 | 0] << 24, I7 = i3[Q4 + 72 | 0] | i3[Q4 + 73 | 0] << 8 | i3[Q4 + 74 | 0] << 16 | i3[Q4 + 75 | 0] << 24, Q4 = (i3[Q4 + 60 | 0] | i3[Q4 + 61 | 0] << 8 | i3[Q4 + 62 | 0] << 16 | i3[Q4 + 63 | 0] << 24) ^ (i3[Q4 + 92 | 0] | i3[Q4 + 93 | 0] << 8 | i3[Q4 + 94 | 0] << 16 | i3[Q4 + 95 | 0] << 24) ^ (i3[Q4 + 76 | 0] | i3[Q4 + 77 | 0] << 8 | i3[Q4 + 78 | 0] << 16 | i3[Q4 + 79 | 0] << 24), C3[A8 + 28 | 0] = Q4, C3[A8 + 29 | 0] = Q4 >>> 8, C3[A8 + 30 | 0] = Q4 >>> 16, C3[A8 + 31 | 0] = Q4 >>> 24, I7 = B4 ^ I7 ^ g6, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = t4 ^ h4 ^ w4, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = k4 ^ e4 ^ n4, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24; + break A; + } + VA(A8, 0, I7); + } + r3 = o4 + 224 | 0; + } + function Y3(A8, I7, g6, C4) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0; + r3 = B4 = r3 - 320 | 0, E3[B4 + 280 >> 2] = 0, E3[B4 + 284 >> 2] = 0, E3[B4 + 272 >> 2] = 0, E3[B4 + 276 >> 2] = 0, E3[B4 + 264 >> 2] = 0, E3[B4 + 268 >> 2] = 0, E3[B4 + 256 >> 2] = 0, E3[B4 + 260 >> 2] = 0, TA(G4 = B4 + 256 | 0, I7, g6), P4 = i3[C4 + 16 | 0] | i3[C4 + 17 | 0] << 8 | i3[C4 + 18 | 0] << 16 | i3[C4 + 19 | 0] << 24, H4 = i3[C4 + 48 | 0] | i3[C4 + 49 | 0] << 8 | i3[C4 + 50 | 0] << 16 | i3[C4 + 51 | 0] << 24, c4 = i3[C4 + 20 | 0] | i3[C4 + 21 | 0] << 8 | i3[C4 + 22 | 0] << 16 | i3[C4 + 23 | 0] << 24, D4 = i3[C4 + 52 | 0] | i3[C4 + 53 | 0] << 8 | i3[C4 + 54 | 0] << 16 | i3[C4 + 55 | 0] << 24, a4 = i3[C4 + 24 | 0] | i3[C4 + 25 | 0] << 8 | i3[C4 + 26 | 0] << 16 | i3[C4 + 27 | 0] << 24, y4 = i3[C4 + 56 | 0] | i3[C4 + 57 | 0] << 8 | i3[C4 + 58 | 0] << 16 | i3[C4 + 59 | 0] << 24, f4 = i3[C4 + 28 | 0] | i3[C4 + 29 | 0] << 8 | i3[C4 + 30 | 0] << 16 | i3[C4 + 31 | 0] << 24, e4 = i3[C4 + 60 | 0] | i3[C4 + 61 | 0] << 8 | i3[C4 + 62 | 0] << 16 | i3[C4 + 63 | 0] << 24, I7 = i3[C4 + 36 | 0] | i3[C4 + 37 | 0] << 8 | i3[C4 + 38 | 0] << 16 | i3[C4 + 39 | 0] << 24, w4 = i3[C4 + 84 | 0] | i3[C4 + 85 | 0] << 8 | i3[C4 + 86 | 0] << 16 | i3[C4 + 87 | 0] << 24, t4 = i3[C4 + 116 | 0] | i3[C4 + 117 | 0] << 8 | i3[C4 + 118 | 0] << 16 | i3[C4 + 119 | 0] << 24, J4 = i3[C4 + 100 | 0] | i3[C4 + 101 | 0] << 8 | i3[C4 + 102 | 0] << 16 | i3[C4 + 103 | 0] << 24, Y4 = i3[C4 + 44 | 0] | i3[C4 + 45 | 0] << 8 | i3[C4 + 46 | 0] << 16 | i3[C4 + 47 | 0] << 24, h4 = i3[C4 + 92 | 0] | i3[C4 + 93 | 0] << 8 | i3[C4 + 94 | 0] << 16 | i3[C4 + 95 | 0] << 24, k4 = i3[C4 + 124 | 0] | i3[C4 + 125 | 0] << 8 | i3[C4 + 126 | 0] << 16 | i3[C4 + 127 | 0] << 24, U4 = i3[C4 + 108 | 0] | i3[C4 + 109 | 0] << 8 | i3[C4 + 110 | 0] << 16 | i3[C4 + 111 | 0] << 24, d4 = i3[C4 + 32 | 0] | i3[C4 + 33 | 0] << 8 | i3[C4 + 34 | 0] << 16 | i3[C4 + 35 | 0] << 24, n4 = i3[C4 + 80 | 0] | i3[C4 + 81 | 0] << 8 | i3[C4 + 82 | 0] << 16 | i3[C4 + 83 | 0] << 24, s4 = i3[C4 + 112 | 0] | i3[C4 + 113 | 0] << 8 | i3[C4 + 114 | 0] << 16 | i3[C4 + 115 | 0] << 24, b4 = i3[C4 + 96 | 0] | i3[C4 + 97 | 0] << 8 | i3[C4 + 98 | 0] << 16 | i3[C4 + 99 | 0] << 24, F4 = E3[B4 + 272 >> 2], S4 = E3[B4 + 256 >> 2], M4 = E3[B4 + 260 >> 2], N4 = E3[B4 + 264 >> 2], K4 = E3[B4 + 268 >> 2], _4 = E3[B4 + 276 >> 2], p4 = E3[B4 + 284 >> 2], Q4 = i3[C4 + 40 | 0] | i3[C4 + 41 | 0] << 8 | i3[C4 + 42 | 0] << 16 | i3[C4 + 43 | 0] << 24, o4 = i3[C4 + 104 | 0] | i3[C4 + 105 | 0] << 8 | i3[C4 + 106 | 0] << 16 | i3[C4 + 107 | 0] << 24, E3[B4 + 280 >> 2] = Q4 ^ o4 & (i3[C4 + 120 | 0] | i3[C4 + 121 | 0] << 8 | i3[C4 + 122 | 0] << 16 | i3[C4 + 123 | 0] << 24) ^ E3[B4 + 280 >> 2] ^ (i3[C4 + 88 | 0] | i3[C4 + 89 | 0] << 8 | i3[C4 + 90 | 0] << 16 | i3[C4 + 91 | 0] << 24), E3[B4 + 272 >> 2] = d4 ^ b4 & s4 ^ n4 ^ F4, E3[B4 + 284 >> 2] = Y4 ^ U4 & k4 ^ h4 ^ p4, E3[B4 + 276 >> 2] = I7 ^ J4 & t4 ^ w4 ^ _4, E3[B4 + 268 >> 2] = U4 ^ Y4 & e4 ^ f4 ^ K4, E3[B4 + 264 >> 2] = y4 & Q4 ^ a4 ^ N4 ^ o4, E3[B4 + 260 >> 2] = J4 ^ I7 & D4 ^ c4 ^ M4, E3[B4 + 256 >> 2] = b4 ^ H4 & d4 ^ P4 ^ S4, VA(g6 + G4 | 0, 0, 32 - g6 | 0), TA(A8, G4, g6), g6 = E3[B4 + 280 >> 2], G4 = E3[B4 + 272 >> 2], J4 = E3[B4 + 284 >> 2], Y4 = E3[B4 + 276 >> 2], U4 = E3[B4 + 256 >> 2], d4 = E3[B4 + 260 >> 2], b4 = E3[B4 + 264 >> 2], P4 = E3[B4 + 268 >> 2], A8 = E3[C4 + 124 >> 2], E3[B4 + 312 >> 2] = E3[C4 + 120 >> 2], E3[B4 + 316 >> 2] = A8, A8 = E3[C4 + 116 >> 2], E3[B4 + 304 >> 2] = E3[C4 + 112 >> 2], E3[B4 + 308 >> 2] = A8, A8 = E3[C4 + 108 >> 2], E3[B4 + 248 >> 2] = E3[C4 + 104 >> 2], E3[B4 + 252 >> 2] = A8, A8 = E3[C4 + 100 >> 2], E3[B4 + 240 >> 2] = E3[C4 + 96 >> 2], E3[B4 + 244 >> 2] = A8, A8 = E3[C4 + 124 >> 2], E3[B4 + 232 >> 2] = E3[C4 + 120 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[C4 + 116 >> 2], E3[B4 + 224 >> 2] = E3[C4 + 112 >> 2], E3[B4 + 228 >> 2] = A8, aA(I7 = B4 + 288 | 0, B4 + 240 | 0, B4 + 224 | 0), A8 = E3[B4 + 300 >> 2], E3[C4 + 120 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 124 >> 2] = A8, A8 = E3[B4 + 292 >> 2], E3[C4 + 112 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 116 >> 2] = A8, A8 = E3[C4 + 92 >> 2], E3[B4 + 216 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[C4 + 84 >> 2], E3[B4 + 208 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[C4 + 108 >> 2], E3[B4 + 200 >> 2] = E3[C4 + 104 >> 2], E3[B4 + 204 >> 2] = A8, A8 = E3[C4 + 100 >> 2], E3[B4 + 192 >> 2] = E3[C4 + 96 >> 2], E3[B4 + 196 >> 2] = A8, aA(I7, B4 + 208 | 0, B4 + 192 | 0), A8 = E3[B4 + 300 >> 2], E3[C4 + 104 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 108 >> 2] = A8, A8 = E3[B4 + 292 >> 2], E3[C4 + 96 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 100 >> 2] = A8, A8 = E3[C4 + 76 >> 2], E3[B4 + 184 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 188 >> 2] = A8, H4 = E3[4 + (A8 = C4 - -64 | 0) >> 2], E3[B4 + 176 >> 2] = E3[A8 >> 2], E3[B4 + 180 >> 2] = H4, H4 = E3[C4 + 92 >> 2], E3[B4 + 168 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 172 >> 2] = H4, H4 = E3[C4 + 84 >> 2], E3[B4 + 160 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 164 >> 2] = H4, aA(I7, B4 + 176 | 0, B4 + 160 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 88 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 92 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 80 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 84 >> 2] = H4, H4 = E3[C4 + 60 >> 2], E3[B4 + 152 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 156 >> 2] = H4, H4 = E3[C4 + 52 >> 2], E3[B4 + 144 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 148 >> 2] = H4, H4 = E3[C4 + 76 >> 2], E3[B4 + 136 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 140 >> 2] = H4, H4 = E3[A8 + 4 >> 2], E3[B4 + 128 >> 2] = E3[A8 >> 2], E3[B4 + 132 >> 2] = H4, aA(I7, B4 + 144 | 0, B4 + 128 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 72 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 76 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[A8 >> 2] = E3[B4 + 288 >> 2], E3[A8 + 4 >> 2] = H4, H4 = E3[C4 + 44 >> 2], E3[B4 + 120 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 124 >> 2] = H4, H4 = E3[C4 + 36 >> 2], E3[B4 + 112 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 116 >> 2] = H4, H4 = E3[C4 + 60 >> 2], E3[B4 + 104 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 108 >> 2] = H4, H4 = E3[C4 + 52 >> 2], E3[B4 + 96 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 100 >> 2] = H4, aA(I7, B4 + 112 | 0, B4 + 96 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 56 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 60 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 48 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 52 >> 2] = H4, H4 = E3[C4 + 28 >> 2], E3[B4 + 88 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 92 >> 2] = H4, H4 = E3[C4 + 20 >> 2], E3[B4 + 80 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 84 >> 2] = H4, H4 = E3[C4 + 44 >> 2], E3[B4 + 72 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 76 >> 2] = H4, H4 = E3[C4 + 36 >> 2], E3[B4 + 64 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 68 >> 2] = H4, aA(I7, B4 + 80 | 0, B4 - -64 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 40 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 44 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 32 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 36 >> 2] = H4, H4 = E3[C4 + 12 >> 2], E3[B4 + 56 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 60 >> 2] = H4, H4 = E3[C4 + 4 >> 2], E3[B4 + 48 >> 2] = E3[C4 >> 2], E3[B4 + 52 >> 2] = H4, H4 = E3[C4 + 28 >> 2], E3[B4 + 40 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 44 >> 2] = H4, H4 = E3[C4 + 20 >> 2], E3[B4 + 32 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 36 >> 2] = H4, aA(I7, B4 + 48 | 0, B4 + 32 | 0), H4 = E3[B4 + 300 >> 2], E3[C4 + 24 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 28 >> 2] = H4, H4 = E3[B4 + 292 >> 2], E3[C4 + 16 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 20 >> 2] = H4, H4 = E3[B4 + 316 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 312 >> 2], E3[B4 + 28 >> 2] = H4, H4 = E3[B4 + 308 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 304 >> 2], E3[B4 + 20 >> 2] = H4, H4 = E3[C4 + 12 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 12 >> 2] = H4, H4 = E3[C4 + 4 >> 2], E3[B4 >> 2] = E3[C4 >> 2], E3[B4 + 4 >> 2] = H4, aA(I7, B4 + 16 | 0, B4), I7 = E3[B4 + 300 >> 2], E3[C4 + 8 >> 2] = E3[B4 + 296 >> 2], E3[C4 + 12 >> 2] = I7, I7 = E3[B4 + 292 >> 2], E3[C4 >> 2] = E3[B4 + 288 >> 2], E3[C4 + 4 >> 2] = I7, E3[C4 + 12 >> 2] = P4 ^ (i3[C4 + 12 | 0] | i3[C4 + 13 | 0] << 8 | i3[C4 + 14 | 0] << 16 | i3[C4 + 15 | 0] << 24), E3[C4 + 8 >> 2] = b4 ^ (i3[C4 + 8 | 0] | i3[C4 + 9 | 0] << 8 | i3[C4 + 10 | 0] << 16 | i3[C4 + 11 | 0] << 24), E3[C4 + 4 >> 2] = d4 ^ (i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24), E3[C4 >> 2] = U4 ^ (i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24), E3[A8 >> 2] = G4 ^ (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24), E3[C4 + 68 >> 2] = Y4 ^ (i3[C4 + 68 | 0] | i3[C4 + 69 | 0] << 8 | i3[C4 + 70 | 0] << 16 | i3[C4 + 71 | 0] << 24), E3[C4 + 72 >> 2] = g6 ^ (i3[C4 + 72 | 0] | i3[C4 + 73 | 0] << 8 | i3[C4 + 74 | 0] << 16 | i3[C4 + 75 | 0] << 24), E3[C4 + 76 >> 2] = J4 ^ (i3[C4 + 76 | 0] | i3[C4 + 77 | 0] << 8 | i3[C4 + 78 | 0] << 16 | i3[C4 + 79 | 0] << 24), r3 = B4 + 320 | 0; + } + function U3(A8, I7) { + var g6, C4, B4, Q4, i4, o4, D4, a4, y4, f4, e4, w4, r4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4, p4, H4, G4, J4, Y4, U4, d4, b4, P4, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0; + v4 = PA(C4 = (n4 = E3[I7 + 12 >> 2]) << 1, o4 = C4 >> 31, n4, N4 = n4 >> 31), L4 = t3, R4 = (z2 = PA(u4 = E3[I7 + 16 >> 2], D4 = u4 >> 31, a4 = (x4 = E3[I7 + 8 >> 2]) << 1, w4 = a4 >> 31)) + v4 | 0, v4 = t3 + L4 | 0, v4 = R4 >>> 0 < z2 >>> 0 ? v4 + 1 | 0 : v4, L4 = (j2 = PA(T2 = (y4 = E3[I7 + 20 >> 2]) << 1, r4 = T2 >> 31, z2 = (m4 = E3[I7 + 4 >> 2]) << 1, B4 = z2 >> 31)) + R4 | 0, R4 = t3 + v4 | 0, R4 = L4 >>> 0 < j2 >>> 0 ? R4 + 1 | 0 : R4, q4 = PA(g6 = E3[I7 + 24 >> 2], f4 = g6 >> 31, j2 = (W2 = E3[I7 >> 2]) << 1, Q4 = j2 >> 31), v4 = t3 + R4 | 0, v4 = (L4 = q4 + L4 | 0) >>> 0 < q4 >>> 0 ? v4 + 1 | 0 : v4, R4 = L4, h4 = E3[I7 + 32 >> 2], L4 = PA(X2 = c3(h4, 19), e4 = X2 >> 31, h4, F4 = h4 >> 31), v4 = t3 + v4 | 0, v4 = (R4 = R4 + L4 | 0) >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, G4 = E3[I7 + 36 >> 2], L4 = PA(q4 = c3(G4, 38), i4 = q4 >> 31, S4 = (k4 = E3[I7 + 28 >> 2]) << 1, K4 = S4 >> 31), I7 = t3 + v4 | 0, Z2 = R4 = L4 + R4 | 0, L4 = R4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(z2, B4, u4, D4), v4 = t3, R4 = PA(a4, w4, n4, N4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, l3 = PA(y4, M4 = y4 >> 31, j2, Q4), R4 = t3 + v4 | 0, R4 = (I7 = l3 + I7 | 0) >>> 0 < l3 >>> 0 ? R4 + 1 | 0 : R4, l3 = PA(X2, e4, S4, K4), v4 = t3 + R4 | 0, v4 = (I7 = l3 + I7 | 0) >>> 0 < l3 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(q4, i4, g6, f4), v4 = t3 + v4 | 0, CA2 = I7 = R4 + I7 | 0, O2 = I7 >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, v4 = PA(z2, B4, C4, o4), R4 = t3, _4 = I7 = x4, x4 = PA(I7, V2 = I7 >> 31, I7, V2), I7 = t3 + R4 | 0, I7 = (v4 = x4 + v4 | 0) >>> 0 < x4 >>> 0 ? I7 + 1 | 0 : I7, R4 = (x4 = PA(j2, Q4, u4, D4)) + v4 | 0, v4 = t3 + I7 | 0, v4 = R4 >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, I7 = (x4 = PA(l3 = c3(k4, 38), s4 = l3 >> 31, k4, p4 = k4 >> 31)) + R4 | 0, R4 = t3 + v4 | 0, R4 = I7 >>> 0 < x4 >>> 0 ? R4 + 1 | 0 : R4, I7 = (v4 = I7) + (x4 = PA(X2, e4, I7 = g6 << 1, I7 >> 31)) | 0, v4 = t3 + R4 | 0, v4 = I7 >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, R4 = I7, I7 = PA(q4, i4, T2, r4), v4 = t3 + v4 | 0, J4 = R4 = R4 + I7 | 0, Y4 = v4 = I7 >>> 0 > R4 >>> 0 ? v4 + 1 | 0 : v4, I7 = v4, U4 = R4 = R4 + 33554432 | 0, d4 = I7 = R4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, v4 = (v4 = I7 >> 26) + O2 | 0, CA2 = I7 = (R4 = (67108863 & I7) << 6 | R4 >>> 26) + CA2 | 0, v4 = I7 >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, b4 = I7 = I7 + 16777216 | 0, v4 = (v4 = (R4 = I7 >>> 0 < 16777216 ? v4 + 1 | 0 : v4) >> 25) + L4 | 0, I7 = (I7 = (33554431 & R4) << 7 | I7 >>> 25) >>> 0 > (R4 = I7 + Z2 | 0) >>> 0 ? v4 + 1 | 0 : v4, Z2 = v4 = R4 + 33554432 | 0, x4 = I7 = v4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[A8 + 24 >> 2] = R4 - (-67108864 & v4), I7 = PA(j2, Q4, _4, V2), v4 = t3, L4 = PA(z2, B4, m4, $2 = m4 >> 31), R4 = t3 + v4 | 0, R4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? R4 + 1 | 0 : R4, O2 = PA(L4 = c3(g6, 19), gA2 = L4 >> 31, g6, f4), v4 = t3 + R4 | 0, v4 = (I7 = O2 + I7 | 0) >>> 0 < O2 >>> 0 ? v4 + 1 | 0 : v4, R4 = (O2 = PA(T2, r4, l3, s4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < O2 >>> 0 ? I7 + 1 | 0 : I7, AA2 = PA(X2, e4, O2 = u4 << 1, H4 = O2 >> 31), v4 = t3 + I7 | 0, v4 = (R4 = AA2 + R4 | 0) >>> 0 < AA2 >>> 0 ? v4 + 1 | 0 : v4, I7 = R4, R4 = PA(q4, i4, C4, o4), v4 = t3 + v4 | 0, IA2 = I7 = I7 + R4 | 0, AA2 = I7 >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, I7 = PA(T2, r4, L4, gA2), v4 = t3, m4 = PA(j2, Q4, m4, $2), R4 = t3 + v4 | 0, R4 = (I7 = m4 + I7 | 0) >>> 0 < m4 >>> 0 ? R4 + 1 | 0 : R4, m4 = PA(u4, D4, l3, s4), v4 = t3 + R4 | 0, v4 = (I7 = m4 + I7 | 0) >>> 0 < m4 >>> 0 ? v4 + 1 | 0 : v4, R4 = (m4 = PA(X2, e4, C4, o4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < m4 >>> 0 ? I7 + 1 | 0 : I7, m4 = PA(q4, i4, _4, V2), v4 = t3 + I7 | 0, BA2 = R4 = m4 + R4 | 0, $2 = R4 >>> 0 < m4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(I7 = c3(y4, 38), I7 >> 31, y4, M4), m4 = t3, I7 = W2, W2 = R4, R4 = PA(I7, v4 = I7 >> 31, I7, v4), v4 = t3 + m4 | 0, v4 = (I7 = W2 + R4 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, L4 = PA(L4, gA2, O2, H4), R4 = t3 + v4 | 0, R4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? R4 + 1 | 0 : R4, L4 = PA(C4, o4, l3, s4), v4 = t3 + R4 | 0, v4 = (I7 = L4 + I7 | 0) >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, R4 = (L4 = PA(X2, e4, a4, w4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, L4 = PA(z2, B4, q4, i4), v4 = t3 + I7 | 0, m4 = R4 = L4 + R4 | 0, W2 = v4 = R4 >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, gA2 = R4 = R4 + 33554432 | 0, P4 = v4 = R4 >>> 0 < 33554432 ? v4 + 1 | 0 : v4, I7 = v4 >> 26, v4 = (67108863 & v4) << 6 | R4 >>> 26, R4 = I7 + $2 | 0, $2 = L4 = v4 + BA2 | 0, v4 = v4 >>> 0 > L4 >>> 0 ? R4 + 1 | 0 : R4, BA2 = R4 = L4 + 16777216 | 0, L4 = (33554431 & (v4 = R4 >>> 0 < 16777216 ? v4 + 1 | 0 : v4)) << 7 | R4 >>> 25, v4 = (v4 >> 25) + AA2 | 0, v4 = (R4 = L4 + IA2 | 0) >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, AA2 = I7 = R4 + 33554432 | 0, L4 = v4 = I7 >>> 0 < 33554432 ? v4 + 1 | 0 : v4, E3[A8 + 8 >> 2] = R4 - (-67108864 & I7), I7 = PA(a4, w4, y4, M4), v4 = t3, R4 = PA(u4, D4, C4, o4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(z2, B4, g6, f4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(j2, Q4, k4, p4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, IA2 = (R4 = PA(q4, i4, h4, F4)) + I7 | 0, I7 = t3 + v4 | 0, R4 = (v4 = x4 >> 26) + (R4 = R4 >>> 0 > IA2 >>> 0 ? I7 + 1 | 0 : I7) | 0, Z2 = I7 = (x4 = (67108863 & x4) << 6 | Z2 >>> 26) + IA2 | 0, v4 = I7 >>> 0 < x4 >>> 0 ? R4 + 1 | 0 : R4, IA2 = I7 = I7 + 16777216 | 0, x4 = v4 = I7 >>> 0 < 16777216 ? v4 + 1 | 0 : v4, E3[A8 + 28 >> 2] = Z2 - (-33554432 & I7), I7 = PA(j2, Q4, n4, N4), R4 = t3, v4 = (V2 = PA(z2, B4, _4, V2)) + I7 | 0, I7 = t3 + R4 | 0, I7 = v4 >>> 0 < V2 >>> 0 ? I7 + 1 | 0 : I7, v4 = (l3 = PA(g6, f4, l3, s4)) + v4 | 0, R4 = t3 + I7 | 0, I7 = (X2 = PA(X2, e4, T2, r4)) + v4 | 0, v4 = t3 + (v4 >>> 0 < l3 >>> 0 ? R4 + 1 | 0 : R4) | 0, v4 = I7 >>> 0 < X2 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(q4, i4, u4, D4), v4 = t3 + v4 | 0, v4 = (v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4) + (R4 = L4 >> 26) | 0, I7 = (R4 = L4 = (Z2 = I7) + (I7 = (67108863 & L4) << 6 | AA2 >>> 26) | 0) >>> 0 < I7 >>> 0 ? v4 + 1 | 0 : v4, X2 = v4 = R4 + 16777216 | 0, L4 = I7 = v4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 12 >> 2] = R4 - (-33554432 & v4), I7 = PA(g6, f4, a4, w4), v4 = t3, R4 = PA(u4, D4, u4, D4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = PA(C4, o4, T2, r4), v4 = t3 + v4 | 0, v4 = (I7 = R4 + I7 | 0) >>> 0 < R4 >>> 0 ? v4 + 1 | 0 : v4, R4 = (u4 = PA(z2, B4, S4, K4)) + I7 | 0, I7 = t3 + v4 | 0, I7 = R4 >>> 0 < u4 >>> 0 ? I7 + 1 | 0 : I7, v4 = (u4 = PA(j2, Q4, h4, F4)) + R4 | 0, R4 = t3 + I7 | 0, R4 = v4 >>> 0 < u4 >>> 0 ? R4 + 1 | 0 : R4, I7 = (u4 = PA(I7 = q4, i4, q4 = G4, T2 = q4 >> 31)) + v4 | 0, v4 = t3 + R4 | 0, v4 = I7 >>> 0 < u4 >>> 0 ? v4 + 1 | 0 : v4, R4 = I7, v4 = (I7 = x4 >> 25) + v4 | 0, v4 = (R4 = R4 + (x4 = (33554431 & x4) << 7 | IA2 >>> 25) | 0) >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, u4 = I7 = R4 + 33554432 | 0, x4 = v4 = I7 >>> 0 < 33554432 ? v4 + 1 | 0 : v4, E3[A8 + 32 >> 2] = R4 - (-67108864 & I7), v4 = L4 >> 25, R4 = (L4 = (33554431 & L4) << 7 | X2 >>> 25) + (J4 - (I7 = -67108864 & U4) | 0) | 0, I7 = v4 + (Y4 - ((I7 >>> 0 > J4 >>> 0) + d4 | 0) | 0) | 0, I7 = R4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, L4 = R4, I7 = ((67108863 & (v4 = (R4 = R4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | R4 >>> 26) + (l3 = CA2 - (-33554432 & b4) | 0) | 0, E3[A8 + 20 >> 2] = I7, E3[A8 + 16 >> 2] = L4 - (-67108864 & R4), I7 = PA(C4, o4, g6, f4), R4 = t3, v4 = (L4 = PA(y4, M4, O2, H4)) + I7 | 0, I7 = t3 + R4 | 0, I7 = v4 >>> 0 < L4 >>> 0 ? I7 + 1 | 0 : I7, R4 = (L4 = PA(a4, w4, k4, p4)) + v4 | 0, v4 = t3 + I7 | 0, v4 = R4 >>> 0 < L4 >>> 0 ? v4 + 1 | 0 : v4, I7 = (L4 = PA(z2, B4, h4, F4)) + R4 | 0, R4 = t3 + v4 | 0, R4 = I7 >>> 0 < L4 >>> 0 ? R4 + 1 | 0 : R4, L4 = (v4 = I7) + (I7 = PA(j2, Q4, q4, T2)) | 0, v4 = t3 + R4 | 0, v4 = (I7 = I7 >>> 0 > L4 >>> 0 ? v4 + 1 | 0 : v4) + (v4 = x4 >> 26) | 0, I7 = (R4 = (x4 = (67108863 & x4) << 6 | u4 >>> 26) + L4 | 0) >>> 0 < x4 >>> 0 ? v4 + 1 | 0 : v4, I7 = (v4 = R4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 36 >> 2] = R4 - (-33554432 & v4), x4 = $2 - (-33554432 & BA2) | 0, L4 = m4 - (R4 = -67108864 & gA2) | 0, z2 = W2 - ((R4 >>> 0 > m4 >>> 0) + P4 | 0) | 0, I7 = PA((33554431 & I7) << 7 | v4 >>> 25, I7 >> 25, 19, 0), v4 = t3 + z2 | 0, I7 = I7 >>> 0 > (R4 = I7 + L4 | 0) >>> 0 ? v4 + 1 | 0 : v4, I7 = ((67108863 & (I7 = (v4 = R4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | v4 >>> 26) + x4 | 0, E3[A8 + 4 >> 2] = I7, E3[A8 >> 2] = R4 - (-67108864 & v4); + } + function d3(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, t4 = 0; + r3 = g6 = r3 - 416 | 0, C4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, B4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, Q4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, o4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, t4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, c4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, D4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, a4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, A8 = E3[I7 + 92 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 412 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 400 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 404 >> 2] = A8, A8 = E3[I7 + 76 >> 2], E3[g6 + 376 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 380 >> 2] = A8, e4 = E3[4 + (A8 = w4 = I7 - -64 | 0) >> 2], E3[g6 + 368 >> 2] = E3[A8 >> 2], E3[g6 + 372 >> 2] = e4, A8 = E3[I7 + 92 >> 2], E3[g6 + 360 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 364 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 352 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 356 >> 2] = A8, aA(A8 = g6 + 384 | 0, g6 + 368 | 0, g6 + 352 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 92 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 84 >> 2] = e4, e4 = E3[I7 + 60 >> 2], E3[g6 + 344 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 348 >> 2] = e4, e4 = E3[I7 + 52 >> 2], E3[g6 + 336 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 340 >> 2] = e4, e4 = E3[I7 + 76 >> 2], E3[g6 + 328 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 332 >> 2] = e4, e4 = E3[w4 + 4 >> 2], E3[g6 + 320 >> 2] = E3[w4 >> 2], E3[g6 + 324 >> 2] = e4, aA(A8, g6 + 336 | 0, g6 + 320 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 76 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[w4 >> 2] = E3[g6 + 384 >> 2], E3[w4 + 4 >> 2] = e4, e4 = E3[I7 + 44 >> 2], E3[g6 + 312 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 316 >> 2] = e4, e4 = E3[I7 + 36 >> 2], E3[g6 + 304 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 308 >> 2] = e4, e4 = E3[I7 + 60 >> 2], E3[g6 + 296 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 300 >> 2] = e4, e4 = E3[I7 + 52 >> 2], E3[g6 + 288 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 292 >> 2] = e4, aA(A8, g6 + 304 | 0, g6 + 288 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 60 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 52 >> 2] = e4, e4 = E3[I7 + 28 >> 2], E3[g6 + 280 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 284 >> 2] = e4, e4 = E3[I7 + 20 >> 2], E3[g6 + 272 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 276 >> 2] = e4, e4 = E3[I7 + 44 >> 2], E3[g6 + 264 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 268 >> 2] = e4, e4 = E3[I7 + 36 >> 2], E3[g6 + 256 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 260 >> 2] = e4, aA(A8, g6 + 272 | 0, g6 + 256 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 44 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 36 >> 2] = e4, e4 = E3[I7 + 12 >> 2], E3[g6 + 248 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 252 >> 2] = e4, e4 = E3[I7 + 4 >> 2], E3[g6 + 240 >> 2] = E3[I7 >> 2], E3[g6 + 244 >> 2] = e4, e4 = E3[I7 + 28 >> 2], E3[g6 + 232 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 236 >> 2] = e4, e4 = E3[I7 + 20 >> 2], E3[g6 + 224 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 228 >> 2] = e4, aA(A8, g6 + 240 | 0, g6 + 224 | 0), e4 = E3[g6 + 396 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 28 >> 2] = e4, e4 = E3[g6 + 388 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 20 >> 2] = e4, e4 = E3[g6 + 412 >> 2], E3[g6 + 216 >> 2] = E3[g6 + 408 >> 2], E3[g6 + 220 >> 2] = e4, e4 = E3[g6 + 404 >> 2], E3[g6 + 208 >> 2] = E3[g6 + 400 >> 2], E3[g6 + 212 >> 2] = e4, e4 = E3[I7 + 12 >> 2], E3[g6 + 200 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 204 >> 2] = e4, e4 = E3[I7 + 4 >> 2], E3[g6 + 192 >> 2] = E3[I7 >> 2], E3[g6 + 196 >> 2] = e4, aA(A8, g6 + 208 | 0, g6 + 192 | 0), e4 = E3[g6 + 384 >> 2], y4 = E3[g6 + 388 >> 2], f4 = E3[g6 + 392 >> 2], E3[I7 + 12 >> 2] = E3[g6 + 396 >> 2] ^ D4, E3[I7 + 8 >> 2] = c4 ^ f4, E3[I7 + 4 >> 2] = t4 ^ y4, E3[I7 >> 2] = e4 ^ a4, t4 = E3[I7 + 92 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 412 >> 2] = t4, t4 = E3[I7 + 84 >> 2], E3[g6 + 400 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 404 >> 2] = t4, t4 = E3[I7 + 76 >> 2], E3[g6 + 184 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 188 >> 2] = t4, t4 = E3[w4 + 4 >> 2], E3[g6 + 176 >> 2] = E3[w4 >> 2], E3[g6 + 180 >> 2] = t4, t4 = E3[I7 + 92 >> 2], E3[g6 + 168 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 172 >> 2] = t4, t4 = E3[I7 + 84 >> 2], E3[g6 + 160 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 164 >> 2] = t4, aA(A8, g6 + 176 | 0, g6 + 160 | 0), t4 = E3[g6 + 396 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 92 >> 2] = t4, t4 = E3[g6 + 388 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 84 >> 2] = t4, t4 = E3[I7 + 60 >> 2], E3[g6 + 152 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 156 >> 2] = t4, t4 = E3[I7 + 52 >> 2], E3[g6 + 144 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 148 >> 2] = t4, t4 = E3[I7 + 76 >> 2], E3[g6 + 136 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 140 >> 2] = t4, t4 = E3[w4 + 4 >> 2], E3[g6 + 128 >> 2] = E3[w4 >> 2], E3[g6 + 132 >> 2] = t4, aA(A8, g6 + 144 | 0, g6 + 128 | 0), t4 = E3[g6 + 396 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 76 >> 2] = t4, t4 = E3[g6 + 388 >> 2], E3[w4 >> 2] = E3[g6 + 384 >> 2], E3[w4 + 4 >> 2] = t4, w4 = E3[I7 + 44 >> 2], E3[g6 + 120 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 124 >> 2] = w4, w4 = E3[I7 + 36 >> 2], E3[g6 + 112 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 116 >> 2] = w4, w4 = E3[I7 + 60 >> 2], E3[g6 + 104 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 108 >> 2] = w4, w4 = E3[I7 + 52 >> 2], E3[g6 + 96 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 100 >> 2] = w4, aA(A8, g6 + 112 | 0, g6 + 96 | 0), w4 = E3[g6 + 396 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 60 >> 2] = w4, w4 = E3[g6 + 388 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 52 >> 2] = w4, w4 = E3[I7 + 28 >> 2], E3[g6 + 88 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 92 >> 2] = w4, w4 = E3[I7 + 20 >> 2], E3[g6 + 80 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 84 >> 2] = w4, w4 = E3[I7 + 44 >> 2], E3[g6 + 72 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 76 >> 2] = w4, w4 = E3[I7 + 36 >> 2], E3[g6 + 64 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 68 >> 2] = w4, aA(A8, g6 + 80 | 0, g6 - -64 | 0), w4 = E3[g6 + 396 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 44 >> 2] = w4, w4 = E3[g6 + 388 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 36 >> 2] = w4, w4 = E3[I7 + 12 >> 2], E3[g6 + 56 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 60 >> 2] = w4, w4 = E3[I7 + 4 >> 2], E3[g6 + 48 >> 2] = E3[I7 >> 2], E3[g6 + 52 >> 2] = w4, w4 = E3[I7 + 28 >> 2], E3[g6 + 40 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 44 >> 2] = w4, w4 = E3[I7 + 20 >> 2], E3[g6 + 32 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 36 >> 2] = w4, aA(A8, g6 + 48 | 0, g6 + 32 | 0), w4 = E3[g6 + 396 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 392 >> 2], E3[I7 + 28 >> 2] = w4, w4 = E3[g6 + 388 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 384 >> 2], E3[I7 + 20 >> 2] = w4, w4 = E3[g6 + 412 >> 2], E3[g6 + 24 >> 2] = E3[g6 + 408 >> 2], E3[g6 + 28 >> 2] = w4, w4 = E3[g6 + 404 >> 2], E3[g6 + 16 >> 2] = E3[g6 + 400 >> 2], E3[g6 + 20 >> 2] = w4, w4 = E3[I7 + 12 >> 2], E3[g6 + 8 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 12 >> 2] = w4, w4 = E3[I7 + 4 >> 2], E3[g6 >> 2] = E3[I7 >> 2], E3[g6 + 4 >> 2] = w4, aA(A8, g6 + 16 | 0, g6), A8 = E3[g6 + 384 >> 2], w4 = E3[g6 + 388 >> 2], t4 = E3[g6 + 392 >> 2], E3[I7 + 12 >> 2] = E3[g6 + 396 >> 2] ^ o4, E3[I7 + 8 >> 2] = t4 ^ Q4, E3[I7 + 4 >> 2] = w4 ^ B4, E3[I7 >> 2] = A8 ^ C4, r3 = g6 + 416 | 0; + } + function b3(A8, I7, g6) { + var C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4 = 0, s4 = 0, F4 = 0; + for (r3 = C4 = r3 - 288 | 0, w4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, t4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, h4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, a4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, y4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, f4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, k4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = g6 + 112 | 0, A8 = 33620224 ^ (e4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24), E3[I7 >> 2] = A8, E3[(c4 = g6 + 96 | 0) >> 2] = 1427652059 ^ e4, E3[(D4 = g6 + 80 | 0) >> 2] = A8, s4 = e4 ^ k4, E3[(A8 = g6 - -64 | 0) >> 2] = s4, E3[g6 + 56 >> 2] = 1110511904, E3[g6 + 60 >> 2] = -584534669, E3[(B4 = g6 + 48 | 0) >> 2] = 1427652059, E3[B4 + 4 >> 2] = -248528275, E3[g6 + 40 >> 2] = 1496785429, E3[g6 + 44 >> 2] = 1652156816, E3[(Q4 = g6 + 32 | 0) >> 2] = 33620224, E3[Q4 + 4 >> 2] = 218629379, E3[g6 + 24 >> 2] = 1110511904, E3[g6 + 28 >> 2] = -584534669, E3[(o4 = g6 + 16 | 0) >> 2] = 1427652059, E3[o4 + 4 >> 2] = -248528275, E3[g6 >> 2] = s4, s4 = 1652156816 ^ f4, E3[g6 + 124 >> 2] = s4, F4 = 1496785429 ^ y4, E3[g6 + 120 >> 2] = F4, n4 = 218629379 ^ a4, E3[g6 + 116 >> 2] = n4, E3[g6 + 108 >> 2] = -584534669 ^ f4, E3[g6 + 104 >> 2] = 1110511904 ^ y4, E3[g6 + 100 >> 2] = -248528275 ^ a4, E3[g6 + 92 >> 2] = s4, E3[g6 + 88 >> 2] = F4, E3[g6 + 84 >> 2] = n4, s4 = f4 ^ h4, E3[g6 + 76 >> 2] = s4, F4 = y4 ^ t4, E3[g6 + 72 >> 2] = F4, n4 = a4 ^ w4, E3[g6 + 68 >> 2] = n4, E3[g6 + 12 >> 2] = s4, E3[g6 + 8 >> 2] = F4, E3[g6 + 4 >> 2] = n4, F4 = 0; s4 = E3[I7 + 12 >> 2], E3[C4 + 280 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 284 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[C4 + 272 >> 2] = E3[I7 >> 2], E3[C4 + 276 >> 2] = s4, s4 = E3[c4 + 12 >> 2], E3[C4 + 248 >> 2] = E3[c4 + 8 >> 2], E3[C4 + 252 >> 2] = s4, s4 = E3[c4 + 4 >> 2], E3[C4 + 240 >> 2] = E3[c4 >> 2], E3[C4 + 244 >> 2] = s4, s4 = E3[I7 + 12 >> 2], E3[C4 + 232 >> 2] = E3[I7 + 8 >> 2], E3[C4 + 236 >> 2] = s4, s4 = E3[I7 + 4 >> 2], E3[C4 + 224 >> 2] = E3[I7 >> 2], E3[C4 + 228 >> 2] = s4, aA(s4 = C4 + 256 | 0, C4 + 240 | 0, C4 + 224 | 0), n4 = E3[C4 + 268 >> 2], E3[I7 + 8 >> 2] = E3[C4 + 264 >> 2], E3[I7 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[I7 >> 2] = E3[C4 + 256 >> 2], E3[I7 + 4 >> 2] = n4, n4 = E3[D4 + 12 >> 2], E3[C4 + 216 >> 2] = E3[D4 + 8 >> 2], E3[C4 + 220 >> 2] = n4, n4 = E3[D4 + 4 >> 2], E3[C4 + 208 >> 2] = E3[D4 >> 2], E3[C4 + 212 >> 2] = n4, n4 = E3[c4 + 12 >> 2], E3[C4 + 200 >> 2] = E3[c4 + 8 >> 2], E3[C4 + 204 >> 2] = n4, n4 = E3[c4 + 4 >> 2], E3[C4 + 192 >> 2] = E3[c4 >> 2], E3[C4 + 196 >> 2] = n4, aA(s4, C4 + 208 | 0, C4 + 192 | 0), n4 = E3[C4 + 268 >> 2], E3[c4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[c4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[c4 >> 2] = E3[C4 + 256 >> 2], E3[c4 + 4 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 184 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 188 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 176 >> 2] = E3[A8 >> 2], E3[C4 + 180 >> 2] = n4, n4 = E3[D4 + 12 >> 2], E3[C4 + 168 >> 2] = E3[D4 + 8 >> 2], E3[C4 + 172 >> 2] = n4, n4 = E3[D4 + 4 >> 2], E3[C4 + 160 >> 2] = E3[D4 >> 2], E3[C4 + 164 >> 2] = n4, aA(s4, C4 + 176 | 0, C4 + 160 | 0), n4 = E3[C4 + 268 >> 2], E3[D4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[D4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[D4 >> 2] = E3[C4 + 256 >> 2], E3[D4 + 4 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 152 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 156 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 144 >> 2] = E3[B4 >> 2], E3[C4 + 148 >> 2] = n4, n4 = E3[A8 + 12 >> 2], E3[C4 + 136 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 140 >> 2] = n4, n4 = E3[A8 + 4 >> 2], E3[C4 + 128 >> 2] = E3[A8 >> 2], E3[C4 + 132 >> 2] = n4, aA(s4, C4 + 144 | 0, C4 + 128 | 0), n4 = E3[C4 + 268 >> 2], E3[A8 + 8 >> 2] = E3[C4 + 264 >> 2], E3[A8 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[A8 >> 2] = E3[C4 + 256 >> 2], E3[A8 + 4 >> 2] = n4, n4 = E3[Q4 + 12 >> 2], E3[C4 + 120 >> 2] = E3[Q4 + 8 >> 2], E3[C4 + 124 >> 2] = n4, n4 = E3[Q4 + 4 >> 2], E3[C4 + 112 >> 2] = E3[Q4 >> 2], E3[C4 + 116 >> 2] = n4, n4 = E3[B4 + 12 >> 2], E3[C4 + 104 >> 2] = E3[B4 + 8 >> 2], E3[C4 + 108 >> 2] = n4, n4 = E3[B4 + 4 >> 2], E3[C4 + 96 >> 2] = E3[B4 >> 2], E3[C4 + 100 >> 2] = n4, aA(s4, C4 + 112 | 0, C4 + 96 | 0), n4 = E3[C4 + 268 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[B4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[B4 >> 2] = E3[C4 + 256 >> 2], E3[B4 + 4 >> 2] = n4, n4 = E3[o4 + 12 >> 2], E3[C4 + 88 >> 2] = E3[o4 + 8 >> 2], E3[C4 + 92 >> 2] = n4, n4 = E3[o4 + 4 >> 2], E3[C4 + 80 >> 2] = E3[o4 >> 2], E3[C4 + 84 >> 2] = n4, n4 = E3[Q4 + 12 >> 2], E3[C4 + 72 >> 2] = E3[Q4 + 8 >> 2], E3[C4 + 76 >> 2] = n4, n4 = E3[Q4 + 4 >> 2], E3[C4 + 64 >> 2] = E3[Q4 >> 2], E3[C4 + 68 >> 2] = n4, aA(s4, C4 + 80 | 0, C4 - -64 | 0), n4 = E3[C4 + 268 >> 2], E3[Q4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[Q4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[Q4 >> 2] = E3[C4 + 256 >> 2], E3[Q4 + 4 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 60 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 + 48 >> 2] = E3[g6 >> 2], E3[C4 + 52 >> 2] = n4, n4 = E3[o4 + 12 >> 2], E3[C4 + 40 >> 2] = E3[o4 + 8 >> 2], E3[C4 + 44 >> 2] = n4, n4 = E3[o4 + 4 >> 2], E3[C4 + 32 >> 2] = E3[o4 >> 2], E3[C4 + 36 >> 2] = n4, aA(s4, C4 + 48 | 0, C4 + 32 | 0), n4 = E3[C4 + 268 >> 2], E3[o4 + 8 >> 2] = E3[C4 + 264 >> 2], E3[o4 + 12 >> 2] = n4, n4 = E3[C4 + 260 >> 2], E3[o4 >> 2] = E3[C4 + 256 >> 2], E3[o4 + 4 >> 2] = n4, n4 = E3[C4 + 284 >> 2], E3[C4 + 24 >> 2] = E3[C4 + 280 >> 2], E3[C4 + 28 >> 2] = n4, n4 = E3[C4 + 276 >> 2], E3[C4 + 16 >> 2] = E3[C4 + 272 >> 2], E3[C4 + 20 >> 2] = n4, n4 = E3[g6 + 12 >> 2], E3[C4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[C4 + 12 >> 2] = n4, n4 = E3[g6 + 4 >> 2], E3[C4 >> 2] = E3[g6 >> 2], E3[C4 + 4 >> 2] = n4, aA(s4, C4 + 16 | 0, C4), s4 = E3[C4 + 268 >> 2], E3[g6 + 8 >> 2] = E3[C4 + 264 >> 2], E3[g6 + 12 >> 2] = s4, s4 = E3[C4 + 260 >> 2], E3[g6 >> 2] = E3[C4 + 256 >> 2], E3[g6 + 4 >> 2] = s4, E3[g6 + 12 >> 2] = (i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24) ^ h4, E3[g6 + 8 >> 2] = (i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24) ^ t4, E3[g6 + 4 >> 2] = (i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24) ^ w4, E3[g6 >> 2] = (i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24) ^ k4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ e4, E3[g6 + 68 >> 2] = (i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24) ^ a4, E3[g6 + 72 >> 2] = (i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24) ^ y4, E3[g6 + 76 >> 2] = (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24) ^ f4, 10 != (0 | (F4 = F4 + 1 | 0)); ) ; + r3 = C4 + 288 | 0; + } + function P3(A8, I7, g6, B4, Q4) { + var o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0; + for (o4 = r3 + -64 | 0, c4 = E3[A8 + 60 >> 2], D4 = E3[A8 + 56 >> 2], q4 = E3[A8 + 52 >> 2], m4 = E3[A8 + 48 >> 2], a4 = E3[A8 + 44 >> 2], y4 = E3[A8 + 40 >> 2], f4 = E3[A8 + 36 >> 2], e4 = E3[A8 + 32 >> 2], w4 = E3[A8 + 28 >> 2], t4 = E3[A8 + 24 >> 2], h4 = E3[A8 + 20 >> 2], k4 = E3[A8 + 16 >> 2], n4 = E3[A8 + 12 >> 2], s4 = E3[A8 + 8 >> 2], F4 = E3[A8 + 4 >> 2], S4 = E3[A8 >> 2]; ; ) { + if (!Q4 & B4 >>> 0 > 63 | Q4) M4 = g6; + else { + if (E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, E3[o4 + 24 >> 2] = 0, E3[o4 + 28 >> 2] = 0, E3[o4 + 16 >> 2] = 0, E3[o4 + 20 >> 2] = 0, E3[o4 + 8 >> 2] = 0, E3[o4 + 12 >> 2] = 0, E3[o4 >> 2] = 0, E3[o4 + 4 >> 2] = 0, K4 = 0, B4 | Q4) for (; C3[K4 + o4 | 0] = i3[I7 + K4 | 0], !Q4 & (K4 = K4 + 1 | 0) >>> 0 < B4 >>> 0 | Q4; ) ; + I7 = M4 = o4, O2 = g6; + } + for (l3 = 20, N4 = S4, U4 = F4, d4 = s4, v4 = n4, K4 = k4, g6 = h4, p4 = t4, H4 = w4, G4 = e4, L4 = f4, b4 = y4, _4 = c4, x4 = D4, R4 = q4, P4 = m4, J4 = a4; Y4 = K4, N4 = gI((K4 = N4 + K4 | 0) ^ P4, 16), Y4 = P4 = gI(Y4 ^ (G4 = N4 + G4 | 0), 12), P4 = gI((u4 = K4 + P4 | 0) ^ N4, 8), K4 = gI(Y4 ^ (G4 = P4 + G4 | 0), 7), _4 = gI((N4 = H4 + v4 | 0) ^ _4, 16), H4 = gI((J4 = _4 + J4 | 0) ^ H4, 12), v4 = gI((d4 = p4 + d4 | 0) ^ x4, 16), p4 = gI((b4 = v4 + b4 | 0) ^ p4, 12), x4 = (z2 = N4 + H4 | 0) + K4 | 0, j2 = gI((d4 = p4 + d4 | 0) ^ v4, 8), N4 = gI(x4 ^ j2, 16), v4 = gI((U4 = g6 + U4 | 0) ^ R4, 16), g6 = gI((L4 = v4 + L4 | 0) ^ g6, 12), Y4 = K4, R4 = gI((U4 = g6 + U4 | 0) ^ v4, 8), Y4 = gI(Y4 ^ (K4 = (X2 = R4 + L4 | 0) + N4 | 0), 12), x4 = gI(N4 ^ (v4 = Y4 + x4 | 0), 8), K4 = gI((L4 = x4 + K4 | 0) ^ Y4, 7), Y4 = G4, G4 = d4, N4 = gI(_4 ^ z2, 8), d4 = gI((_4 = N4 + J4 | 0) ^ H4, 7), R4 = gI((G4 = G4 + d4 | 0) ^ R4, 16), J4 = gI((H4 = Y4 + R4 | 0) ^ d4, 12), R4 = gI(R4 ^ (d4 = J4 + G4 | 0), 8), H4 = gI((G4 = H4 + R4 | 0) ^ J4, 7), J4 = _4, _4 = U4, U4 = gI((b4 = b4 + j2 | 0) ^ p4, 7), p4 = J4 + (P4 = gI((_4 = _4 + U4 | 0) ^ P4, 16)) | 0, J4 = _4, _4 = gI(p4 ^ U4, 12), P4 = gI(P4 ^ (U4 = J4 + _4 | 0), 8), p4 = gI((J4 = p4 + P4 | 0) ^ _4, 7), Y4 = b4, _4 = N4, N4 = gI(g6 ^ X2, 7), _4 = gI(_4 ^ (b4 = N4 + u4 | 0), 16), u4 = gI((g6 = Y4 + _4 | 0) ^ N4, 12), _4 = gI(_4 ^ (N4 = u4 + b4 | 0), 8), g6 = gI((b4 = g6 + _4 | 0) ^ u4, 7), l3 = l3 - 2 | 0; ) ; + if (l3 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, u4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, z2 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, j2 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, X2 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, Y4 = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, T2 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, V2 = i3[I7 + 32 | 0] | i3[I7 + 33 | 0] << 8 | i3[I7 + 34 | 0] << 16 | i3[I7 + 35 | 0] << 24, Z2 = i3[I7 + 36 | 0] | i3[I7 + 37 | 0] << 8 | i3[I7 + 38 | 0] << 16 | i3[I7 + 39 | 0] << 24, W2 = i3[I7 + 40 | 0] | i3[I7 + 41 | 0] << 8 | i3[I7 + 42 | 0] << 16 | i3[I7 + 43 | 0] << 24, $2 = i3[I7 + 44 | 0] | i3[I7 + 45 | 0] << 8 | i3[I7 + 46 | 0] << 16 | i3[I7 + 47 | 0] << 24, AA2 = i3[I7 + 48 | 0] | i3[I7 + 49 | 0] << 8 | i3[I7 + 50 | 0] << 16 | i3[I7 + 51 | 0] << 24, IA2 = i3[I7 + 52 | 0] | i3[I7 + 53 | 0] << 8 | i3[I7 + 54 | 0] << 16 | i3[I7 + 55 | 0] << 24, gA2 = i3[I7 + 56 | 0] | i3[I7 + 57 | 0] << 8 | i3[I7 + 58 | 0] << 16 | i3[I7 + 59 | 0] << 24, CA2 = i3[I7 + 60 | 0] | i3[I7 + 61 | 0] << 8 | i3[I7 + 62 | 0] << 16 | i3[I7 + 63 | 0] << 24, N4 = N4 + S4 ^ (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24), C3[0 | M4] = N4, C3[M4 + 1 | 0] = N4 >>> 8, C3[M4 + 2 | 0] = N4 >>> 16, C3[M4 + 3 | 0] = N4 >>> 24, N4 = _4 + c4 ^ CA2, C3[M4 + 60 | 0] = N4, C3[M4 + 61 | 0] = N4 >>> 8, C3[M4 + 62 | 0] = N4 >>> 16, C3[M4 + 63 | 0] = N4 >>> 24, N4 = x4 + D4 ^ gA2, C3[M4 + 56 | 0] = N4, C3[M4 + 57 | 0] = N4 >>> 8, C3[M4 + 58 | 0] = N4 >>> 16, C3[M4 + 59 | 0] = N4 >>> 24, N4 = R4 + q4 ^ IA2, C3[M4 + 52 | 0] = N4, C3[M4 + 53 | 0] = N4 >>> 8, C3[M4 + 54 | 0] = N4 >>> 16, C3[M4 + 55 | 0] = N4 >>> 24, N4 = P4 + m4 ^ AA2, C3[M4 + 48 | 0] = N4, C3[M4 + 49 | 0] = N4 >>> 8, C3[M4 + 50 | 0] = N4 >>> 16, C3[M4 + 51 | 0] = N4 >>> 24, N4 = J4 + a4 ^ $2, C3[M4 + 44 | 0] = N4, C3[M4 + 45 | 0] = N4 >>> 8, C3[M4 + 46 | 0] = N4 >>> 16, C3[M4 + 47 | 0] = N4 >>> 24, N4 = b4 + y4 ^ W2, C3[M4 + 40 | 0] = N4, C3[M4 + 41 | 0] = N4 >>> 8, C3[M4 + 42 | 0] = N4 >>> 16, C3[M4 + 43 | 0] = N4 >>> 24, N4 = L4 + f4 ^ Z2, C3[M4 + 36 | 0] = N4, C3[M4 + 37 | 0] = N4 >>> 8, C3[M4 + 38 | 0] = N4 >>> 16, C3[M4 + 39 | 0] = N4 >>> 24, N4 = G4 + e4 ^ V2, C3[M4 + 32 | 0] = N4, C3[M4 + 33 | 0] = N4 >>> 8, C3[M4 + 34 | 0] = N4 >>> 16, C3[M4 + 35 | 0] = N4 >>> 24, H4 = H4 + w4 ^ T2, C3[M4 + 28 | 0] = H4, C3[M4 + 29 | 0] = H4 >>> 8, C3[M4 + 30 | 0] = H4 >>> 16, C3[M4 + 31 | 0] = H4 >>> 24, p4 = Y4 ^ p4 + t4, C3[M4 + 24 | 0] = p4, C3[M4 + 25 | 0] = p4 >>> 8, C3[M4 + 26 | 0] = p4 >>> 16, C3[M4 + 27 | 0] = p4 >>> 24, g6 = X2 ^ g6 + h4, C3[M4 + 20 | 0] = g6, C3[M4 + 21 | 0] = g6 >>> 8, C3[M4 + 22 | 0] = g6 >>> 16, C3[M4 + 23 | 0] = g6 >>> 24, g6 = j2 ^ K4 + k4, C3[M4 + 16 | 0] = g6, C3[M4 + 17 | 0] = g6 >>> 8, C3[M4 + 18 | 0] = g6 >>> 16, C3[M4 + 19 | 0] = g6 >>> 24, g6 = z2 ^ v4 + n4, C3[M4 + 12 | 0] = g6, C3[M4 + 13 | 0] = g6 >>> 8, C3[M4 + 14 | 0] = g6 >>> 16, C3[M4 + 15 | 0] = g6 >>> 24, g6 = u4 ^ d4 + s4, C3[M4 + 8 | 0] = g6, C3[M4 + 9 | 0] = g6 >>> 8, C3[M4 + 10 | 0] = g6 >>> 16, C3[M4 + 11 | 0] = g6 >>> 24, g6 = l3 ^ U4 + F4, C3[M4 + 4 | 0] = g6, C3[M4 + 5 | 0] = g6 >>> 8, C3[M4 + 6 | 0] = g6 >>> 16, C3[M4 + 7 | 0] = g6 >>> 24, q4 = !(m4 = m4 + 1 | 0) + q4 | 0, !Q4 & B4 >>> 0 <= 64) { + if (!(!(B4 | Q4) | !Q4 & B4 >>> 0 > 63 | !!(0 | Q4))) for (K4 = 0; C3[K4 + O2 | 0] = i3[M4 + K4 | 0], B4 >>> 0 > (K4 = K4 + 1 | 0) >>> 0; ) ; + E3[A8 + 52 >> 2] = q4, E3[A8 + 48 >> 2] = m4; + break; + } + I7 = I7 - -64 | 0, g6 = M4 - -64 | 0, Q4 = Q4 - 1 | 0, Q4 = (B4 = B4 + -64 | 0) >>> 0 < 4294967232 ? Q4 + 1 | 0 : Q4; + } + } + function v3(A8, I7) { + var g6, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0; + r3 = g6 = r3 - 704 | 0, B4 = 80 + ((Q4 = E3[A8 + 72 >> 2] >>> 3 & 127) + A8 | 0) | 0, Q4 >>> 0 >= 112 ? (TA(B4, 34608, 128 - Q4 | 0), n3(A8, Q4 = A8 + 80 | 0, g6, g6 + 640 | 0), VA(Q4, 0, 112)) : TA(B4, 34608, 112 - Q4 | 0), D4 = (i4 = E3[A8 + 64 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 68 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[A8 + 192 | 0] = B4, C3[A8 + 193 | 0] = B4 >>> 8, C3[A8 + 194 | 0] = B4 >>> 16, C3[A8 + 195 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[A8 + 196 | 0] = Q4, C3[A8 + 197 | 0] = Q4 >>> 8, C3[A8 + 198 | 0] = Q4 >>> 16, C3[A8 + 199 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 72 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 76 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[A8 + 200 | 0] = B4, C3[A8 + 201 | 0] = B4 >>> 8, C3[A8 + 202 | 0] = B4 >>> 16, C3[A8 + 203 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[A8 + 204 | 0] = Q4, C3[A8 + 205 | 0] = Q4 >>> 8, C3[A8 + 206 | 0] = Q4 >>> 16, C3[A8 + 207 | 0] = Q4 >>> 24, n3(A8, A8 + 80 | 0, g6, g6 + 640 | 0), D4 = (i4 = E3[A8 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 4 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[0 | I7] = B4, C3[I7 + 1 | 0] = B4 >>> 8, C3[I7 + 2 | 0] = B4 >>> 16, C3[I7 + 3 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 4 | 0] = Q4, C3[I7 + 5 | 0] = Q4 >>> 8, C3[I7 + 6 | 0] = Q4 >>> 16, C3[I7 + 7 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 8 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 12 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 8 | 0] = B4, C3[I7 + 9 | 0] = B4 >>> 8, C3[I7 + 10 | 0] = B4 >>> 16, C3[I7 + 11 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 12 | 0] = Q4, C3[I7 + 13 | 0] = Q4 >>> 8, C3[I7 + 14 | 0] = Q4 >>> 16, C3[I7 + 15 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 16 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 20 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 16 | 0] = B4, C3[I7 + 17 | 0] = B4 >>> 8, C3[I7 + 18 | 0] = B4 >>> 16, C3[I7 + 19 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 20 | 0] = Q4, C3[I7 + 21 | 0] = Q4 >>> 8, C3[I7 + 22 | 0] = Q4 >>> 16, C3[I7 + 23 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 24 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 28 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 24 | 0] = B4, C3[I7 + 25 | 0] = B4 >>> 8, C3[I7 + 26 | 0] = B4 >>> 16, C3[I7 + 27 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 28 | 0] = Q4, C3[I7 + 29 | 0] = Q4 >>> 8, C3[I7 + 30 | 0] = Q4 >>> 16, C3[I7 + 31 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 32 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 36 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 32 | 0] = B4, C3[I7 + 33 | 0] = B4 >>> 8, C3[I7 + 34 | 0] = B4 >>> 16, C3[I7 + 35 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 36 | 0] = Q4, C3[I7 + 37 | 0] = Q4 >>> 8, C3[I7 + 38 | 0] = Q4 >>> 16, C3[I7 + 39 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 40 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 44 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 40 | 0] = B4, C3[I7 + 41 | 0] = B4 >>> 8, C3[I7 + 42 | 0] = B4 >>> 16, C3[I7 + 43 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 44 | 0] = Q4, C3[I7 + 45 | 0] = Q4 >>> 8, C3[I7 + 46 | 0] = Q4 >>> 16, C3[I7 + 47 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 48 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, B4 = a4 | c4 << 8 | -16777216 & ((255 & (B4 = E3[A8 + 52 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & B4) << 8 | i4 >>> 24) | B4 >>> 8 & 65280 | B4 >>> 24, C3[I7 + 48 | 0] = B4, C3[I7 + 49 | 0] = B4 >>> 8, C3[I7 + 50 | 0] = B4 >>> 16, C3[I7 + 51 | 0] = B4 >>> 24, B4 = Q4 | o4 | D4, Q4 = 0, Q4 |= B4, C3[I7 + 52 | 0] = Q4, C3[I7 + 53 | 0] = Q4 >>> 8, C3[I7 + 54 | 0] = Q4 >>> 16, C3[I7 + 55 | 0] = Q4 >>> 24, D4 = (i4 = E3[A8 + 56 >> 2]) << 24 | (65280 & i4) << 8, Q4 = (o4 = 16711680 & i4) >>> 8 | 0, B4 = I7, a4 = o4 << 24, o4 = (c4 = -16777216 & i4) >>> 24 | 0, I7 = a4 | c4 << 8 | -16777216 & ((255 & (I7 = E3[A8 + 60 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & I7) << 8 | i4 >>> 24) | I7 >>> 8 & 65280 | I7 >>> 24, C3[B4 + 56 | 0] = I7, C3[B4 + 57 | 0] = I7 >>> 8, C3[B4 + 58 | 0] = I7 >>> 16, C3[B4 + 59 | 0] = I7 >>> 24, I7 = Q4 | o4 | D4, I7 |= Q4 = 0, C3[B4 + 60 | 0] = I7, C3[B4 + 61 | 0] = I7 >>> 8, C3[B4 + 62 | 0] = I7 >>> 16, C3[B4 + 63 | 0] = I7 >>> 24, MI(g6, 704), MI(A8, 208), r3 = g6 + 704 | 0; + } + function R3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, M4, N4, K4, _4 = 0; + r3 = B4 = r3 - 224 | 0, a4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, y4 = i3[0 | (_4 = g6 - -64 | 0)] | i3[_4 + 1 | 0] << 8 | i3[_4 + 2 | 0] << 16 | i3[_4 + 3 | 0] << 24, f4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, e4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, w4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, Q4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, t4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, h4 = i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24, k4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, n4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, s4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, o4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, F4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, S4 = i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24, M4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, N4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, K4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, c4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = (D4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ (i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) & (i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24) ^ (i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24) ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24), C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = N4 & K4 ^ S4 ^ M4 ^ F4 ^ o4, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = n4 & s4 ^ h4 ^ k4 ^ t4 ^ Q4, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = e4 & w4 ^ a4 ^ y4 ^ f4 ^ c4, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, A8 = E3[_4 + 4 >> 2], E3[B4 + 176 >> 2] = E3[_4 >> 2], E3[B4 + 180 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = A8, aA(A8 = B4 + 192 | 0, B4 + 176 | 0, B4 + 160 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 92 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 84 >> 2] = I7, I7 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = I7, I7 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = I7, I7 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = I7, I7 = E3[_4 + 4 >> 2], E3[B4 + 128 >> 2] = E3[_4 >> 2], E3[B4 + 132 >> 2] = I7, aA(A8, B4 + 144 | 0, B4 + 128 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 76 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[_4 >> 2] = E3[B4 + 192 >> 2], E3[_4 + 4 >> 2] = I7, I7 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = I7, I7 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = I7, I7 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = I7, I7 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = I7, aA(A8, B4 + 112 | 0, B4 + 96 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 60 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 52 >> 2] = I7, I7 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = I7, I7 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = I7, I7 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = I7, I7 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = I7, aA(A8, B4 + 80 | 0, B4 - -64 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 44 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 36 >> 2] = I7, I7 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = I7, I7 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = I7, I7 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = I7, I7 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = I7, aA(A8, B4 + 48 | 0, B4 + 32 | 0), I7 = E3[B4 + 204 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 28 >> 2] = I7, I7 = E3[B4 + 196 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 20 >> 2] = I7, I7 = E3[B4 + 220 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 216 >> 2], E3[B4 + 28 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 208 >> 2], E3[B4 + 20 >> 2] = I7, I7 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = I7, I7 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = I7, aA(A8, B4 + 16 | 0, B4), A8 = E3[B4 + 192 >> 2], I7 = E3[B4 + 196 >> 2], _4 = E3[B4 + 200 >> 2], E3[g6 + 12 >> 2] = D4 ^ E3[B4 + 204 >> 2], E3[g6 + 8 >> 2] = _4 ^ o4, E3[g6 + 4 >> 2] = I7 ^ Q4, E3[g6 >> 2] = A8 ^ c4, r3 = B4 + 224 | 0; + } + function L3(A8, I7, g6) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0; + r3 = B4 = r3 - 224 | 0, M4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, S4 = i3[0 | (F4 = g6 - -64 | 0)] | i3[F4 + 1 | 0] << 8 | i3[F4 + 2 | 0] << 16 | i3[F4 + 3 | 0] << 24, Q4 = i3[g6 + 80 | 0] | i3[g6 + 81 | 0] << 8 | i3[g6 + 82 | 0] << 16 | i3[g6 + 83 | 0] << 24, o4 = i3[g6 + 32 | 0] | i3[g6 + 33 | 0] << 8 | i3[g6 + 34 | 0] << 16 | i3[g6 + 35 | 0] << 24, c4 = i3[g6 + 48 | 0] | i3[g6 + 49 | 0] << 8 | i3[g6 + 50 | 0] << 16 | i3[g6 + 51 | 0] << 24, N4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, D4 = i3[g6 + 68 | 0] | i3[g6 + 69 | 0] << 8 | i3[g6 + 70 | 0] << 16 | i3[g6 + 71 | 0] << 24, a4 = i3[g6 + 84 | 0] | i3[g6 + 85 | 0] << 8 | i3[g6 + 86 | 0] << 16 | i3[g6 + 87 | 0] << 24, y4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, f4 = i3[g6 + 36 | 0] | i3[g6 + 37 | 0] << 8 | i3[g6 + 38 | 0] << 16 | i3[g6 + 39 | 0] << 24, e4 = i3[g6 + 52 | 0] | i3[g6 + 53 | 0] << 8 | i3[g6 + 54 | 0] << 16 | i3[g6 + 55 | 0] << 24, K4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, w4 = i3[g6 + 72 | 0] | i3[g6 + 73 | 0] << 8 | i3[g6 + 74 | 0] << 16 | i3[g6 + 75 | 0] << 24, t4 = i3[g6 + 88 | 0] | i3[g6 + 89 | 0] << 8 | i3[g6 + 90 | 0] << 16 | i3[g6 + 91 | 0] << 24, h4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, k4 = i3[g6 + 40 | 0] | i3[g6 + 41 | 0] << 8 | i3[g6 + 42 | 0] << 16 | i3[g6 + 43 | 0] << 24, n4 = i3[g6 + 56 | 0] | i3[g6 + 57 | 0] << 8 | i3[g6 + 58 | 0] << 16 | i3[g6 + 59 | 0] << 24, s4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, I7 = (i3[g6 + 44 | 0] | i3[g6 + 45 | 0] << 8 | i3[g6 + 46 | 0] << 16 | i3[g6 + 47 | 0] << 24) & (i3[g6 + 60 | 0] | i3[g6 + 61 | 0] << 8 | i3[g6 + 62 | 0] << 16 | i3[g6 + 63 | 0] << 24) ^ (i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24) ^ (i3[g6 + 76 | 0] | i3[g6 + 77 | 0] << 8 | i3[g6 + 78 | 0] << 16 | i3[g6 + 79 | 0] << 24) ^ (i3[g6 + 92 | 0] | i3[g6 + 93 | 0] << 8 | i3[g6 + 94 | 0] << 16 | i3[g6 + 95 | 0] << 24) ^ (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24), C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, K4 = k4 & n4 ^ K4 ^ t4 ^ h4 ^ w4, C3[A8 + 8 | 0] = K4, C3[A8 + 9 | 0] = K4 >>> 8, C3[A8 + 10 | 0] = K4 >>> 16, C3[A8 + 11 | 0] = K4 >>> 24, N4 = f4 & e4 ^ N4 ^ a4 ^ y4 ^ D4, C3[A8 + 4 | 0] = N4, C3[A8 + 5 | 0] = N4 >>> 8, C3[A8 + 6 | 0] = N4 >>> 16, C3[A8 + 7 | 0] = N4 >>> 24, M4 = o4 & c4 ^ M4 ^ S4 ^ Q4 ^ s4, C3[0 | A8] = M4, C3[A8 + 1 | 0] = M4 >>> 8, C3[A8 + 2 | 0] = M4 >>> 16, C3[A8 + 3 | 0] = M4 >>> 24, A8 = E3[g6 + 92 >> 2], E3[B4 + 216 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 220 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 208 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 212 >> 2] = A8, A8 = E3[g6 + 76 >> 2], E3[B4 + 184 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 188 >> 2] = A8, A8 = E3[F4 + 4 >> 2], E3[B4 + 176 >> 2] = E3[F4 >> 2], E3[B4 + 180 >> 2] = A8, A8 = E3[g6 + 92 >> 2], E3[B4 + 168 >> 2] = E3[g6 + 88 >> 2], E3[B4 + 172 >> 2] = A8, A8 = E3[g6 + 84 >> 2], E3[B4 + 160 >> 2] = E3[g6 + 80 >> 2], E3[B4 + 164 >> 2] = A8, aA(A8 = B4 + 192 | 0, B4 + 176 | 0, B4 + 160 | 0), S4 = E3[B4 + 204 >> 2], E3[g6 + 88 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 92 >> 2] = S4, S4 = E3[B4 + 196 >> 2], E3[g6 + 80 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 84 >> 2] = S4, S4 = E3[g6 + 60 >> 2], E3[B4 + 152 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 156 >> 2] = S4, S4 = E3[g6 + 52 >> 2], E3[B4 + 144 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 148 >> 2] = S4, S4 = E3[g6 + 76 >> 2], E3[B4 + 136 >> 2] = E3[g6 + 72 >> 2], E3[B4 + 140 >> 2] = S4, S4 = E3[F4 + 4 >> 2], E3[B4 + 128 >> 2] = E3[F4 >> 2], E3[B4 + 132 >> 2] = S4, aA(A8, B4 + 144 | 0, B4 + 128 | 0), S4 = E3[B4 + 204 >> 2], E3[g6 + 72 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 76 >> 2] = S4, S4 = E3[B4 + 196 >> 2], E3[F4 >> 2] = E3[B4 + 192 >> 2], E3[F4 + 4 >> 2] = S4, F4 = E3[g6 + 44 >> 2], E3[B4 + 120 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 124 >> 2] = F4, F4 = E3[g6 + 36 >> 2], E3[B4 + 112 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 116 >> 2] = F4, F4 = E3[g6 + 60 >> 2], E3[B4 + 104 >> 2] = E3[g6 + 56 >> 2], E3[B4 + 108 >> 2] = F4, F4 = E3[g6 + 52 >> 2], E3[B4 + 96 >> 2] = E3[g6 + 48 >> 2], E3[B4 + 100 >> 2] = F4, aA(A8, B4 + 112 | 0, B4 + 96 | 0), F4 = E3[B4 + 204 >> 2], E3[g6 + 56 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 60 >> 2] = F4, F4 = E3[B4 + 196 >> 2], E3[g6 + 48 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 52 >> 2] = F4, F4 = E3[g6 + 28 >> 2], E3[B4 + 88 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 92 >> 2] = F4, F4 = E3[g6 + 20 >> 2], E3[B4 + 80 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 84 >> 2] = F4, F4 = E3[g6 + 44 >> 2], E3[B4 + 72 >> 2] = E3[g6 + 40 >> 2], E3[B4 + 76 >> 2] = F4, F4 = E3[g6 + 36 >> 2], E3[B4 + 64 >> 2] = E3[g6 + 32 >> 2], E3[B4 + 68 >> 2] = F4, aA(A8, B4 + 80 | 0, B4 - -64 | 0), F4 = E3[B4 + 204 >> 2], E3[g6 + 40 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 44 >> 2] = F4, F4 = E3[B4 + 196 >> 2], E3[g6 + 32 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 36 >> 2] = F4, F4 = E3[g6 + 12 >> 2], E3[B4 + 56 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 60 >> 2] = F4, F4 = E3[g6 + 4 >> 2], E3[B4 + 48 >> 2] = E3[g6 >> 2], E3[B4 + 52 >> 2] = F4, F4 = E3[g6 + 28 >> 2], E3[B4 + 40 >> 2] = E3[g6 + 24 >> 2], E3[B4 + 44 >> 2] = F4, F4 = E3[g6 + 20 >> 2], E3[B4 + 32 >> 2] = E3[g6 + 16 >> 2], E3[B4 + 36 >> 2] = F4, aA(A8, B4 + 48 | 0, B4 + 32 | 0), F4 = E3[B4 + 204 >> 2], E3[g6 + 24 >> 2] = E3[B4 + 200 >> 2], E3[g6 + 28 >> 2] = F4, F4 = E3[B4 + 196 >> 2], E3[g6 + 16 >> 2] = E3[B4 + 192 >> 2], E3[g6 + 20 >> 2] = F4, F4 = E3[B4 + 220 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 216 >> 2], E3[B4 + 28 >> 2] = F4, F4 = E3[B4 + 212 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 208 >> 2], E3[B4 + 20 >> 2] = F4, F4 = E3[g6 + 12 >> 2], E3[B4 + 8 >> 2] = E3[g6 + 8 >> 2], E3[B4 + 12 >> 2] = F4, F4 = E3[g6 + 4 >> 2], E3[B4 >> 2] = E3[g6 >> 2], E3[B4 + 4 >> 2] = F4, aA(A8, B4 + 16 | 0, B4), A8 = E3[B4 + 192 >> 2], F4 = E3[B4 + 196 >> 2], S4 = E3[B4 + 200 >> 2], E3[g6 + 12 >> 2] = I7 ^ E3[B4 + 204 >> 2], E3[g6 + 8 >> 2] = S4 ^ K4, E3[g6 + 4 >> 2] = F4 ^ N4, E3[g6 >> 2] = A8 ^ M4, r3 = B4 + 224 | 0; + } + function x3(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4 = 0, e4 = 0; + r3 = g6 = r3 - 288 | 0, C4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, B4 = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, Q4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, o4 = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, c4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, D4 = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, a4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, y4 = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, A8 = E3[I7 + 124 >> 2], E3[g6 + 280 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 284 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 272 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 276 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 248 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 252 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 240 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 244 >> 2] = A8, A8 = E3[I7 + 124 >> 2], E3[g6 + 232 >> 2] = E3[I7 + 120 >> 2], E3[g6 + 236 >> 2] = A8, A8 = E3[I7 + 116 >> 2], E3[g6 + 224 >> 2] = E3[I7 + 112 >> 2], E3[g6 + 228 >> 2] = A8, aA(e4 = g6 + 256 | 0, g6 + 240 | 0, g6 + 224 | 0), A8 = E3[g6 + 268 >> 2], E3[I7 + 120 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 124 >> 2] = A8, A8 = E3[g6 + 260 >> 2], E3[I7 + 112 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 116 >> 2] = A8, A8 = E3[I7 + 92 >> 2], E3[g6 + 216 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 220 >> 2] = A8, A8 = E3[I7 + 84 >> 2], E3[g6 + 208 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 212 >> 2] = A8, A8 = E3[I7 + 108 >> 2], E3[g6 + 200 >> 2] = E3[I7 + 104 >> 2], E3[g6 + 204 >> 2] = A8, A8 = E3[I7 + 100 >> 2], E3[g6 + 192 >> 2] = E3[I7 + 96 >> 2], E3[g6 + 196 >> 2] = A8, aA(e4, g6 + 208 | 0, g6 + 192 | 0), A8 = E3[g6 + 268 >> 2], E3[I7 + 104 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 108 >> 2] = A8, A8 = E3[g6 + 260 >> 2], E3[I7 + 96 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 100 >> 2] = A8, A8 = E3[I7 + 76 >> 2], E3[g6 + 184 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 188 >> 2] = A8, f4 = E3[4 + (A8 = I7 - -64 | 0) >> 2], E3[g6 + 176 >> 2] = E3[A8 >> 2], E3[g6 + 180 >> 2] = f4, f4 = E3[I7 + 92 >> 2], E3[g6 + 168 >> 2] = E3[I7 + 88 >> 2], E3[g6 + 172 >> 2] = f4, f4 = E3[I7 + 84 >> 2], E3[g6 + 160 >> 2] = E3[I7 + 80 >> 2], E3[g6 + 164 >> 2] = f4, aA(e4, g6 + 176 | 0, g6 + 160 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 88 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 92 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 80 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 84 >> 2] = f4, f4 = E3[I7 + 60 >> 2], E3[g6 + 152 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 156 >> 2] = f4, f4 = E3[I7 + 52 >> 2], E3[g6 + 144 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 148 >> 2] = f4, f4 = E3[I7 + 76 >> 2], E3[g6 + 136 >> 2] = E3[I7 + 72 >> 2], E3[g6 + 140 >> 2] = f4, f4 = E3[A8 + 4 >> 2], E3[g6 + 128 >> 2] = E3[A8 >> 2], E3[g6 + 132 >> 2] = f4, aA(e4, g6 + 144 | 0, g6 + 128 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 72 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 76 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[A8 >> 2] = E3[g6 + 256 >> 2], E3[A8 + 4 >> 2] = f4, f4 = E3[I7 + 44 >> 2], E3[g6 + 120 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 124 >> 2] = f4, f4 = E3[I7 + 36 >> 2], E3[g6 + 112 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 116 >> 2] = f4, f4 = E3[I7 + 60 >> 2], E3[g6 + 104 >> 2] = E3[I7 + 56 >> 2], E3[g6 + 108 >> 2] = f4, f4 = E3[I7 + 52 >> 2], E3[g6 + 96 >> 2] = E3[I7 + 48 >> 2], E3[g6 + 100 >> 2] = f4, aA(e4, g6 + 112 | 0, g6 + 96 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 56 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 60 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 48 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 52 >> 2] = f4, f4 = E3[I7 + 28 >> 2], E3[g6 + 88 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 92 >> 2] = f4, f4 = E3[I7 + 20 >> 2], E3[g6 + 80 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 84 >> 2] = f4, f4 = E3[I7 + 44 >> 2], E3[g6 + 72 >> 2] = E3[I7 + 40 >> 2], E3[g6 + 76 >> 2] = f4, f4 = E3[I7 + 36 >> 2], E3[g6 + 64 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 68 >> 2] = f4, aA(e4, g6 + 80 | 0, g6 - -64 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 40 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 44 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 32 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 36 >> 2] = f4, f4 = E3[I7 + 12 >> 2], E3[g6 + 56 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 60 >> 2] = f4, f4 = E3[I7 + 4 >> 2], E3[g6 + 48 >> 2] = E3[I7 >> 2], E3[g6 + 52 >> 2] = f4, f4 = E3[I7 + 28 >> 2], E3[g6 + 40 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 44 >> 2] = f4, f4 = E3[I7 + 20 >> 2], E3[g6 + 32 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 36 >> 2] = f4, aA(e4, g6 + 48 | 0, g6 + 32 | 0), f4 = E3[g6 + 268 >> 2], E3[I7 + 24 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 28 >> 2] = f4, f4 = E3[g6 + 260 >> 2], E3[I7 + 16 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 20 >> 2] = f4, f4 = E3[g6 + 284 >> 2], E3[g6 + 24 >> 2] = E3[g6 + 280 >> 2], E3[g6 + 28 >> 2] = f4, f4 = E3[g6 + 276 >> 2], E3[g6 + 16 >> 2] = E3[g6 + 272 >> 2], E3[g6 + 20 >> 2] = f4, f4 = E3[I7 + 12 >> 2], E3[g6 + 8 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 12 >> 2] = f4, f4 = E3[I7 + 4 >> 2], E3[g6 >> 2] = E3[I7 >> 2], E3[g6 + 4 >> 2] = f4, aA(e4, g6 + 16 | 0, g6), e4 = E3[g6 + 268 >> 2], E3[I7 + 8 >> 2] = E3[g6 + 264 >> 2], E3[I7 + 12 >> 2] = e4, e4 = E3[g6 + 260 >> 2], E3[I7 >> 2] = E3[g6 + 256 >> 2], E3[I7 + 4 >> 2] = e4, E3[I7 + 12 >> 2] = (i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) ^ a4, E3[I7 + 8 >> 2] = (i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24) ^ D4, E3[I7 + 4 >> 2] = (i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24) ^ c4, E3[I7 >> 2] = (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24) ^ y4, E3[A8 >> 2] = (i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24) ^ o4, E3[I7 + 68 >> 2] = (i3[I7 + 68 | 0] | i3[I7 + 69 | 0] << 8 | i3[I7 + 70 | 0] << 16 | i3[I7 + 71 | 0] << 24) ^ Q4, E3[I7 + 72 >> 2] = (i3[I7 + 72 | 0] | i3[I7 + 73 | 0] << 8 | i3[I7 + 74 | 0] << 16 | i3[I7 + 75 | 0] << 24) ^ B4, E3[I7 + 76 >> 2] = (i3[I7 + 76 | 0] | i3[I7 + 77 | 0] << 8 | i3[I7 + 78 | 0] << 16 | i3[I7 + 79 | 0] << 24) ^ C4, r3 = g6 + 288 | 0; + } + function u3(A8, I7, g6, C4) { + var B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4 = 0, M4 = 0, N4 = 0, K4 = 0; + r3 = B4 = r3 - 240 | 0, E3[B4 + 200 >> 2] = 0, E3[B4 + 204 >> 2] = 0, E3[B4 + 192 >> 2] = 0, E3[B4 + 196 >> 2] = 0, TA(M4 = B4 + 192 | 0, I7, g6), N4 = i3[C4 + 16 | 0] | i3[C4 + 17 | 0] << 8 | i3[C4 + 18 | 0] << 16 | i3[C4 + 19 | 0] << 24, K4 = i3[0 | (I7 = C4 - -64 | 0)] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, S4 = i3[C4 + 80 | 0] | i3[C4 + 81 | 0] << 8 | i3[C4 + 82 | 0] << 16 | i3[C4 + 83 | 0] << 24, Q4 = i3[C4 + 32 | 0] | i3[C4 + 33 | 0] << 8 | i3[C4 + 34 | 0] << 16 | i3[C4 + 35 | 0] << 24, o4 = i3[C4 + 48 | 0] | i3[C4 + 49 | 0] << 8 | i3[C4 + 50 | 0] << 16 | i3[C4 + 51 | 0] << 24, c4 = i3[C4 + 20 | 0] | i3[C4 + 21 | 0] << 8 | i3[C4 + 22 | 0] << 16 | i3[C4 + 23 | 0] << 24, D4 = i3[C4 + 68 | 0] | i3[C4 + 69 | 0] << 8 | i3[C4 + 70 | 0] << 16 | i3[C4 + 71 | 0] << 24, a4 = i3[C4 + 84 | 0] | i3[C4 + 85 | 0] << 8 | i3[C4 + 86 | 0] << 16 | i3[C4 + 87 | 0] << 24, y4 = i3[C4 + 36 | 0] | i3[C4 + 37 | 0] << 8 | i3[C4 + 38 | 0] << 16 | i3[C4 + 39 | 0] << 24, f4 = i3[C4 + 52 | 0] | i3[C4 + 53 | 0] << 8 | i3[C4 + 54 | 0] << 16 | i3[C4 + 55 | 0] << 24, e4 = i3[C4 + 24 | 0] | i3[C4 + 25 | 0] << 8 | i3[C4 + 26 | 0] << 16 | i3[C4 + 27 | 0] << 24, w4 = i3[C4 + 72 | 0] | i3[C4 + 73 | 0] << 8 | i3[C4 + 74 | 0] << 16 | i3[C4 + 75 | 0] << 24, t4 = i3[C4 + 88 | 0] | i3[C4 + 89 | 0] << 8 | i3[C4 + 90 | 0] << 16 | i3[C4 + 91 | 0] << 24, h4 = i3[C4 + 40 | 0] | i3[C4 + 41 | 0] << 8 | i3[C4 + 42 | 0] << 16 | i3[C4 + 43 | 0] << 24, k4 = i3[C4 + 56 | 0] | i3[C4 + 57 | 0] << 8 | i3[C4 + 58 | 0] << 16 | i3[C4 + 59 | 0] << 24, n4 = E3[B4 + 192 >> 2], s4 = E3[B4 + 196 >> 2], F4 = E3[B4 + 200 >> 2], E3[B4 + 204 >> 2] = (i3[C4 + 44 | 0] | i3[C4 + 45 | 0] << 8 | i3[C4 + 46 | 0] << 16 | i3[C4 + 47 | 0] << 24) & (i3[C4 + 60 | 0] | i3[C4 + 61 | 0] << 8 | i3[C4 + 62 | 0] << 16 | i3[C4 + 63 | 0] << 24) ^ (i3[C4 + 28 | 0] | i3[C4 + 29 | 0] << 8 | i3[C4 + 30 | 0] << 16 | i3[C4 + 31 | 0] << 24) ^ (i3[C4 + 76 | 0] | i3[C4 + 77 | 0] << 8 | i3[C4 + 78 | 0] << 16 | i3[C4 + 79 | 0] << 24) ^ E3[B4 + 204 >> 2] ^ (i3[C4 + 92 | 0] | i3[C4 + 93 | 0] << 8 | i3[C4 + 94 | 0] << 16 | i3[C4 + 95 | 0] << 24), E3[B4 + 200 >> 2] = h4 & k4 ^ t4 ^ F4 ^ w4 ^ e4, E3[B4 + 196 >> 2] = y4 & f4 ^ a4 ^ s4 ^ D4 ^ c4, E3[B4 + 192 >> 2] = Q4 & o4 ^ N4 ^ K4 ^ S4 ^ n4, VA(g6 + M4 | 0, 0, 16 - g6 | 0), TA(A8, M4, g6), g6 = E3[B4 + 192 >> 2], M4 = E3[B4 + 196 >> 2], N4 = E3[B4 + 200 >> 2], K4 = E3[B4 + 204 >> 2], A8 = E3[C4 + 92 >> 2], E3[B4 + 232 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 236 >> 2] = A8, A8 = E3[C4 + 84 >> 2], E3[B4 + 224 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 228 >> 2] = A8, A8 = E3[C4 + 76 >> 2], E3[B4 + 184 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 188 >> 2] = A8, A8 = E3[I7 + 4 >> 2], E3[B4 + 176 >> 2] = E3[I7 >> 2], E3[B4 + 180 >> 2] = A8, A8 = E3[C4 + 92 >> 2], E3[B4 + 168 >> 2] = E3[C4 + 88 >> 2], E3[B4 + 172 >> 2] = A8, A8 = E3[C4 + 84 >> 2], E3[B4 + 160 >> 2] = E3[C4 + 80 >> 2], E3[B4 + 164 >> 2] = A8, aA(A8 = B4 + 208 | 0, B4 + 176 | 0, B4 + 160 | 0), S4 = E3[B4 + 220 >> 2], E3[C4 + 88 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 92 >> 2] = S4, S4 = E3[B4 + 212 >> 2], E3[C4 + 80 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 84 >> 2] = S4, S4 = E3[C4 + 60 >> 2], E3[B4 + 152 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 156 >> 2] = S4, S4 = E3[C4 + 52 >> 2], E3[B4 + 144 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 148 >> 2] = S4, S4 = E3[C4 + 76 >> 2], E3[B4 + 136 >> 2] = E3[C4 + 72 >> 2], E3[B4 + 140 >> 2] = S4, S4 = E3[I7 + 4 >> 2], E3[B4 + 128 >> 2] = E3[I7 >> 2], E3[B4 + 132 >> 2] = S4, aA(A8, B4 + 144 | 0, B4 + 128 | 0), S4 = E3[B4 + 220 >> 2], E3[C4 + 72 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 76 >> 2] = S4, S4 = E3[B4 + 212 >> 2], E3[I7 >> 2] = E3[B4 + 208 >> 2], E3[I7 + 4 >> 2] = S4, I7 = E3[C4 + 44 >> 2], E3[B4 + 120 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 124 >> 2] = I7, I7 = E3[C4 + 36 >> 2], E3[B4 + 112 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 116 >> 2] = I7, I7 = E3[C4 + 60 >> 2], E3[B4 + 104 >> 2] = E3[C4 + 56 >> 2], E3[B4 + 108 >> 2] = I7, I7 = E3[C4 + 52 >> 2], E3[B4 + 96 >> 2] = E3[C4 + 48 >> 2], E3[B4 + 100 >> 2] = I7, aA(A8, B4 + 112 | 0, B4 + 96 | 0), I7 = E3[B4 + 220 >> 2], E3[C4 + 56 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 60 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[C4 + 48 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 52 >> 2] = I7, I7 = E3[C4 + 28 >> 2], E3[B4 + 88 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 92 >> 2] = I7, I7 = E3[C4 + 20 >> 2], E3[B4 + 80 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 84 >> 2] = I7, I7 = E3[C4 + 44 >> 2], E3[B4 + 72 >> 2] = E3[C4 + 40 >> 2], E3[B4 + 76 >> 2] = I7, I7 = E3[C4 + 36 >> 2], E3[B4 + 64 >> 2] = E3[C4 + 32 >> 2], E3[B4 + 68 >> 2] = I7, aA(A8, B4 + 80 | 0, B4 - -64 | 0), I7 = E3[B4 + 220 >> 2], E3[C4 + 40 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 44 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[C4 + 32 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 36 >> 2] = I7, I7 = E3[C4 + 12 >> 2], E3[B4 + 56 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 60 >> 2] = I7, I7 = E3[C4 + 4 >> 2], E3[B4 + 48 >> 2] = E3[C4 >> 2], E3[B4 + 52 >> 2] = I7, I7 = E3[C4 + 28 >> 2], E3[B4 + 40 >> 2] = E3[C4 + 24 >> 2], E3[B4 + 44 >> 2] = I7, I7 = E3[C4 + 20 >> 2], E3[B4 + 32 >> 2] = E3[C4 + 16 >> 2], E3[B4 + 36 >> 2] = I7, aA(A8, B4 + 48 | 0, B4 + 32 | 0), I7 = E3[B4 + 220 >> 2], E3[C4 + 24 >> 2] = E3[B4 + 216 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[B4 + 212 >> 2], E3[C4 + 16 >> 2] = E3[B4 + 208 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[B4 + 236 >> 2], E3[B4 + 24 >> 2] = E3[B4 + 232 >> 2], E3[B4 + 28 >> 2] = I7, I7 = E3[B4 + 228 >> 2], E3[B4 + 16 >> 2] = E3[B4 + 224 >> 2], E3[B4 + 20 >> 2] = I7, I7 = E3[C4 + 12 >> 2], E3[B4 + 8 >> 2] = E3[C4 + 8 >> 2], E3[B4 + 12 >> 2] = I7, I7 = E3[C4 + 4 >> 2], E3[B4 >> 2] = E3[C4 >> 2], E3[B4 + 4 >> 2] = I7, aA(A8, B4 + 16 | 0, B4), A8 = E3[B4 + 208 >> 2], I7 = E3[B4 + 212 >> 2], S4 = E3[B4 + 216 >> 2], E3[C4 + 12 >> 2] = K4 ^ E3[B4 + 220 >> 2], E3[C4 + 8 >> 2] = S4 ^ N4, E3[C4 + 4 >> 2] = I7 ^ M4, E3[C4 >> 2] = A8 ^ g6, r3 = B4 + 240 | 0; + } + function m3(A8, I7, g6) { + var B4, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + r3 = B4 = r3 + -64 | 0; + A: { + if ((g6 - 65 & 255) >>> 0 > 191) { + if (c4 = -1, !(i3[A8 + 80 | 0] | i3[A8 + 81 | 0] << 8 | i3[A8 + 82 | 0] << 16 | i3[A8 + 83 | 0] << 24 | i3[A8 + 84 | 0] | i3[A8 + 85 | 0] << 8 | i3[A8 + 86 | 0] << 16 | i3[A8 + 87 | 0] << 24)) { + if ((D4 = i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) >>> 0 >= 129) { + if (a4 = o4 = i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24, o4 = (D4 = 128 + (c4 = i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) | 0) >>> 0 < 128 ? o4 + 1 | 0 : o4, C3[A8 + 64 | 0] = D4, C3[A8 + 65 | 0] = D4 >>> 8, C3[A8 + 66 | 0] = D4 >>> 16, C3[A8 + 67 | 0] = D4 >>> 24, C3[A8 + 68 | 0] = o4, C3[A8 + 69 | 0] = o4 >>> 8, C3[A8 + 70 | 0] = o4 >>> 16, C3[A8 + 71 | 0] = o4 >>> 24, o4 = i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24, o4 = (y4 = c4 = -1 == (0 | a4) & c4 >>> 0 > 4294967167) >>> 0 > (c4 = c4 + (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) | 0) >>> 0 ? o4 + 1 | 0 : o4, C3[A8 + 72 | 0] = c4, C3[A8 + 73 | 0] = c4 >>> 8, C3[A8 + 74 | 0] = c4 >>> 16, C3[A8 + 75 | 0] = c4 >>> 24, C3[A8 + 76 | 0] = o4, C3[A8 + 77 | 0] = o4 >>> 8, C3[A8 + 78 | 0] = o4 >>> 16, C3[A8 + 79 | 0] = o4 >>> 24, h3(A8, o4 = A8 + 96 | 0), c4 = (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) - 128 | 0, C3[A8 + 352 | 0] = c4, C3[A8 + 353 | 0] = c4 >>> 8, C3[A8 + 354 | 0] = c4 >>> 16, C3[A8 + 355 | 0] = c4 >>> 24, c4 >>> 0 >= 129) break A; + TA(o4, A8 + 224 | 0, c4), D4 = i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24; + } + c4 = y4 = i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24, c4 = (a4 = D4 + (o4 = i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) | 0) >>> 0 < D4 >>> 0 ? c4 + 1 | 0 : c4, C3[A8 + 64 | 0] = a4, C3[A8 + 65 | 0] = a4 >>> 8, C3[A8 + 66 | 0] = a4 >>> 16, C3[A8 + 67 | 0] = a4 >>> 24, C3[A8 + 68 | 0] = c4, C3[A8 + 69 | 0] = c4 >>> 8, C3[A8 + 70 | 0] = c4 >>> 16, C3[A8 + 71 | 0] = c4 >>> 24, c4 = (0 | c4) == (0 | y4) & o4 >>> 0 > a4 >>> 0 | c4 >>> 0 < y4 >>> 0, o4 = i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24, o4 = (y4 = c4) >>> 0 > (c4 = c4 + (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) | 0) >>> 0 ? o4 + 1 | 0 : o4, C3[A8 + 72 | 0] = c4, C3[A8 + 73 | 0] = c4 >>> 8, C3[A8 + 74 | 0] = c4 >>> 16, C3[A8 + 75 | 0] = c4 >>> 24, C3[A8 + 76 | 0] = o4, C3[A8 + 77 | 0] = o4 >>> 8, C3[A8 + 78 | 0] = o4 >>> 16, C3[A8 + 79 | 0] = o4 >>> 24, i3[A8 + 356 | 0] && (C3[A8 + 88 | 0] = 255, C3[A8 + 89 | 0] = 255, C3[A8 + 90 | 0] = 255, C3[A8 + 91 | 0] = 255, C3[A8 + 92 | 0] = 255, C3[A8 + 93 | 0] = 255, C3[A8 + 94 | 0] = 255, C3[A8 + 95 | 0] = 255), C3[A8 + 80 | 0] = 255, C3[A8 + 81 | 0] = 255, C3[A8 + 82 | 0] = 255, C3[A8 + 83 | 0] = 255, C3[A8 + 84 | 0] = 255, C3[A8 + 85 | 0] = 255, C3[A8 + 86 | 0] = 255, C3[A8 + 87 | 0] = 255, VA((c4 = A8 + 96 | 0) + D4 | 0, 0, 256 - D4 | 0), h3(A8, c4), o4 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[B4 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[B4 + 4 >> 2] = o4, o4 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[B4 + 8 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[B4 + 12 >> 2] = o4, o4 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[B4 + 16 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[B4 + 20 >> 2] = o4, o4 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[B4 + 24 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[B4 + 28 >> 2] = o4, o4 = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[B4 + 32 >> 2] = i3[A8 + 32 | 0] | i3[A8 + 33 | 0] << 8 | i3[A8 + 34 | 0] << 16 | i3[A8 + 35 | 0] << 24, E3[B4 + 36 >> 2] = o4, o4 = i3[A8 + 44 | 0] | i3[A8 + 45 | 0] << 8 | i3[A8 + 46 | 0] << 16 | i3[A8 + 47 | 0] << 24, E3[B4 + 40 >> 2] = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[B4 + 44 >> 2] = o4, o4 = i3[A8 + 52 | 0] | i3[A8 + 53 | 0] << 8 | i3[A8 + 54 | 0] << 16 | i3[A8 + 55 | 0] << 24, E3[B4 + 48 >> 2] = i3[A8 + 48 | 0] | i3[A8 + 49 | 0] << 8 | i3[A8 + 50 | 0] << 16 | i3[A8 + 51 | 0] << 24, E3[B4 + 52 >> 2] = o4, o4 = i3[A8 + 60 | 0] | i3[A8 + 61 | 0] << 8 | i3[A8 + 62 | 0] << 16 | i3[A8 + 63 | 0] << 24, E3[B4 + 56 >> 2] = i3[A8 + 56 | 0] | i3[A8 + 57 | 0] << 8 | i3[A8 + 58 | 0] << 16 | i3[A8 + 59 | 0] << 24, E3[B4 + 60 >> 2] = o4, TA(I7, B4, g6), MI(A8, 64), MI(c4, 256), c4 = 0; + } + return r3 = B4 - -64 | 0, c4; + } + iI(), Q3(); + } + f3(1268, 1130, 306, 1074), Q3(); + } + function q3(A8, I7) { + var g6, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0; + for (r3 = g6 = r3 - 320 | 0, V(B4 = A8 + 40 | 0, I7), E3[A8 + 84 >> 2] = 0, E3[A8 + 88 >> 2] = 0, E3[A8 + 80 >> 2] = 1, E3[A8 + 92 >> 2] = 0, E3[A8 + 96 >> 2] = 0, E3[A8 + 100 >> 2] = 0, E3[A8 + 104 >> 2] = 0, E3[A8 + 108 >> 2] = 0, E3[A8 + 112 >> 2] = 0, E3[A8 + 116 >> 2] = 0, U3(p4 = g6 + 240 | 0, B4), M3(K4 = g6 + 192 | 0, p4, 1328), H4 = -1, Q4 = E3[g6 + 240 >> 2] - 1 | 0, E3[g6 + 240 >> 2] = Q4, E3[g6 + 192 >> 2] = E3[g6 + 192 >> 2] + 1, o4 = E3[g6 + 244 >> 2], c4 = E3[g6 + 248 >> 2], D4 = E3[g6 + 252 >> 2], a4 = E3[g6 + 256 >> 2], y4 = E3[g6 + 260 >> 2], f4 = E3[g6 + 264 >> 2], e4 = E3[g6 + 268 >> 2], w4 = E3[g6 + 272 >> 2], t4 = E3[g6 + 276 >> 2], U3(_4 = g6 + 144 | 0, K4), M3(_4, _4, K4), U3(A8, _4), M3(A8, A8, K4), M3(A8, A8, p4), r3 = S4 = r3 - 144 | 0, U3(N4 = S4 + 96 | 0, A8), U3(F4 = S4 + 48 | 0, N4), U3(F4, F4), M3(F4, A8, F4), M3(N4, N4, F4), U3(N4, N4), M3(N4, F4, N4), U3(F4, N4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(N4, F4, N4), U3(F4, N4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(F4, F4, N4), U3(S4, F4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), U3(S4, S4), M3(F4, S4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(N4, F4, N4), U3(F4, N4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(F4, F4, N4), U3(S4, F4), F4 = 1; U3(S4, S4), 100 != (0 | (F4 = F4 + 1 | 0)); ) ; + M3(F4 = S4 + 48 | 0, S4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), U3(F4, F4), M3(N4 = S4 + 96 | 0, F4, N4), U3(N4, N4), U3(N4, N4), M3(A8, N4, A8), r3 = S4 + 144 | 0, M3(A8, A8, _4), M3(A8, A8, p4), U3(F4 = g6 + 96 | 0, A8), M3(F4, F4, K4), F4 = E3[g6 + 132 >> 2], E3[g6 + 84 >> 2] = F4 - t4, S4 = E3[g6 + 128 >> 2], E3[g6 + 80 >> 2] = S4 - w4, N4 = E3[g6 + 124 >> 2], E3[g6 + 76 >> 2] = N4 - e4, K4 = E3[g6 + 120 >> 2], E3[g6 + 72 >> 2] = K4 - f4, _4 = E3[g6 + 116 >> 2], E3[g6 + 68 >> 2] = _4 - y4, p4 = E3[g6 + 112 >> 2], E3[g6 + 64 >> 2] = p4 - a4, h4 = E3[g6 + 108 >> 2], E3[g6 + 60 >> 2] = h4 - D4, k4 = E3[g6 + 104 >> 2], E3[g6 + 56 >> 2] = k4 - c4, n4 = E3[g6 + 100 >> 2], E3[g6 + 52 >> 2] = n4 - o4, s4 = E3[g6 + 96 >> 2], E3[g6 + 48 >> 2] = s4 - Q4, eA(g6, g6 + 48 | 0); + A: { + if (!SA(g6, 32)) { + if (E3[g6 + 36 >> 2] = F4 + t4, E3[g6 + 32 >> 2] = S4 + w4, E3[g6 + 28 >> 2] = N4 + e4, E3[g6 + 24 >> 2] = K4 + f4, E3[g6 + 20 >> 2] = _4 + y4, E3[g6 + 16 >> 2] = p4 + a4, E3[g6 + 12 >> 2] = D4 + h4, E3[g6 + 8 >> 2] = c4 + k4, E3[g6 + 4 >> 2] = o4 + n4, E3[g6 >> 2] = Q4 + s4, eA(F4 = g6 + 288 | 0, g6), !SA(F4, 32)) break A; + M3(A8, A8, 1376); + } + eA(g6 + 288 | 0, A8), (1 & C3[g6 + 288 | 0]) == (i3[I7 + 31 | 0] >>> 7 | 0) && (E3[A8 >> 2] = 0 - E3[A8 >> 2], E3[A8 + 36 >> 2] = 0 - E3[A8 + 36 >> 2], E3[A8 + 32 >> 2] = 0 - E3[A8 + 32 >> 2], E3[A8 + 28 >> 2] = 0 - E3[A8 + 28 >> 2], E3[A8 + 24 >> 2] = 0 - E3[A8 + 24 >> 2], E3[A8 + 20 >> 2] = 0 - E3[A8 + 20 >> 2], E3[A8 + 16 >> 2] = 0 - E3[A8 + 16 >> 2], E3[A8 + 12 >> 2] = 0 - E3[A8 + 12 >> 2], E3[A8 + 8 >> 2] = 0 - E3[A8 + 8 >> 2], E3[A8 + 4 >> 2] = 0 - E3[A8 + 4 >> 2]), M3(A8 + 120 | 0, A8, B4), H4 = 0; + } + return r3 = g6 + 320 | 0, H4; + } + function l2(A8, I7, g6) { + var B4, Q4, E4, o4, c4, D4, a4, y4, f4, e4, w4, r4, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0; + for (s4 = 1634760805, h4 = B4 = i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24, F4 = Q4 = i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24, S4 = E4 = i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24, M4 = o4 = i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24, p4 = 857760878, N4 = c4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, k4 = D4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, _4 = a4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, G4 = y4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, I7 = 2036477234, n4 = f4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, t4 = 1797285236, J4 = e4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, H4 = w4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, g6 = r4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24; K4 = gI(h4 + p4 | 0, 7) ^ G4, Y4 = gI(K4 + p4 | 0, 9) ^ H4, M4 = gI(g6 + s4 | 0, 7) ^ M4, U4 = gI(M4 + s4 | 0, 9) ^ _4, b4 = gI(U4 + M4 | 0, 13) ^ g6, S4 = gI(t4 + n4 | 0, 7) ^ S4, d4 = gI(S4 + t4 | 0, 9) ^ k4, _4 = gI(S4 + d4 | 0, 13) ^ n4, n4 = gI(d4 + _4 | 0, 18) ^ t4, k4 = gI(I7 + N4 | 0, 7) ^ J4, g6 = b4 ^ gI(n4 + k4 | 0, 7), H4 = Y4 ^ gI(g6 + n4 | 0, 9), J4 = gI(g6 + H4 | 0, 13) ^ k4, t4 = gI(H4 + J4 | 0, 18) ^ n4, F4 = gI(I7 + k4 | 0, 9) ^ F4, N4 = gI(F4 + k4 | 0, 13) ^ N4, I7 = gI(N4 + F4 | 0, 18) ^ I7, n4 = gI(I7 + K4 | 0, 7) ^ _4, _4 = gI(n4 + I7 | 0, 9) ^ U4, G4 = gI(n4 + _4 | 0, 13) ^ K4, I7 = gI(_4 + G4 | 0, 18) ^ I7, K4 = gI(K4 + Y4 | 0, 13) ^ h4, h4 = gI(K4 + Y4 | 0, 18) ^ p4, N4 = gI(h4 + M4 | 0, 7) ^ N4, k4 = gI(N4 + h4 | 0, 9) ^ d4, M4 = gI(k4 + N4 | 0, 13) ^ M4, p4 = gI(k4 + M4 | 0, 18) ^ h4, s4 = gI(U4 + b4 | 0, 18) ^ s4, h4 = gI(s4 + S4 | 0, 7) ^ K4, F4 = gI(h4 + s4 | 0, 9) ^ F4, S4 = gI(h4 + F4 | 0, 13) ^ S4, s4 = gI(F4 + S4 | 0, 18) ^ s4, K4 = P4 >>> 0 < 18, P4 = P4 + 2 | 0, K4; ) ; + t4 = t4 + 1797285236 | 0, C3[A8 + 60 | 0] = t4, C3[A8 + 61 | 0] = t4 >>> 8, C3[A8 + 62 | 0] = t4 >>> 16, C3[A8 + 63 | 0] = t4 >>> 24, t4 = J4 + e4 | 0, C3[A8 + 56 | 0] = t4, C3[A8 + 57 | 0] = t4 >>> 8, C3[A8 + 58 | 0] = t4 >>> 16, C3[A8 + 59 | 0] = t4 >>> 24, t4 = H4 + w4 | 0, C3[A8 + 52 | 0] = t4, C3[A8 + 53 | 0] = t4 >>> 8, C3[A8 + 54 | 0] = t4 >>> 16, C3[A8 + 55 | 0] = t4 >>> 24, g6 = g6 + r4 | 0, C3[A8 + 48 | 0] = g6, C3[A8 + 49 | 0] = g6 >>> 8, C3[A8 + 50 | 0] = g6 >>> 16, C3[A8 + 51 | 0] = g6 >>> 24, g6 = n4 + f4 | 0, C3[A8 + 44 | 0] = g6, C3[A8 + 45 | 0] = g6 >>> 8, C3[A8 + 46 | 0] = g6 >>> 16, C3[A8 + 47 | 0] = g6 >>> 24, I7 = I7 + 2036477234 | 0, C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, I7 = G4 + y4 | 0, C3[A8 + 36 | 0] = I7, C3[A8 + 37 | 0] = I7 >>> 8, C3[A8 + 38 | 0] = I7 >>> 16, C3[A8 + 39 | 0] = I7 >>> 24, I7 = _4 + a4 | 0, C3[A8 + 32 | 0] = I7, C3[A8 + 33 | 0] = I7 >>> 8, C3[A8 + 34 | 0] = I7 >>> 16, C3[A8 + 35 | 0] = I7 >>> 24, I7 = k4 + D4 | 0, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = N4 + c4 | 0, C3[A8 + 24 | 0] = I7, C3[A8 + 25 | 0] = I7 >>> 8, C3[A8 + 26 | 0] = I7 >>> 16, C3[A8 + 27 | 0] = I7 >>> 24, I7 = p4 + 857760878 | 0, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = M4 + o4 | 0, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, I7 = S4 + E4 | 0, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = F4 + Q4 | 0, C3[A8 + 8 | 0] = I7, C3[A8 + 9 | 0] = I7 >>> 8, C3[A8 + 10 | 0] = I7 >>> 16, C3[A8 + 11 | 0] = I7 >>> 24, I7 = h4 + B4 | 0, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = s4 + 1634760805 | 0, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24; + } + function z(A8, I7, g6, C4) { + var B4 = 0, Q4 = 0, o4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0; + if (h4 = E3[A8 + 36 >> 2], w4 = E3[A8 + 32 >> 2], r4 = E3[A8 + 28 >> 2], f4 = E3[A8 + 24 >> 2], e4 = E3[A8 + 20 >> 2], !C4 & g6 >>> 0 >= 16 | C4) for (p4 = !i3[A8 + 80 | 0] << 24, n4 = E3[A8 + 4 >> 2], H4 = c3(n4, 5), F4 = E3[A8 + 8 >> 2], K4 = c3(F4, 5), M4 = E3[A8 + 12 >> 2], N4 = c3(M4, 5), _4 = E3[A8 + 16 >> 2], S4 = c3(_4, 5), s4 = E3[A8 >> 2]; B4 = PA(o4 = ((i3[I7 + 3 | 0] | i3[I7 + 4 | 0] << 8 | i3[I7 + 5 | 0] << 16 | i3[I7 + 6 | 0] << 24) >>> 2 & 67108863) + f4 | 0, 0, M4, 0), a4 = t3, e4 = (D4 = PA(f4 = (67108863 & (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24)) + e4 | 0, 0, _4, 0)) + B4 | 0, B4 = t3 + a4 | 0, B4 = D4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4, a4 = PA(r4 = ((i3[I7 + 6 | 0] | i3[I7 + 7 | 0] << 8 | i3[I7 + 8 | 0] << 16 | i3[I7 + 9 | 0] << 24) >>> 4 & 67108863) + r4 | 0, 0, F4, 0), B4 = t3 + B4 | 0, B4 = a4 >>> 0 > (e4 = a4 + e4 | 0) >>> 0 ? B4 + 1 | 0 : B4, a4 = PA(w4 = ((i3[I7 + 9 | 0] | i3[I7 + 10 | 0] << 8 | i3[I7 + 11 | 0] << 16 | i3[I7 + 12 | 0] << 24) >>> 6 | 0) + w4 | 0, 0, n4, 0), B4 = t3 + B4 | 0, B4 = a4 >>> 0 > (e4 = a4 + e4 | 0) >>> 0 ? B4 + 1 | 0 : B4, a4 = PA(h4 = h4 + p4 + ((i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24) >>> 8) | 0, 0, s4, 0), B4 = t3 + B4 | 0, G4 = e4 = a4 + e4 | 0, e4 = a4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4, B4 = PA(o4, 0, F4, 0), a4 = t3, D4 = PA(f4, 0, M4, 0), Q4 = t3 + a4 | 0, Q4 = (B4 = D4 + B4 | 0) >>> 0 < D4 >>> 0 ? Q4 + 1 | 0 : Q4, a4 = (D4 = PA(r4, 0, n4, 0)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = D4 >>> 0 > a4 >>> 0 ? B4 + 1 | 0 : B4, D4 = PA(w4, 0, s4, 0), B4 = t3 + B4 | 0, B4 = D4 >>> 0 > (a4 = D4 + a4 | 0) >>> 0 ? B4 + 1 | 0 : B4, D4 = PA(h4, 0, S4, 0), B4 = t3 + B4 | 0, J4 = a4 = D4 + a4 | 0, a4 = D4 >>> 0 > a4 >>> 0 ? B4 + 1 | 0 : B4, B4 = PA(o4, 0, n4, 0), y4 = t3, D4 = (Q4 = PA(f4, 0, F4, 0)) + B4 | 0, B4 = t3 + y4 | 0, B4 = Q4 >>> 0 > D4 >>> 0 ? B4 + 1 | 0 : B4, y4 = PA(r4, 0, s4, 0), Q4 = t3 + B4 | 0, Q4 = (D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, y4 = PA(w4, 0, S4, 0), B4 = t3 + Q4 | 0, B4 = (D4 = y4 + D4 | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, y4 = PA(h4, 0, N4, 0), B4 = t3 + B4 | 0, Y4 = D4 = y4 + D4 | 0, D4 = D4 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, B4 = PA(o4, 0, s4, 0), Q4 = t3, y4 = (k4 = PA(f4, 0, n4, 0)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = y4 >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = PA(r4, 0, S4, 0), B4 = t3 + B4 | 0, B4 = Q4 >>> 0 > (y4 = Q4 + y4 | 0) >>> 0 ? B4 + 1 | 0 : B4, k4 = PA(w4, 0, N4, 0), Q4 = t3 + B4 | 0, Q4 = (y4 = k4 + y4 | 0) >>> 0 < k4 >>> 0 ? Q4 + 1 | 0 : Q4, k4 = PA(h4, 0, K4, 0), B4 = t3 + Q4 | 0, B4 = (y4 = k4 + y4 | 0) >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, k4 = y4, y4 = B4, B4 = PA(o4, 0, S4, 0), Q4 = t3, o4 = (f4 = PA(f4, 0, s4, 0)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = o4 >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, f4 = PA(r4, 0, N4, 0), B4 = t3 + B4 | 0, B4 = (o4 = f4 + o4 | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, f4 = PA(w4, 0, K4, 0), B4 = t3 + B4 | 0, B4 = (o4 = f4 + o4 | 0) >>> 0 < f4 >>> 0 ? B4 + 1 | 0 : B4, f4 = PA(h4, 0, H4, 0), Q4 = t3 + B4 | 0, Q4 = (o4 = f4 + o4 | 0) >>> 0 < f4 >>> 0 ? Q4 + 1 | 0 : Q4, f4 = o4, B4 = y4, B4 = (o4 = (r4 = (67108863 & Q4) << 6 | o4 >>> 26) + k4 | 0) >>> 0 < r4 >>> 0 ? B4 + 1 | 0 : B4, r4 = o4, w4 = (67108863 & B4) << 6 | o4 >>> 26, B4 = D4, B4 = (o4 = w4 + Y4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, w4 = o4, Q4 = a4, h4 = B4 = (o4 = (67108863 & B4) << 6 | o4 >>> 26) + J4 | 0, a4 = (67108863 & (Q4 = B4 >>> 0 < o4 >>> 0 ? Q4 + 1 | 0 : Q4)) << 6 | B4 >>> 26, B4 = e4, f4 = (67108863 & r4) + ((B4 = c3((67108863 & ((o4 = a4 + G4 | 0) >>> 0 < a4 >>> 0 ? B4 + 1 : B4)) << 6 | o4 >>> 26, 5) + (67108863 & f4) | 0) >>> 26 | 0) | 0, r4 = 67108863 & w4, w4 = 67108863 & h4, h4 = 67108863 & o4, e4 = 67108863 & B4, I7 = I7 + 16 | 0, !(C4 = C4 - (g6 >>> 0 < 16) | 0) & (g6 = g6 - 16 | 0) >>> 0 > 15 | C4; ) ; + E3[A8 + 20 >> 2] = e4, E3[A8 + 36 >> 2] = h4, E3[A8 + 32 >> 2] = w4, E3[A8 + 28 >> 2] = r4, E3[A8 + 24 >> 2] = f4; + } + function j(A8, I7, g6, B4) { + A8 |= 0, I7 |= 0; + var E4 = 0; + return E4 = -1, (B4 |= 0) - 65 >>> 0 < 4294967232 | (g6 |= 0) >>> 0 > 64 || (g6 && I7 ? (r3 = E4 = r3 - 128 | 0, !I7 | ((B4 &= 255) - 65 & 255) >>> 0 <= 191 | ((g6 &= 255) - 65 & 255) >>> 0 <= 191 ? (iI(), Q3()) : (VA(A8 - -64 | 0, 0, 293), C3[A8 + 56 | 0] = 121, C3[A8 + 57 | 0] = 33, C3[A8 + 58 | 0] = 126, C3[A8 + 59 | 0] = 19, C3[A8 + 60 | 0] = 25, C3[A8 + 61 | 0] = 205, C3[A8 + 62 | 0] = 224, C3[A8 + 63 | 0] = 91, C3[A8 + 48 | 0] = 107, C3[A8 + 49 | 0] = 189, C3[A8 + 50 | 0] = 65, C3[A8 + 51 | 0] = 251, C3[A8 + 52 | 0] = 171, C3[A8 + 53 | 0] = 217, C3[A8 + 54 | 0] = 131, C3[A8 + 55 | 0] = 31, C3[A8 + 40 | 0] = 31, C3[A8 + 41 | 0] = 108, C3[A8 + 42 | 0] = 62, C3[A8 + 43 | 0] = 43, C3[A8 + 44 | 0] = 140, C3[A8 + 45 | 0] = 104, C3[A8 + 46 | 0] = 5, C3[A8 + 47 | 0] = 155, C3[A8 + 32 | 0] = 209, C3[A8 + 33 | 0] = 130, C3[A8 + 34 | 0] = 230, C3[A8 + 35 | 0] = 173, C3[A8 + 36 | 0] = 127, C3[A8 + 37 | 0] = 82, C3[A8 + 38 | 0] = 14, C3[A8 + 39 | 0] = 81, C3[A8 + 24 | 0] = 241, C3[A8 + 25 | 0] = 54, C3[A8 + 26 | 0] = 29, C3[A8 + 27 | 0] = 95, C3[A8 + 28 | 0] = 58, C3[A8 + 29 | 0] = 245, C3[A8 + 30 | 0] = 79, C3[A8 + 31 | 0] = 165, C3[A8 + 16 | 0] = 43, C3[A8 + 17 | 0] = 248, C3[A8 + 18 | 0] = 148, C3[A8 + 19 | 0] = 254, C3[A8 + 20 | 0] = 114, C3[A8 + 21 | 0] = 243, C3[A8 + 22 | 0] = 110, C3[A8 + 23 | 0] = 60, C3[A8 + 8 | 0] = 59, C3[A8 + 9 | 0] = 167, C3[A8 + 10 | 0] = 202, C3[A8 + 11 | 0] = 132, C3[A8 + 12 | 0] = 133, C3[A8 + 13 | 0] = 174, C3[A8 + 14 | 0] = 103, C3[A8 + 15 | 0] = 187, B4 = -222443256 ^ (g6 << 8 | B4), C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, B4 = g6 >>> 24 ^ 1779033703, C3[A8 + 4 | 0] = B4, C3[A8 + 5 | 0] = B4 >>> 8, C3[A8 + 6 | 0] = B4 >>> 16, C3[A8 + 7 | 0] = B4 >>> 24, g6 = TA(VA(E4, 0, 128), I7, g6), TA(A8 + 96 | 0, g6, 128), I7 = 128 + (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) | 0, C3[A8 + 352 | 0] = I7, C3[A8 + 353 | 0] = I7 >>> 8, C3[A8 + 354 | 0] = I7 >>> 16, C3[A8 + 355 | 0] = I7 >>> 24, MI(g6, 128), r3 = g6 + 128 | 0)) : (((I7 = 255 & B4) - 65 & 255) >>> 0 <= 191 && (iI(), Q3()), VA(A8 - -64 | 0, 0, 293), C3[A8 + 56 | 0] = 121, C3[A8 + 57 | 0] = 33, C3[A8 + 58 | 0] = 126, C3[A8 + 59 | 0] = 19, C3[A8 + 60 | 0] = 25, C3[A8 + 61 | 0] = 205, C3[A8 + 62 | 0] = 224, C3[A8 + 63 | 0] = 91, C3[A8 + 48 | 0] = 107, C3[A8 + 49 | 0] = 189, C3[A8 + 50 | 0] = 65, C3[A8 + 51 | 0] = 251, C3[A8 + 52 | 0] = 171, C3[A8 + 53 | 0] = 217, C3[A8 + 54 | 0] = 131, C3[A8 + 55 | 0] = 31, C3[A8 + 40 | 0] = 31, C3[A8 + 41 | 0] = 108, C3[A8 + 42 | 0] = 62, C3[A8 + 43 | 0] = 43, C3[A8 + 44 | 0] = 140, C3[A8 + 45 | 0] = 104, C3[A8 + 46 | 0] = 5, C3[A8 + 47 | 0] = 155, C3[A8 + 32 | 0] = 209, C3[A8 + 33 | 0] = 130, C3[A8 + 34 | 0] = 230, C3[A8 + 35 | 0] = 173, C3[A8 + 36 | 0] = 127, C3[A8 + 37 | 0] = 82, C3[A8 + 38 | 0] = 14, C3[A8 + 39 | 0] = 81, C3[A8 + 24 | 0] = 241, C3[A8 + 25 | 0] = 54, C3[A8 + 26 | 0] = 29, C3[A8 + 27 | 0] = 95, C3[A8 + 28 | 0] = 58, C3[A8 + 29 | 0] = 245, C3[A8 + 30 | 0] = 79, C3[A8 + 31 | 0] = 165, C3[A8 + 16 | 0] = 43, C3[A8 + 17 | 0] = 248, C3[A8 + 18 | 0] = 148, C3[A8 + 19 | 0] = 254, C3[A8 + 20 | 0] = 114, C3[A8 + 21 | 0] = 243, C3[A8 + 22 | 0] = 110, C3[A8 + 23 | 0] = 60, C3[A8 + 8 | 0] = 59, C3[A8 + 9 | 0] = 167, C3[A8 + 10 | 0] = 202, C3[A8 + 11 | 0] = 132, C3[A8 + 12 | 0] = 133, C3[A8 + 13 | 0] = 174, C3[A8 + 14 | 0] = 103, C3[A8 + 15 | 0] = 187, I7 ^= -222443256, C3[0 | A8] = I7, C3[A8 + 1 | 0] = I7 >>> 8, C3[A8 + 2 | 0] = I7 >>> 16, C3[A8 + 3 | 0] = I7 >>> 24, C3[A8 + 4 | 0] = 103, C3[A8 + 5 | 0] = 230, C3[A8 + 6 | 0] = 9, C3[A8 + 7 | 0] = 106), E4 = 0), 0 | E4; + } + function X(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0; + w4 = E3[I7 + 4 >> 2], e4 = E3[I7 + 44 >> 2], t4 = E3[I7 + 8 >> 2], h4 = E3[I7 + 48 >> 2], k4 = E3[I7 + 12 >> 2], n4 = E3[I7 + 52 >> 2], s4 = E3[I7 + 16 >> 2], F4 = E3[I7 + 56 >> 2], S4 = E3[I7 + 20 >> 2], N4 = E3[I7 + 60 >> 2], K4 = E3[I7 + 24 >> 2], _4 = E3[(r4 = I7 - -64 | 0) >> 2], p4 = E3[I7 + 28 >> 2], H4 = E3[I7 + 68 >> 2], G4 = E3[I7 + 32 >> 2], J4 = E3[I7 + 72 >> 2], Y4 = E3[I7 + 36 >> 2], U4 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = Y4 + U4, E3[A8 + 32 >> 2] = G4 + J4, E3[A8 + 28 >> 2] = p4 + H4, E3[A8 + 24 >> 2] = K4 + _4, E3[A8 + 20 >> 2] = S4 + N4, E3[A8 + 16 >> 2] = s4 + F4, E3[A8 + 12 >> 2] = k4 + n4, E3[A8 + 8 >> 2] = t4 + h4, E3[A8 + 4 >> 2] = e4 + w4, e4 = E3[I7 + 4 >> 2], t4 = E3[I7 + 44 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 48 >> 2], n4 = E3[I7 + 12 >> 2], s4 = E3[I7 + 52 >> 2], F4 = E3[I7 + 16 >> 2], S4 = E3[I7 + 56 >> 2], N4 = E3[I7 + 20 >> 2], K4 = E3[I7 + 60 >> 2], _4 = E3[I7 + 24 >> 2], r4 = E3[r4 >> 2], w4 = E3[I7 + 28 >> 2], p4 = E3[I7 + 68 >> 2], H4 = E3[I7 + 32 >> 2], G4 = E3[I7 + 72 >> 2], J4 = E3[I7 >> 2], Y4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = G4 - H4, E3[A8 + 68 >> 2] = p4 - w4, E3[(w4 = A8 - -64 | 0) >> 2] = r4 - _4, E3[A8 + 60 >> 2] = K4 - N4, E3[A8 + 56 >> 2] = S4 - F4, E3[A8 + 52 >> 2] = s4 - n4, E3[A8 + 48 >> 2] = k4 - h4, E3[A8 + 44 >> 2] = t4 - e4, E3[A8 + 40 >> 2] = Y4 - J4, M3(A8 + 80 | 0, A8, g6), M3(e4 = A8 + 40 | 0, e4, g6 + 40 | 0), M3(A8 + 120 | 0, g6 + 120 | 0, I7 + 120 | 0), M3(A8, I7 + 80 | 0, g6 + 80 | 0), Y4 = E3[A8 + 4 >> 2], U4 = E3[A8 + 8 >> 2], Q4 = E3[A8 + 12 >> 2], i4 = E3[A8 + 16 >> 2], o4 = E3[A8 + 20 >> 2], c4 = E3[A8 + 24 >> 2], D4 = E3[A8 + 28 >> 2], a4 = E3[A8 + 32 >> 2], y4 = E3[A8 + 36 >> 2], I7 = E3[A8 + 44 >> 2], g6 = E3[A8 + 84 >> 2], e4 = E3[A8 + 48 >> 2], t4 = E3[A8 + 88 >> 2], h4 = E3[A8 + 52 >> 2], k4 = E3[A8 + 92 >> 2], n4 = E3[A8 + 56 >> 2], s4 = E3[A8 + 96 >> 2], F4 = E3[A8 + 60 >> 2], S4 = E3[A8 + 100 >> 2], N4 = E3[w4 >> 2], K4 = E3[A8 + 104 >> 2], r4 = E3[A8 + 68 >> 2], _4 = E3[A8 + 108 >> 2], p4 = E3[A8 + 72 >> 2], H4 = E3[A8 + 112 >> 2], f4 = E3[A8 >> 2], G4 = E3[A8 + 40 >> 2], J4 = E3[A8 + 80 >> 2], C4 = E3[A8 + 76 >> 2], B4 = E3[A8 + 116 >> 2], E3[A8 + 76 >> 2] = C4 + B4, E3[A8 + 72 >> 2] = p4 + H4, E3[A8 + 68 >> 2] = r4 + _4, E3[w4 >> 2] = N4 + K4, E3[A8 + 60 >> 2] = F4 + S4, E3[A8 + 56 >> 2] = n4 + s4, E3[A8 + 52 >> 2] = h4 + k4, E3[A8 + 48 >> 2] = e4 + t4, E3[A8 + 44 >> 2] = I7 + g6, E3[A8 + 40 >> 2] = G4 + J4, E3[A8 + 36 >> 2] = B4 - C4, E3[A8 + 32 >> 2] = H4 - p4, E3[A8 + 28 >> 2] = _4 - r4, E3[A8 + 24 >> 2] = K4 - N4, E3[A8 + 20 >> 2] = S4 - F4, E3[A8 + 16 >> 2] = s4 - n4, E3[A8 + 12 >> 2] = k4 - h4, E3[A8 + 8 >> 2] = t4 - e4, E3[A8 + 4 >> 2] = g6 - I7, E3[A8 >> 2] = J4 - G4, I7 = y4 << 1, g6 = E3[A8 + 156 >> 2], E3[A8 + 156 >> 2] = I7 - g6, w4 = a4 << 1, e4 = E3[A8 + 152 >> 2], E3[A8 + 152 >> 2] = w4 - e4, t4 = D4 << 1, h4 = E3[A8 + 148 >> 2], E3[A8 + 148 >> 2] = t4 - h4, k4 = c4 << 1, n4 = E3[A8 + 144 >> 2], E3[A8 + 144 >> 2] = k4 - n4, s4 = o4 << 1, F4 = E3[A8 + 140 >> 2], E3[A8 + 140 >> 2] = s4 - F4, S4 = i4 << 1, N4 = E3[A8 + 136 >> 2], E3[A8 + 136 >> 2] = S4 - N4, K4 = Q4 << 1, r4 = E3[A8 + 132 >> 2], E3[A8 + 132 >> 2] = K4 - r4, _4 = U4 << 1, p4 = E3[A8 + 128 >> 2], E3[A8 + 128 >> 2] = _4 - p4, H4 = Y4 << 1, G4 = E3[A8 + 124 >> 2], E3[A8 + 124 >> 2] = H4 - G4, J4 = f4 << 1, Y4 = E3[A8 + 120 >> 2], E3[A8 + 120 >> 2] = J4 - Y4, E3[A8 + 112 >> 2] = e4 + w4, E3[A8 + 108 >> 2] = t4 + h4, E3[A8 + 104 >> 2] = k4 + n4, E3[A8 + 100 >> 2] = s4 + F4, E3[A8 + 96 >> 2] = S4 + N4, E3[A8 + 92 >> 2] = K4 + r4, E3[A8 + 88 >> 2] = _4 + p4, E3[A8 + 84 >> 2] = H4 + G4, E3[A8 + 80 >> 2] = J4 + Y4, E3[A8 + 116 >> 2] = I7 + g6; + } + function O(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0; + w4 = E3[I7 + 4 >> 2], e4 = E3[I7 + 44 >> 2], t4 = E3[I7 + 8 >> 2], h4 = E3[I7 + 48 >> 2], k4 = E3[I7 + 12 >> 2], n4 = E3[I7 + 52 >> 2], s4 = E3[I7 + 16 >> 2], F4 = E3[I7 + 56 >> 2], S4 = E3[I7 + 20 >> 2], N4 = E3[I7 + 60 >> 2], K4 = E3[I7 + 24 >> 2], _4 = E3[(r4 = I7 - -64 | 0) >> 2], p4 = E3[I7 + 28 >> 2], H4 = E3[I7 + 68 >> 2], G4 = E3[I7 + 32 >> 2], J4 = E3[I7 + 72 >> 2], Y4 = E3[I7 + 36 >> 2], U4 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = Y4 + U4, E3[A8 + 32 >> 2] = G4 + J4, E3[A8 + 28 >> 2] = p4 + H4, E3[A8 + 24 >> 2] = K4 + _4, E3[A8 + 20 >> 2] = S4 + N4, E3[A8 + 16 >> 2] = s4 + F4, E3[A8 + 12 >> 2] = k4 + n4, E3[A8 + 8 >> 2] = t4 + h4, E3[A8 + 4 >> 2] = e4 + w4, e4 = E3[I7 + 4 >> 2], t4 = E3[I7 + 44 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 48 >> 2], n4 = E3[I7 + 12 >> 2], s4 = E3[I7 + 52 >> 2], F4 = E3[I7 + 16 >> 2], S4 = E3[I7 + 56 >> 2], N4 = E3[I7 + 20 >> 2], K4 = E3[I7 + 60 >> 2], _4 = E3[I7 + 24 >> 2], r4 = E3[r4 >> 2], w4 = E3[I7 + 28 >> 2], p4 = E3[I7 + 68 >> 2], H4 = E3[I7 + 32 >> 2], G4 = E3[I7 + 72 >> 2], J4 = E3[I7 >> 2], Y4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = G4 - H4, E3[A8 + 68 >> 2] = p4 - w4, E3[(w4 = A8 - -64 | 0) >> 2] = r4 - _4, E3[A8 + 60 >> 2] = K4 - N4, E3[A8 + 56 >> 2] = S4 - F4, E3[A8 + 52 >> 2] = s4 - n4, E3[A8 + 48 >> 2] = k4 - h4, E3[A8 + 44 >> 2] = t4 - e4, E3[A8 + 40 >> 2] = Y4 - J4, M3(A8 + 80 | 0, A8, g6 + 40 | 0), M3(e4 = A8 + 40 | 0, e4, g6), M3(A8 + 120 | 0, g6 + 120 | 0, I7 + 120 | 0), M3(A8, I7 + 80 | 0, g6 + 80 | 0), Y4 = E3[A8 + 4 >> 2], U4 = E3[A8 + 8 >> 2], Q4 = E3[A8 + 12 >> 2], i4 = E3[A8 + 16 >> 2], o4 = E3[A8 + 20 >> 2], c4 = E3[A8 + 24 >> 2], D4 = E3[A8 + 28 >> 2], a4 = E3[A8 + 32 >> 2], y4 = E3[A8 + 36 >> 2], I7 = E3[A8 + 44 >> 2], g6 = E3[A8 + 84 >> 2], e4 = E3[A8 + 48 >> 2], t4 = E3[A8 + 88 >> 2], h4 = E3[A8 + 52 >> 2], k4 = E3[A8 + 92 >> 2], n4 = E3[A8 + 56 >> 2], s4 = E3[A8 + 96 >> 2], F4 = E3[A8 + 60 >> 2], S4 = E3[A8 + 100 >> 2], N4 = E3[w4 >> 2], K4 = E3[A8 + 104 >> 2], r4 = E3[A8 + 68 >> 2], _4 = E3[A8 + 108 >> 2], p4 = E3[A8 + 72 >> 2], H4 = E3[A8 + 112 >> 2], f4 = E3[A8 >> 2], G4 = E3[A8 + 40 >> 2], J4 = E3[A8 + 80 >> 2], C4 = E3[A8 + 76 >> 2], B4 = E3[A8 + 116 >> 2], E3[A8 + 76 >> 2] = C4 + B4, E3[A8 + 72 >> 2] = p4 + H4, E3[A8 + 68 >> 2] = r4 + _4, E3[w4 >> 2] = N4 + K4, E3[A8 + 60 >> 2] = F4 + S4, E3[A8 + 56 >> 2] = n4 + s4, E3[A8 + 52 >> 2] = h4 + k4, E3[A8 + 48 >> 2] = e4 + t4, E3[A8 + 44 >> 2] = I7 + g6, E3[A8 + 40 >> 2] = G4 + J4, E3[A8 + 36 >> 2] = B4 - C4, E3[A8 + 32 >> 2] = H4 - p4, E3[A8 + 28 >> 2] = _4 - r4, E3[A8 + 24 >> 2] = K4 - N4, E3[A8 + 20 >> 2] = S4 - F4, E3[A8 + 16 >> 2] = s4 - n4, E3[A8 + 12 >> 2] = k4 - h4, E3[A8 + 8 >> 2] = t4 - e4, E3[A8 + 4 >> 2] = g6 - I7, E3[A8 >> 2] = J4 - G4, I7 = E3[A8 + 156 >> 2], g6 = y4 << 1, E3[A8 + 156 >> 2] = I7 + g6, w4 = E3[A8 + 152 >> 2], e4 = a4 << 1, E3[A8 + 152 >> 2] = w4 + e4, t4 = E3[A8 + 148 >> 2], h4 = D4 << 1, E3[A8 + 148 >> 2] = t4 + h4, k4 = E3[A8 + 144 >> 2], n4 = c4 << 1, E3[A8 + 144 >> 2] = k4 + n4, s4 = E3[A8 + 140 >> 2], F4 = o4 << 1, E3[A8 + 140 >> 2] = s4 + F4, S4 = E3[A8 + 136 >> 2], N4 = i4 << 1, E3[A8 + 136 >> 2] = S4 + N4, K4 = E3[A8 + 132 >> 2], r4 = Q4 << 1, E3[A8 + 132 >> 2] = K4 + r4, _4 = E3[A8 + 128 >> 2], p4 = U4 << 1, E3[A8 + 128 >> 2] = _4 + p4, H4 = E3[A8 + 124 >> 2], G4 = Y4 << 1, E3[A8 + 124 >> 2] = H4 + G4, J4 = E3[A8 + 120 >> 2], Y4 = f4 << 1, E3[A8 + 120 >> 2] = J4 + Y4, E3[A8 + 112 >> 2] = e4 - w4, E3[A8 + 108 >> 2] = h4 - t4, E3[A8 + 104 >> 2] = n4 - k4, E3[A8 + 100 >> 2] = F4 - s4, E3[A8 + 96 >> 2] = N4 - S4, E3[A8 + 92 >> 2] = r4 - K4, E3[A8 + 88 >> 2] = p4 - _4, E3[A8 + 84 >> 2] = G4 - H4, E3[A8 + 80 >> 2] = Y4 - J4, E3[A8 + 116 >> 2] = g6 - I7; + } + function T(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0; + w4 = E3[I7 + 4 >> 2], e4 = E3[I7 + 44 >> 2], t4 = E3[I7 + 8 >> 2], h4 = E3[I7 + 48 >> 2], k4 = E3[I7 + 12 >> 2], n4 = E3[I7 + 52 >> 2], s4 = E3[I7 + 16 >> 2], F4 = E3[I7 + 56 >> 2], S4 = E3[I7 + 20 >> 2], N4 = E3[I7 + 60 >> 2], K4 = E3[I7 + 24 >> 2], _4 = E3[(r4 = I7 - -64 | 0) >> 2], p4 = E3[I7 + 28 >> 2], H4 = E3[I7 + 68 >> 2], G4 = E3[I7 + 32 >> 2], J4 = E3[I7 + 72 >> 2], Y4 = E3[I7 + 36 >> 2], U4 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = Y4 + U4, E3[A8 + 32 >> 2] = G4 + J4, E3[A8 + 28 >> 2] = p4 + H4, E3[A8 + 24 >> 2] = K4 + _4, E3[A8 + 20 >> 2] = S4 + N4, E3[A8 + 16 >> 2] = s4 + F4, E3[A8 + 12 >> 2] = k4 + n4, E3[A8 + 8 >> 2] = t4 + h4, E3[A8 + 4 >> 2] = e4 + w4, e4 = E3[I7 + 4 >> 2], t4 = E3[I7 + 44 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 48 >> 2], n4 = E3[I7 + 12 >> 2], s4 = E3[I7 + 52 >> 2], F4 = E3[I7 + 16 >> 2], S4 = E3[I7 + 56 >> 2], N4 = E3[I7 + 20 >> 2], K4 = E3[I7 + 60 >> 2], _4 = E3[I7 + 24 >> 2], r4 = E3[r4 >> 2], w4 = E3[I7 + 28 >> 2], p4 = E3[I7 + 68 >> 2], H4 = E3[I7 + 32 >> 2], G4 = E3[I7 + 72 >> 2], J4 = E3[I7 >> 2], Y4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = G4 - H4, E3[A8 + 68 >> 2] = p4 - w4, E3[(w4 = A8 - -64 | 0) >> 2] = r4 - _4, E3[A8 + 60 >> 2] = K4 - N4, E3[A8 + 56 >> 2] = S4 - F4, E3[A8 + 52 >> 2] = s4 - n4, E3[A8 + 48 >> 2] = k4 - h4, E3[A8 + 44 >> 2] = t4 - e4, E3[A8 + 40 >> 2] = Y4 - J4, M3(A8 + 80 | 0, A8, g6), M3(e4 = A8 + 40 | 0, e4, g6 + 40 | 0), M3(A8 + 120 | 0, g6 + 80 | 0, I7 + 120 | 0), Y4 = E3[I7 + 84 >> 2], U4 = E3[I7 + 88 >> 2], Q4 = E3[I7 + 92 >> 2], i4 = E3[I7 + 96 >> 2], o4 = E3[I7 + 100 >> 2], c4 = E3[I7 + 104 >> 2], D4 = E3[I7 + 108 >> 2], a4 = E3[I7 + 112 >> 2], y4 = E3[I7 + 116 >> 2], g6 = E3[A8 + 44 >> 2], e4 = E3[A8 + 84 >> 2], t4 = E3[A8 + 48 >> 2], h4 = E3[A8 + 88 >> 2], k4 = E3[A8 + 52 >> 2], n4 = E3[A8 + 92 >> 2], s4 = E3[A8 + 56 >> 2], F4 = E3[A8 + 96 >> 2], S4 = E3[A8 + 60 >> 2], N4 = E3[A8 + 100 >> 2], K4 = E3[w4 >> 2], r4 = E3[A8 + 104 >> 2], _4 = E3[A8 + 68 >> 2], p4 = E3[A8 + 108 >> 2], H4 = E3[A8 + 72 >> 2], G4 = E3[A8 + 112 >> 2], f4 = E3[I7 + 80 >> 2], I7 = E3[A8 + 40 >> 2], J4 = E3[A8 + 80 >> 2], C4 = E3[A8 + 76 >> 2], B4 = E3[A8 + 116 >> 2], E3[A8 + 76 >> 2] = C4 + B4, E3[A8 + 72 >> 2] = H4 + G4, E3[A8 + 68 >> 2] = _4 + p4, E3[w4 >> 2] = K4 + r4, E3[A8 + 60 >> 2] = S4 + N4, E3[A8 + 56 >> 2] = s4 + F4, E3[A8 + 52 >> 2] = k4 + n4, E3[A8 + 48 >> 2] = t4 + h4, E3[A8 + 44 >> 2] = g6 + e4, E3[A8 + 40 >> 2] = I7 + J4, E3[A8 + 36 >> 2] = B4 - C4, E3[A8 + 32 >> 2] = G4 - H4, E3[A8 + 28 >> 2] = p4 - _4, E3[A8 + 24 >> 2] = r4 - K4, E3[A8 + 20 >> 2] = N4 - S4, E3[A8 + 16 >> 2] = F4 - s4, E3[A8 + 12 >> 2] = n4 - k4, E3[A8 + 8 >> 2] = h4 - t4, E3[A8 + 4 >> 2] = e4 - g6, E3[A8 >> 2] = J4 - I7, I7 = y4 << 1, g6 = E3[A8 + 156 >> 2], E3[A8 + 156 >> 2] = I7 - g6, w4 = a4 << 1, e4 = E3[A8 + 152 >> 2], E3[A8 + 152 >> 2] = w4 - e4, t4 = D4 << 1, h4 = E3[A8 + 148 >> 2], E3[A8 + 148 >> 2] = t4 - h4, k4 = c4 << 1, n4 = E3[A8 + 144 >> 2], E3[A8 + 144 >> 2] = k4 - n4, s4 = o4 << 1, F4 = E3[A8 + 140 >> 2], E3[A8 + 140 >> 2] = s4 - F4, S4 = i4 << 1, N4 = E3[A8 + 136 >> 2], E3[A8 + 136 >> 2] = S4 - N4, K4 = Q4 << 1, r4 = E3[A8 + 132 >> 2], E3[A8 + 132 >> 2] = K4 - r4, _4 = U4 << 1, p4 = E3[A8 + 128 >> 2], E3[A8 + 128 >> 2] = _4 - p4, H4 = Y4 << 1, G4 = E3[A8 + 124 >> 2], E3[A8 + 124 >> 2] = H4 - G4, J4 = f4 << 1, Y4 = E3[A8 + 120 >> 2], E3[A8 + 120 >> 2] = J4 - Y4, E3[A8 + 112 >> 2] = e4 + w4, E3[A8 + 108 >> 2] = t4 + h4, E3[A8 + 104 >> 2] = k4 + n4, E3[A8 + 100 >> 2] = s4 + F4, E3[A8 + 96 >> 2] = S4 + N4, E3[A8 + 92 >> 2] = K4 + r4, E3[A8 + 88 >> 2] = _4 + p4, E3[A8 + 84 >> 2] = H4 + G4, E3[A8 + 80 >> 2] = J4 + Y4, E3[A8 + 116 >> 2] = I7 + g6; + } + function V(A8, I7) { + var g6, C4, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, r4, h4, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0; + r4 = i3[I7 + 31 | 0], g6 = i3[I7 + 30 | 0], C4 = i3[I7 + 29 | 0], B4 = i3[I7 + 6 | 0], Q4 = i3[I7 + 5 | 0], o4 = i3[I7 + 4 | 0], c4 = i3[I7 + 9 | 0], D4 = i3[I7 + 8 | 0], a4 = i3[I7 + 7 | 0], y4 = i3[I7 + 12 | 0], H4 = i3[I7 + 11 | 0], G4 = i3[I7 + 10 | 0], f4 = i3[I7 + 15 | 0], J4 = i3[I7 + 14 | 0], e4 = i3[I7 + 13 | 0], N4 = i3[I7 + 28 | 0], p4 = i3[I7 + 27 | 0], K4 = i3[I7 + 26 | 0], M4 = i3[I7 + 25 | 0], F4 = i3[I7 + 24 | 0], s4 = i3[I7 + 23 | 0], h4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, S4 = (n4 = i3[I7 + 21 | 0]) << 15, n4 = k4 = n4 >>> 17 | 0, _4 = S4, _4 |= (S4 = i3[I7 + 20 | 0]) << 7, S4 = (k4 = S4 >>> 25 | 0) | n4, n4 = (k4 = i3[I7 + 22 | 0]) >>> 9 | 0, k4 = k4 << 23 | _4, n4 |= S4, w4 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, I7 = 0, S4 = k4, k4 = (33554431 & (I7 = (_4 = w4 + 16777216 | 0) >>> 0 < 16777216 ? 1 : I7)) << 7 | _4 >>> 25, I7 = (I7 >>> 25 | 0) + n4 | 0, k4 = (n4 = S4 = S4 + k4 | 0) >>> 0 < k4 >>> 0 ? I7 + 1 | 0 : I7, I7 = (S4 = n4 + 33554432 | 0) >>> 0 < 33554432 ? k4 + 1 | 0 : k4, E3[A8 + 24 >> 2] = n4 - (-67108864 & S4), k4 = (n4 = s4 >>> 27 | 0) | F4 >>> 19 | M4 >>> 11, n4 = s4 = (F4 = M4 << 21 | (s4 = F4 << 13 | s4 << 5)) + (n4 = (67108863 & (n4 = I7)) << 6 | S4 >>> 26) | 0, I7 = k4, k4 = (s4 = F4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 28 >> 2] = n4 - (1040187392 & s4), n4 = (k4 = (I7 = k4) >>> 25 | 0) + (n4 = p4 >>> 20 | K4 >>> 28 | N4 >>> 12) | 0, I7 = n4 = (k4 = s4 = (I7 = (33554431 & I7) << 7 | s4 >>> 25) + (p4 << 12 | K4 << 4 | N4 << 20) | 0) >>> 0 < I7 >>> 0 ? n4 + 1 | 0 : n4, s4 = (N4 = k4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[A8 + 32 >> 2] = k4 - (-67108864 & N4), n4 = y4 >>> 13 | (k4 = H4 >>> 21 | G4 >>> 29), I7 = (n4 = (p4 = 16777216 + (H4 = H4 << 11 | G4 << 3 | y4 << 19) | 0) >>> 0 < 16777216 ? n4 + 1 | 0 : n4) >>> 25 | 0, n4 = (k4 = F4 = J4 << 10 | e4 << 2 | f4 << 18) + (F4 = (33554431 & n4) << 7 | p4 >>> 25) | 0, k4 = I7 + (M4 = J4 >>> 22 | e4 >>> 30 | f4 >>> 14) | 0, I7 = k4 = n4 >>> 0 < F4 >>> 0 ? k4 + 1 | 0 : k4, F4 = ((67108863 & (I7 = (F4 = n4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | (k4 = F4) >>> 26) + (K4 = w4 - (-33554432 & _4) | 0) | 0, E3[A8 + 20 >> 2] = F4, E3[A8 + 16 >> 2] = n4 - (-67108864 & k4), k4 = Q4 >>> 18 | o4 >>> 26 | B4 >>> 10, n4 = (k4 = (K4 = 16777216 + (G4 = Q4 << 14 | o4 << 6 | B4 << 22) | 0) >>> 0 < 16777216 ? k4 + 1 | 0 : k4) >>> 25 | 0, k4 = (I7 = F4 = D4 << 13 | a4 << 5 | c4 << 21) + (F4 = (33554431 & k4) << 7 | K4 >>> 25) | 0, I7 = n4 + (M4 = D4 >>> 19 | a4 >>> 27 | c4 >>> 11) | 0, I7 = k4 >>> 0 < F4 >>> 0 ? I7 + 1 | 0 : I7, n4 = (M4 = k4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[A8 + 8 >> 2] = k4 - (-67108864 & M4), N4 = (s4 = (67108863 & s4) << 6 | N4 >>> 26) + (J4 = r4 << 18 & 33292288 | g6 << 10 | C4 << 2) | 0, I7 = k4 = g6 >>> 22 | C4 >>> 30, k4 = (s4 = J4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[A8 + 36 >> 2] = N4 - (33554432 & s4), n4 = H4 + ((67108863 & n4) << 6 | M4 >>> 26) | 0, E3[A8 + 12 >> 2] = n4 - (234881024 & p4), F4 = G4 - (2113929216 & K4) | 0, n4 = PA((33554431 & (I7 = k4)) << 7 | s4 >>> 25, k4 = I7 >>> 25 | 0, 19, 0), I7 = t3, n4 = (k4 = n4 + h4 | 0) >>> 0 < n4 >>> 0 ? I7 + 1 | 0 : I7, s4 = ((67108863 & (n4 = (I7 = k4 + 33554432 | 0) >>> 0 < 33554432 ? n4 + 1 | 0 : n4)) << 6 | I7 >>> 26) + F4 | 0, E3[A8 + 4 >> 2] = s4, E3[A8 >> 2] = k4 - (-67108864 & I7); + } + function Z(A8, I7) { + var g6, B4, Q4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0; + for (r3 = g6 = r3 - 480 | 0; a4 = (D4 = g6 + 288 | 0) + (c4 << 1) | 0, y4 = i3[I7 + c4 | 0], C3[a4 + 1 | 0] = y4 >>> 4, C3[0 | a4] = 15 & y4, D4 = D4 + ((a4 = 1 | c4) << 1) | 0, a4 = i3[I7 + a4 | 0], C3[D4 + 1 | 0] = a4 >>> 4, C3[0 | D4] = 15 & a4, 32 != (0 | (c4 = c4 + 2 | 0)); ) ; + for (I7 = 0; c4 = 8 + (D4 = (c4 = I7) + i3[0 | (I7 = (g6 + 288 | 0) + f4 | 0)] | 0) | 0, C3[0 | I7] = D4 - (240 & c4), c4 = 8 + (D4 = i3[I7 + 1 | 0] + (c4 << 24 >> 24 >> 4) | 0) | 0, C3[I7 + 1 | 0] = D4 - (240 & c4), c4 = 8 + (D4 = i3[I7 + 2 | 0] + (c4 << 24 >> 24 >> 4) | 0) | 0, C3[I7 + 2 | 0] = D4 - (240 & c4), I7 = c4 << 24 >> 24 >> 4, 63 != (0 | (f4 = f4 + 3 | 0)); ) ; + for (C3[g6 + 351 | 0] = i3[g6 + 351 | 0] + I7, E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, E3[A8 + 24 >> 2] = 0, E3[A8 + 28 >> 2] = 0, E3[A8 + 16 >> 2] = 0, E3[A8 + 20 >> 2] = 0, E3[A8 + 8 >> 2] = 0, E3[A8 + 12 >> 2] = 0, E3[A8 >> 2] = 0, E3[A8 + 4 >> 2] = 0, E3[A8 + 44 >> 2] = 0, E3[A8 + 48 >> 2] = 0, E3[A8 + 40 >> 2] = 1, E3[A8 + 52 >> 2] = 0, E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, E3[A8 + 64 >> 2] = 0, E3[A8 + 68 >> 2] = 0, E3[A8 + 72 >> 2] = 0, E3[A8 + 76 >> 2] = 0, E3[A8 + 80 >> 2] = 1, VA(A8 + 84 | 0, 0, 76), Q4 = A8 + 120 | 0, f4 = A8 + 80 | 0, I7 = A8 + 40 | 0, D4 = g6 + 208 | 0, B4 = g6 + 168 | 0, a4 = g6 + 248 | 0, c4 = 1; oA(e4 = g6 + 8 | 0, c4 >>> 1 | 0, C3[(g6 + 288 | 0) + c4 | 0]), T(y4 = g6 + 128 | 0, A8, e4), M3(A8, y4, a4), M3(I7, B4, D4), M3(f4, D4, a4), M3(Q4, y4, B4), e4 = c4 >>> 0 < 62, c4 = c4 + 2 | 0, e4; ) ; + for (c4 = E3[A8 + 36 >> 2], E3[g6 + 392 >> 2] = E3[A8 + 32 >> 2], E3[g6 + 396 >> 2] = c4, c4 = E3[A8 + 28 >> 2], E3[g6 + 384 >> 2] = E3[A8 + 24 >> 2], E3[g6 + 388 >> 2] = c4, c4 = E3[A8 + 20 >> 2], E3[g6 + 376 >> 2] = E3[A8 + 16 >> 2], E3[g6 + 380 >> 2] = c4, c4 = E3[A8 + 12 >> 2], E3[g6 + 368 >> 2] = E3[A8 + 8 >> 2], E3[g6 + 372 >> 2] = c4, c4 = E3[A8 + 4 >> 2], E3[g6 + 360 >> 2] = E3[A8 >> 2], E3[g6 + 364 >> 2] = c4, c4 = E3[I7 + 12 >> 2], E3[g6 + 408 >> 2] = E3[I7 + 8 >> 2], E3[g6 + 412 >> 2] = c4, c4 = E3[I7 + 20 >> 2], E3[g6 + 416 >> 2] = E3[I7 + 16 >> 2], E3[g6 + 420 >> 2] = c4, c4 = E3[I7 + 28 >> 2], E3[g6 + 424 >> 2] = E3[I7 + 24 >> 2], E3[g6 + 428 >> 2] = c4, c4 = E3[I7 + 36 >> 2], E3[g6 + 432 >> 2] = E3[I7 + 32 >> 2], E3[g6 + 436 >> 2] = c4, c4 = E3[I7 + 4 >> 2], E3[g6 + 400 >> 2] = E3[I7 >> 2], E3[g6 + 404 >> 2] = c4, c4 = E3[f4 + 12 >> 2], E3[g6 + 448 >> 2] = E3[f4 + 8 >> 2], E3[g6 + 452 >> 2] = c4, c4 = E3[f4 + 20 >> 2], E3[g6 + 456 >> 2] = E3[f4 + 16 >> 2], E3[g6 + 460 >> 2] = c4, c4 = E3[f4 + 28 >> 2], E3[g6 + 464 >> 2] = E3[f4 + 24 >> 2], E3[g6 + 468 >> 2] = c4, c4 = E3[f4 + 36 >> 2], E3[g6 + 472 >> 2] = E3[f4 + 32 >> 2], E3[g6 + 476 >> 2] = c4, c4 = E3[f4 + 4 >> 2], E3[g6 + 440 >> 2] = E3[f4 >> 2], E3[g6 + 444 >> 2] = c4, _3(y4, c4 = g6 + 360 | 0), M3(c4, y4, a4), M3(e4 = g6 + 400 | 0, B4, D4), M3(o4 = g6 + 440 | 0, D4, a4), _3(y4, c4), M3(c4, y4, a4), M3(e4, B4, D4), M3(o4, D4, a4), _3(y4, c4), M3(c4, y4, a4), M3(e4, B4, D4), M3(o4, D4, a4), _3(y4, c4), M3(A8, y4, a4), M3(I7, B4, D4), M3(f4, D4, a4), M3(Q4, y4, B4), c4 = 0; oA(e4 = g6 + 8 | 0, c4 >>> 1 | 0, C3[(g6 + 288 | 0) + c4 | 0]), T(y4 = g6 + 128 | 0, A8, e4), M3(A8, y4, a4), M3(I7, B4, D4), M3(f4, D4, a4), M3(Q4, y4, B4), y4 = c4 >>> 0 < 62, c4 = c4 + 2 | 0, y4; ) ; + r3 = g6 + 480 | 0; + } + function W(A8, I7, g6, B4) { + var Q4, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, s4 = 0; + if (r3 = Q4 = r3 - 704 | 0, g6 | B4) if (o4 = (B4 << 3 | g6 >>> 29) + (c4 = a4 = E3[A8 + 76 >> 2]) | 0, D4 = (f4 = E3[A8 + 72 >> 2]) + (y4 = g6 << 3) | 0, E3[A8 + 72 >> 2] = D4, o4 = D4 >>> 0 < y4 >>> 0 ? o4 + 1 | 0 : o4, E3[A8 + 76 >> 2] = o4, a4 = E3[A8 + 68 >> 2], o4 = (o4 = D4 = (0 | o4) == (0 | c4) & D4 >>> 0 < f4 >>> 0 | o4 >>> 0 < c4 >>> 0) >>> 0 > (D4 = D4 + E3[A8 + 64 >> 2] | 0) >>> 0 ? a4 + 1 | 0 : a4, D4 = (y4 = B4 >>> 29 | 0) + D4 | 0, E3[A8 + 64 >> 2] = D4, E3[A8 + 68 >> 2] = D4 >>> 0 < y4 >>> 0 ? o4 + 1 | 0 : o4, D4 = A8 + 80 | 0, (0 | B4) == (0 | (a4 = k4 = 0 - ((o4 = 0) + ((y4 = 127 & ((7 & c4) << 29 | f4 >>> 3)) >>> 0 > 128) | 0) | 0)) & g6 >>> 0 >= (f4 = 128 - y4 | 0) >>> 0 | B4 >>> 0 > a4 >>> 0) { + if (c4 = 0, a4 = 0, !o4 & (127 ^ y4) >>> 0 >= 3 | o4) for (s4 = 252 & f4; C3[(o4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], C3[D4 + (y4 + (o4 = 1 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (y4 + (o4 = 2 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (y4 + (o4 = 3 | c4) | 0) | 0] = i3[I7 + o4 | 0], o4 = a4, a4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, o4 = t4, t4 = o4 = (e4 = e4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, (0 | e4) != (0 | s4) | (0 | h4) != (0 | o4); ) ; + if (t4 = o4 = 0, o4 | (e4 = 3 & f4)) for (; C3[(o4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], o4 = a4, a4 = (c4 = c4 + 1 | 0) ? o4 : o4 + 1 | 0, o4 = h4, h4 = o4 = (w4 = w4 + 1 | 0) ? o4 : o4 + 1 | 0, (0 | e4) != (0 | w4) | (0 | t4) != (0 | o4); ) ; + if (n3(A8, D4, Q4, c4 = Q4 + 640 | 0), I7 = I7 + f4 | 0, !(B4 = B4 - ((g6 >>> 0 < f4 >>> 0) + k4 | 0) | 0) & (g6 = g6 - f4 | 0) >>> 0 > 127 | B4) for (; n3(A8, I7, Q4, c4), I7 = I7 + 128 | 0, !(B4 = B4 - (g6 >>> 0 < 128) | 0) & (g6 = g6 - 128 | 0) >>> 0 > 127 | B4; ) ; + if (g6 | B4) { + if (A8 = 3 & g6, w4 = 0, h4 = 0, c4 = 0, a4 = 0, !B4 & g6 >>> 0 >= 4 | B4) for (e4 = 124 & g6, f4 = 0, g6 = 0, B4 = 0; C3[c4 + D4 | 0] = i3[I7 + c4 | 0], C3[(o4 = 1 | c4) + D4 | 0] = i3[I7 + o4 | 0], C3[(o4 = 2 | c4) + D4 | 0] = i3[I7 + o4 | 0], C3[(o4 = 3 | c4) + D4 | 0] = i3[I7 + o4 | 0], o4 = a4, a4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, o4 = B4, B4 = o4 = (g6 = g6 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, (0 | g6) != (0 | e4) | (0 | f4) != (0 | o4); ) ; + if (A8 | t4) for (; C3[c4 + D4 | 0] = i3[I7 + c4 | 0], a4 = (c4 = c4 + 1 | 0) ? a4 : a4 + 1 | 0, o4 = h4, h4 = o4 = (w4 = w4 + 1 | 0) ? o4 : o4 + 1 | 0, (0 | A8) != (0 | w4) | (0 | t4) != (0 | o4); ) ; + } + MI(Q4, 704); + } else { + if (c4 = 0, a4 = 0, !B4 & g6 >>> 0 >= 4 | B4) for (A8 = -4 & g6; C3[(o4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], C3[D4 + (f4 = y4 + (o4 = 1 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (f4 = y4 + (o4 = 2 | c4) | 0) | 0] = i3[I7 + o4 | 0], C3[D4 + (f4 = y4 + (o4 = 3 | c4) | 0) | 0] = i3[I7 + o4 | 0], o4 = a4, a4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, o4 = t4, t4 = o4 = (e4 = e4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, (0 | A8) != (0 | e4) | (0 | B4) != (0 | o4); ) ; + if ((g6 &= 3) | (A8 = 0)) for (; C3[(B4 = c4 + y4 | 0) + D4 | 0] = i3[I7 + c4 | 0], a4 = (c4 = c4 + 1 | 0) ? a4 : a4 + 1 | 0, o4 = h4, h4 = o4 = (w4 = w4 + 1 | 0) ? o4 : o4 + 1 | 0, (0 | g6) != (0 | w4) | (0 | A8) != (0 | o4); ) ; + } + return r3 = Q4 + 704 | 0, 0; + } + function $(A8, I7, g6) { + var B4 = 0, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0; + for (Q4 = 2036477234, o4 = 857760878, B4 = 1634760805, D4 = 1797285236, E4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, f4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, c4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, e4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, a4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, s4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, w4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, r4 = i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24, t4 = i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24, h4 = i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24, I7 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, g6 = i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24; y4 = g6, g6 = gI((k4 = I7) ^ (I7 = g6 + B4 | 0), 16), y4 = w4 = gI(y4 ^ (B4 = g6 + w4 | 0), 12), F4 = gI((k4 = I7 + w4 | 0) ^ g6, 8), I7 = gI(y4 ^ (w4 = F4 + B4 | 0), 7), B4 = r4, r4 = gI((g6 = D4 + r4 | 0) ^ E4, 16), B4 = gI(B4 ^ (e4 = r4 + e4 | 0), 12), E4 = t4, D4 = gI((Q4 = Q4 + t4 | 0) ^ f4, 16), E4 = gI(E4 ^ (t4 = D4 + a4 | 0), 12), a4 = gI((Q4 = E4 + Q4 | 0) ^ D4, 8), g6 = gI(a4 ^ (D4 = I7 + (n4 = g6 + B4 | 0) | 0), 16), f4 = gI((o4 = o4 + h4 | 0) ^ c4, 16), h4 = gI((c4 = f4 + s4 | 0) ^ h4, 12), y4 = I7, I7 = gI((o4 = o4 + h4 | 0) ^ f4, 8), y4 = gI(y4 ^ (c4 = g6 + (S4 = I7 + c4 | 0) | 0), 12), f4 = gI(g6 ^ (D4 = y4 + D4 | 0), 8), g6 = gI((s4 = f4 + c4 | 0) ^ y4, 7), y4 = Q4, Q4 = B4, n4 = gI(r4 ^ n4, 8), Q4 = gI(Q4 ^ (B4 = n4 + e4 | 0), 7), r4 = gI((c4 = y4 + Q4 | 0) ^ I7, 16), e4 = gI((I7 = r4 + w4 | 0) ^ Q4, 12), c4 = gI(r4 ^ (Q4 = e4 + c4 | 0), 8), r4 = gI((w4 = I7 + c4 | 0) ^ e4, 7), I7 = gI((I7 = E4) ^ (E4 = a4 + t4 | 0), 7), t4 = gI((o4 = I7 + o4 | 0) ^ F4, 16), a4 = gI(I7 ^ (B4 = t4 + B4 | 0), 12), I7 = gI(t4 ^ (o4 = a4 + o4 | 0), 8), t4 = gI((e4 = B4 + I7 | 0) ^ a4, 7), y4 = E4, B4 = gI(h4 ^ S4, 7), a4 = gI((E4 = B4 + k4 | 0) ^ n4, 16), k4 = gI(B4 ^ (h4 = y4 + a4 | 0), 12), E4 = gI(a4 ^ (B4 = k4 + E4 | 0), 8), h4 = gI((a4 = h4 + E4 | 0) ^ k4, 7), 10 != (0 | (M4 = M4 + 1 | 0)); ) ; + C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = E4, C3[A8 + 29 | 0] = E4 >>> 8, C3[A8 + 30 | 0] = E4 >>> 16, C3[A8 + 31 | 0] = E4 >>> 24, C3[A8 + 24 | 0] = f4, C3[A8 + 25 | 0] = f4 >>> 8, C3[A8 + 26 | 0] = f4 >>> 16, C3[A8 + 27 | 0] = f4 >>> 24, C3[A8 + 20 | 0] = c4, C3[A8 + 21 | 0] = c4 >>> 8, C3[A8 + 22 | 0] = c4 >>> 16, C3[A8 + 23 | 0] = c4 >>> 24, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, C3[A8 + 12 | 0] = D4, C3[A8 + 13 | 0] = D4 >>> 8, C3[A8 + 14 | 0] = D4 >>> 16, C3[A8 + 15 | 0] = D4 >>> 24, C3[A8 + 8 | 0] = Q4, C3[A8 + 9 | 0] = Q4 >>> 8, C3[A8 + 10 | 0] = Q4 >>> 16, C3[A8 + 11 | 0] = Q4 >>> 24, C3[A8 + 4 | 0] = o4, C3[A8 + 5 | 0] = o4 >>> 8, C3[A8 + 6 | 0] = o4 >>> 16, C3[A8 + 7 | 0] = o4 >>> 24; + } + function AA(A8, I7, g6) { + var B4 = 0, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, M4 = 0; + for (B4 = 1797285236, a4 = 2036477234, y4 = 857760878, Q4 = 1634760805, E4 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, c4 = i3[I7 + 8 | 0] | i3[I7 + 9 | 0] << 8 | i3[I7 + 10 | 0] << 16 | i3[I7 + 11 | 0] << 24, o4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24, k4 = i3[g6 + 28 | 0] | i3[g6 + 29 | 0] << 8 | i3[g6 + 30 | 0] << 16 | i3[g6 + 31 | 0] << 24, h4 = i3[g6 + 24 | 0] | i3[g6 + 25 | 0] << 8 | i3[g6 + 26 | 0] << 16 | i3[g6 + 27 | 0] << 24, n4 = 20, r4 = i3[g6 + 20 | 0] | i3[g6 + 21 | 0] << 8 | i3[g6 + 22 | 0] << 16 | i3[g6 + 23 | 0] << 24, t4 = i3[g6 + 16 | 0] | i3[g6 + 17 | 0] << 8 | i3[g6 + 18 | 0] << 16 | i3[g6 + 19 | 0] << 24, f4 = i3[g6 + 12 | 0] | i3[g6 + 13 | 0] << 8 | i3[g6 + 14 | 0] << 16 | i3[g6 + 15 | 0] << 24, e4 = i3[g6 + 8 | 0] | i3[g6 + 9 | 0] << 8 | i3[g6 + 10 | 0] << 16 | i3[g6 + 11 | 0] << 24, w4 = i3[g6 + 4 | 0] | i3[g6 + 5 | 0] << 8 | i3[g6 + 6 | 0] << 16 | i3[g6 + 7 | 0] << 24, I7 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24, g6 = i3[0 | g6] | i3[g6 + 1 | 0] << 8 | i3[g6 + 2 | 0] << 16 | i3[g6 + 3 | 0] << 24; D4 = gI(g6 + y4 | 0, 7) ^ E4, s4 = gI(D4 + y4 | 0, 9) ^ h4, f4 = gI(Q4 + r4 | 0, 7) ^ f4, F4 = gI(f4 + Q4 | 0, 9) ^ c4, S4 = gI(F4 + f4 | 0, 13) ^ r4, e4 = gI(B4 + t4 | 0, 7) ^ e4, o4 = gI(e4 + B4 | 0, 9) ^ o4, c4 = gI(o4 + e4 | 0, 13) ^ t4, B4 = gI(o4 + c4 | 0, 18) ^ B4, E4 = gI(I7 + a4 | 0, 7) ^ k4, r4 = S4 ^ gI(B4 + E4 | 0, 7), h4 = s4 ^ gI(r4 + B4 | 0, 9), k4 = gI(r4 + h4 | 0, 13) ^ E4, B4 = gI(h4 + k4 | 0, 18) ^ B4, w4 = gI(E4 + a4 | 0, 9) ^ w4, M4 = gI(w4 + E4 | 0, 13) ^ I7, I7 = gI(M4 + w4 | 0, 18) ^ a4, t4 = gI(I7 + D4 | 0, 7) ^ c4, c4 = gI(t4 + I7 | 0, 9) ^ F4, E4 = gI(c4 + t4 | 0, 13) ^ D4, a4 = gI(E4 + c4 | 0, 18) ^ I7, D4 = gI(D4 + s4 | 0, 13) ^ g6, g6 = gI(D4 + s4 | 0, 18) ^ y4, I7 = gI(g6 + f4 | 0, 7) ^ M4, o4 = gI(I7 + g6 | 0, 9) ^ o4, f4 = gI(I7 + o4 | 0, 13) ^ f4, y4 = gI(o4 + f4 | 0, 18) ^ g6, Q4 = gI(F4 + S4 | 0, 18) ^ Q4, g6 = gI(Q4 + e4 | 0, 7) ^ D4, w4 = gI(g6 + Q4 | 0, 9) ^ w4, e4 = gI(g6 + w4 | 0, 13) ^ e4, Q4 = gI(w4 + e4 | 0, 18) ^ Q4, D4 = n4 >>> 0 > 2, n4 = n4 - 2 | 0, D4; ) ; + return C3[0 | A8] = Q4, C3[A8 + 1 | 0] = Q4 >>> 8, C3[A8 + 2 | 0] = Q4 >>> 16, C3[A8 + 3 | 0] = Q4 >>> 24, C3[A8 + 28 | 0] = E4, C3[A8 + 29 | 0] = E4 >>> 8, C3[A8 + 30 | 0] = E4 >>> 16, C3[A8 + 31 | 0] = E4 >>> 24, C3[A8 + 24 | 0] = c4, C3[A8 + 25 | 0] = c4 >>> 8, C3[A8 + 26 | 0] = c4 >>> 16, C3[A8 + 27 | 0] = c4 >>> 24, C3[A8 + 20 | 0] = o4, C3[A8 + 21 | 0] = o4 >>> 8, C3[A8 + 22 | 0] = o4 >>> 16, C3[A8 + 23 | 0] = o4 >>> 24, C3[A8 + 16 | 0] = I7, C3[A8 + 17 | 0] = I7 >>> 8, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 19 | 0] = I7 >>> 24, C3[A8 + 12 | 0] = B4, C3[A8 + 13 | 0] = B4 >>> 8, C3[A8 + 14 | 0] = B4 >>> 16, C3[A8 + 15 | 0] = B4 >>> 24, C3[A8 + 8 | 0] = a4, C3[A8 + 9 | 0] = a4 >>> 8, C3[A8 + 10 | 0] = a4 >>> 16, C3[A8 + 11 | 0] = a4 >>> 24, C3[A8 + 4 | 0] = y4, C3[A8 + 5 | 0] = y4 >>> 8, C3[A8 + 6 | 0] = y4 >>> 16, C3[A8 + 7 | 0] = y4 >>> 24, 0; + } + function IA(A8, I7) { + var g6, B4, Q4 = 0, i4 = 0, o4 = 0, c4 = 0; + r3 = g6 = r3 - 288 | 0, i4 = 40 + ((Q4 = E3[A8 + 32 >> 2] >>> 3 & 63) + A8 | 0) | 0, Q4 >>> 0 >= 56 ? (TA(i4, 35040, 64 - Q4 | 0), p3(A8, A8 + 40 | 0, g6, g6 + 256 | 0), E3[A8 + 88 >> 2] = 0, E3[A8 + 92 >> 2] = 0, E3[A8 + 80 >> 2] = 0, E3[A8 + 84 >> 2] = 0, E3[A8 + 72 >> 2] = 0, E3[A8 + 76 >> 2] = 0, E3[(Q4 = A8 - -64 | 0) >> 2] = 0, E3[Q4 + 4 >> 2] = 0, E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, E3[A8 + 48 >> 2] = 0, E3[A8 + 52 >> 2] = 0, E3[A8 + 40 >> 2] = 0, E3[A8 + 44 >> 2] = 0) : TA(i4, 35040, 56 - Q4 | 0), o4 = (Q4 = 16711680 & (i4 = E3[A8 + 32 >> 2])) >>> 8 | 0, c4 = Q4 << 24, B4 = (Q4 = -16777216 & i4) >>> 24 | 0, Q4 = (c4 |= Q4 << 8) | -16777216 & ((255 & (Q4 = E3[A8 + 36 >> 2])) << 24 | i4 >>> 8) | 16711680 & ((16777215 & Q4) << 8 | i4 >>> 24) | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[A8 + 96 | 0] = Q4, C3[A8 + 97 | 0] = Q4 >>> 8, C3[A8 + 98 | 0] = Q4 >>> 16, C3[A8 + 99 | 0] = Q4 >>> 24, Q4 = o4 | B4 | i4 << 24 | (65280 & i4) << 8, Q4 |= o4 = 0, C3[A8 + 100 | 0] = Q4, C3[A8 + 101 | 0] = Q4 >>> 8, C3[A8 + 102 | 0] = Q4 >>> 16, C3[A8 + 103 | 0] = Q4 >>> 24, p3(A8, A8 + 40 | 0, g6, g6 + 256 | 0), Q4 = (Q4 = E3[A8 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[0 | I7] = Q4, C3[I7 + 1 | 0] = Q4 >>> 8, C3[I7 + 2 | 0] = Q4 >>> 16, C3[I7 + 3 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 4 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 4 | 0] = Q4, C3[I7 + 5 | 0] = Q4 >>> 8, C3[I7 + 6 | 0] = Q4 >>> 16, C3[I7 + 7 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 8 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 8 | 0] = Q4, C3[I7 + 9 | 0] = Q4 >>> 8, C3[I7 + 10 | 0] = Q4 >>> 16, C3[I7 + 11 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 12 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 12 | 0] = Q4, C3[I7 + 13 | 0] = Q4 >>> 8, C3[I7 + 14 | 0] = Q4 >>> 16, C3[I7 + 15 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 16 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 16 | 0] = Q4, C3[I7 + 17 | 0] = Q4 >>> 8, C3[I7 + 18 | 0] = Q4 >>> 16, C3[I7 + 19 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 20 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 20 | 0] = Q4, C3[I7 + 21 | 0] = Q4 >>> 8, C3[I7 + 22 | 0] = Q4 >>> 16, C3[I7 + 23 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 24 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 24 | 0] = Q4, C3[I7 + 25 | 0] = Q4 >>> 8, C3[I7 + 26 | 0] = Q4 >>> 16, C3[I7 + 27 | 0] = Q4 >>> 24, Q4 = (Q4 = E3[A8 + 28 >> 2]) << 24 | (65280 & Q4) << 8 | Q4 >>> 8 & 65280 | Q4 >>> 24, C3[I7 + 28 | 0] = Q4, C3[I7 + 29 | 0] = Q4 >>> 8, C3[I7 + 30 | 0] = Q4 >>> 16, C3[I7 + 31 | 0] = Q4 >>> 24, MI(g6, 288), MI(A8, 104), r3 = g6 + 288 | 0; + } + function gA(A8, I7, g6) { + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0; + if (r3 = B4 = r3 - 96 | 0, g6 >>> 0 >= 65 && (RA(A8), BA(A8, I7, g6), IA(A8, B4), g6 = 32, I7 = B4), RA(A8), E3[B4 + 88 >> 2] = 909522486, E3[B4 + 92 >> 2] = 909522486, E3[B4 + 80 >> 2] = 909522486, E3[B4 + 84 >> 2] = 909522486, E3[B4 + 72 >> 2] = 909522486, E3[B4 + 76 >> 2] = 909522486, E3[(c4 = f4 = B4 - -64 | 0) >> 2] = 909522486, E3[c4 + 4 >> 2] = 909522486, E3[B4 + 56 >> 2] = 909522486, E3[B4 + 60 >> 2] = 909522486, E3[B4 + 48 >> 2] = 909522486, E3[B4 + 52 >> 2] = 909522486, E3[B4 + 40 >> 2] = 909522486, E3[B4 + 44 >> 2] = 909522486, E3[B4 + 32 >> 2] = 909522486, E3[B4 + 36 >> 2] = 909522486, g6) { + if (g6 >>> 0 >= 4) for (D4 = 124 & g6; C3[0 | (o4 = (c4 = B4 + 32 | 0) + Q4 | 0)] = i3[0 | o4] ^ i3[I7 + Q4 | 0], C3[0 | (e4 = (o4 = 1 | Q4) + c4 | 0)] = i3[0 | e4] ^ i3[I7 + o4 | 0], C3[0 | (e4 = (o4 = 2 | Q4) + c4 | 0)] = i3[0 | e4] ^ i3[I7 + o4 | 0], C3[0 | (o4 = (o4 = c4) + (c4 = 3 | Q4) | 0)] = i3[0 | o4] ^ i3[I7 + c4 | 0], Q4 = Q4 + 4 | 0, (0 | D4) != (0 | (a4 = a4 + 4 | 0)); ) ; + if (a4 = 3 & g6) for (; C3[0 | (c4 = (B4 + 32 | 0) + Q4 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], Q4 = Q4 + 1 | 0, (0 | a4) != (0 | (y4 = y4 + 1 | 0)); ) ; + } + if (BA(A8, B4 + 32 | 0, 64), RA(c4 = A8 + 104 | 0), E3[B4 + 88 >> 2] = 1549556828, E3[B4 + 92 >> 2] = 1549556828, E3[B4 + 80 >> 2] = 1549556828, E3[B4 + 84 >> 2] = 1549556828, E3[B4 + 72 >> 2] = 1549556828, E3[B4 + 76 >> 2] = 1549556828, E3[f4 >> 2] = 1549556828, E3[f4 + 4 >> 2] = 1549556828, E3[B4 + 56 >> 2] = 1549556828, E3[B4 + 60 >> 2] = 1549556828, E3[B4 + 48 >> 2] = 1549556828, E3[B4 + 52 >> 2] = 1549556828, E3[B4 + 40 >> 2] = 1549556828, E3[B4 + 44 >> 2] = 1549556828, E3[B4 + 32 >> 2] = 1549556828, E3[B4 + 36 >> 2] = 1549556828, g6) { + if (y4 = 0, Q4 = 0, g6 >>> 0 >= 4) for (f4 = 124 & g6, a4 = 0; C3[0 | (D4 = (A8 = B4 + 32 | 0) + Q4 | 0)] = i3[0 | D4] ^ i3[I7 + Q4 | 0], C3[0 | (o4 = (D4 = 1 | Q4) + A8 | 0)] = i3[0 | o4] ^ i3[I7 + D4 | 0], C3[0 | (o4 = (D4 = 2 | Q4) + A8 | 0)] = i3[0 | o4] ^ i3[I7 + D4 | 0], C3[0 | (D4 = (o4 = A8) + (A8 = 3 | Q4) | 0)] = i3[0 | D4] ^ i3[A8 + I7 | 0], Q4 = Q4 + 4 | 0, (0 | f4) != (0 | (a4 = a4 + 4 | 0)); ) ; + if (A8 = 3 & g6) for (; C3[0 | (g6 = (B4 + 32 | 0) + Q4 | 0)] = i3[0 | g6] ^ i3[I7 + Q4 | 0], Q4 = Q4 + 1 | 0, (0 | A8) != (0 | (y4 = y4 + 1 | 0)); ) ; + } + return BA(c4, A8 = B4 + 32 | 0, 64), MI(A8, 64), MI(B4, 32), r3 = B4 + 96 | 0, 0; + } + function CA(A8, I7, g6, C4, B4, i4, o4) { + var c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0; + if (I7 - 65 >>> 0 < 4294967232 | o4 >>> 0 > 64) A8 = -1; + else { + e4 = c4 = r3, r3 = c4 = c4 - 512 & -64; + A: { + I: if (!(!(!(C4 | B4) | g6) | !A8 | ((D4 = 255 & I7) - 65 & 255) >>> 0 <= 191 | !(!(I7 = 255 & o4) || i4) | I7 >>> 0 >= 65)) { + if (I7) { + if (!i4) break I; + VA(c4 - -64 | 0, 0, 293), E3[c4 + 56 >> 2] = 327033209, E3[c4 + 60 >> 2] = 1541459225, E3[c4 + 48 >> 2] = -79577749, E3[c4 + 52 >> 2] = 528734635, E3[c4 + 40 >> 2] = 725511199, E3[c4 + 44 >> 2] = -1694144372, E3[c4 + 32 >> 2] = -1377402159, E3[c4 + 36 >> 2] = 1359893119, E3[c4 + 24 >> 2] = 1595750129, E3[c4 + 28 >> 2] = -1521486534, E3[c4 + 16 >> 2] = -23791573, E3[c4 + 20 >> 2] = 1013904242, E3[c4 + 8 >> 2] = -2067093701, E3[c4 + 12 >> 2] = -1150833019, E3[c4 >> 2] = -222443256 ^ (I7 << 8 | D4), E3[c4 + 4 >> 2] = I7 >>> 24 ^ 1779033703, VA((o4 = c4 + 384 | 0) + I7 | 0, 0, 128 - I7 | 0), TA(o4, i4, I7), TA(c4 + 96 | 0, o4, 128), E3[c4 + 352 >> 2] = 128, MI(o4, 128), I7 = 128; + } else VA(c4 - -64 | 0, 0, 293), E3[c4 + 56 >> 2] = 327033209, E3[c4 + 60 >> 2] = 1541459225, E3[c4 + 48 >> 2] = -79577749, E3[c4 + 52 >> 2] = 528734635, E3[c4 + 40 >> 2] = 725511199, E3[c4 + 44 >> 2] = -1694144372, E3[c4 + 32 >> 2] = -1377402159, E3[c4 + 36 >> 2] = 1359893119, E3[c4 + 24 >> 2] = 1595750129, E3[c4 + 28 >> 2] = -1521486534, E3[c4 + 16 >> 2] = -23791573, E3[c4 + 20 >> 2] = 1013904242, E3[c4 + 8 >> 2] = -2067093701, E3[c4 + 12 >> 2] = -1150833019, E3[c4 >> 2] = -222443256 ^ D4, E3[c4 + 4 >> 2] = 1779033703, I7 = 0; + g: if (C4 | B4) for (w4 = c4 + 224 | 0, a4 = c4 + 96 | 0; ; ) { + if (o4 = I7 + a4 | 0, !B4 & C4 >>> 0 <= (i4 = 256 - I7 | 0) >>> 0) { + TA(o4, g6, C4), E3[c4 + 352 >> 2] = C4 + E3[c4 + 352 >> 2]; + break g; + } + if (TA(o4, g6, i4), E3[c4 + 352 >> 2] = i4 + E3[c4 + 352 >> 2], y4 = I7 = E3[c4 + 68 >> 2], I7 = (f4 = (o4 = E3[c4 + 64 >> 2]) + 128 | 0) >>> 0 < 128 ? I7 + 1 | 0 : I7, E3[c4 + 64 >> 2] = f4, E3[c4 + 68 >> 2] = I7, I7 = E3[c4 + 76 >> 2], I7 = (y4 = o4 = -1 == (0 | y4) & o4 >>> 0 > 4294967167) >>> 0 > (o4 = o4 + E3[c4 + 72 >> 2] | 0) >>> 0 ? I7 + 1 | 0 : I7, E3[c4 + 72 >> 2] = o4, E3[c4 + 76 >> 2] = I7, h3(c4, a4), TA(a4, w4, 128), I7 = E3[c4 + 352 >> 2] - 128 | 0, E3[c4 + 352 >> 2] = I7, g6 = g6 + i4 | 0, !((B4 = B4 - (C4 >>> 0 < i4 >>> 0) | 0) | (C4 = C4 - i4 | 0))) break; + } + m3(c4, A8, D4), r3 = e4; + break A; + } + iI(), Q3(); + } + A8 = 0; + } + return A8; + } + function BA(A8, I7, g6) { + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0; + if (r3 = B4 = r3 - 288 | 0, g6) if (Q4 = E3[A8 + 36 >> 2], y4 = (D4 = E3[A8 + 32 >> 2]) + (a4 = g6 << 3) | 0, E3[A8 + 32 >> 2] = y4, c4 = (g6 >>> 29 | 0) + Q4 | 0, E3[A8 + 36 >> 2] = a4 >>> 0 > y4 >>> 0 ? c4 + 1 | 0 : c4, a4 = A8 + 40 | 0, true & (c4 = 64 - (y4 = 63 & ((7 & Q4) << 29 | D4 >>> 3)) | 0) >>> 0 <= g6 >>> 0) { + if (Q4 = 0, D4 = 0, (63 ^ y4) >>> 0 >= 3) for (h4 = 124 & c4; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], C3[(y4 + (w4 = 1 | Q4) | 0) + a4 | 0] = i3[I7 + w4 | 0], C3[(y4 + (w4 = 2 | Q4) | 0) + a4 | 0] = i3[I7 + w4 | 0], C3[(y4 + (w4 = 3 | Q4) | 0) + a4 | 0] = i3[I7 + w4 | 0], D4 = (Q4 = Q4 + 4 | 0) >>> 0 < 4 ? D4 + 1 | 0 : D4, (o4 = (t4 = t4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4) | (0 | t4) != (0 | h4); ) ; + if (o4 = 3 & c4) for (; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], D4 = (Q4 = Q4 + 1 | 0) ? D4 : D4 + 1 | 0, (f4 = (e4 = e4 + 1 | 0) ? f4 : f4 + 1 | 0) | (0 | o4) != (0 | e4); ) ; + if (p3(A8, a4, B4, f4 = B4 + 256 | 0), I7 = I7 + c4 | 0, !(o4 = 0 - ((g6 >>> 0 < c4 >>> 0) + 0 | 0) | 0) & (g6 = g6 - c4 | 0) >>> 0 > 63 | o4) for (; p3(A8, I7, B4, f4), I7 = I7 - -64 | 0, o4 = o4 - 1 | 0, !(o4 = (g6 = g6 + -64 | 0) >>> 0 < 4294967232 ? o4 + 1 | 0 : o4) & g6 >>> 0 > 63 | o4; ) ; + if (g6 | o4) { + if (A8 = 3 & g6, e4 = 0, f4 = 0, Q4 = 0, D4 = 0, !o4 & g6 >>> 0 >= 4 | o4) for (y4 = 60 & g6, g6 = 0, o4 = 0; C3[Q4 + a4 | 0] = i3[I7 + Q4 | 0], C3[(c4 = 1 | Q4) + a4 | 0] = i3[I7 + c4 | 0], C3[(c4 = 2 | Q4) + a4 | 0] = i3[I7 + c4 | 0], C3[(c4 = 3 | Q4) + a4 | 0] = i3[I7 + c4 | 0], D4 = (Q4 = Q4 + 4 | 0) >>> 0 < 4 ? D4 + 1 | 0 : D4, (o4 = (g6 = g6 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4) | (0 | g6) != (0 | y4); ) ; + if (A8) for (; C3[Q4 + a4 | 0] = i3[I7 + Q4 | 0], D4 = (Q4 = Q4 + 1 | 0) ? D4 : D4 + 1 | 0, (f4 = (e4 = e4 + 1 | 0) ? f4 : f4 + 1 | 0) | (0 | A8) != (0 | e4); ) ; + } + MI(B4, 288); + } else { + if (Q4 = 0, D4 = 0, g6 >>> 0 >= 4) for (A8 = -4 & g6; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], C3[(y4 + (c4 = 1 | Q4) | 0) + a4 | 0] = i3[I7 + c4 | 0], C3[(y4 + (c4 = 2 | Q4) | 0) + a4 | 0] = i3[I7 + c4 | 0], C3[(y4 + (c4 = 3 | Q4) | 0) + a4 | 0] = i3[I7 + c4 | 0], D4 = (Q4 = Q4 + 4 | 0) >>> 0 < 4 ? D4 + 1 | 0 : D4, (o4 = (t4 = t4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4) | (0 | A8) != (0 | t4); ) ; + if (A8 = 3 & g6) for (; C3[(Q4 + y4 | 0) + a4 | 0] = i3[I7 + Q4 | 0], D4 = (Q4 = Q4 + 1 | 0) ? D4 : D4 + 1 | 0, (f4 = (e4 = e4 + 1 | 0) ? f4 : f4 + 1 | 0) | (0 | A8) != (0 | e4); ) ; + } + r3 = B4 + 288 | 0; + } + function QA(A8, I7, g6, B4) { + var Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0; + A: { + if ((o4 = E3[A8 + 56 >> 2]) | (Q4 = E3[A8 + 60 >> 2])) { + if (e4 = D4 = 16 - o4 | 0, y4 = (D4 = (0 | (c4 = 0 - ((o4 >>> 0 > 16) + Q4 | 0) | 0)) == (0 | B4) & g6 >>> 0 > D4 >>> 0 | B4 >>> 0 > c4 >>> 0) ? e4 : g6, e4 = D4 = D4 ? c4 : B4, D4 | y4) { + if (D4 = A8 - -64 | 0, c4 = 0, o4 = 0, !e4 & y4 >>> 0 >= 4 | e4) for (f4 = -4 & y4; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], Q4 = (w4 = 1 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + w4 | 0], Q4 = (w4 = 2 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + w4 | 0], Q4 = (w4 = 3 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + w4 | 0], Q4 = o4, o4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? Q4 + 1 | 0 : Q4, Q4 = t4, t4 = Q4 = (a4 = a4 + 4 | 0) >>> 0 < 4 ? Q4 + 1 | 0 : Q4, (0 | a4) != (0 | f4) | (0 | e4) != (0 | Q4); ) ; + if (t4 = Q4 = 0, Q4 | (a4 = 3 & y4)) for (; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], o4 = (c4 = c4 + 1 | 0) ? o4 : o4 + 1 | 0, Q4 = h4, h4 = Q4 = (r4 = r4 + 1 | 0) ? Q4 : Q4 + 1 | 0, (0 | a4) != (0 | r4) | (0 | t4) != (0 | Q4); ) ; + o4 = E3[A8 + 56 >> 2], Q4 = E3[A8 + 60 >> 2]; + } + if (Q4 = Q4 + e4 | 0, Q4 = (o4 = o4 + y4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, E3[A8 + 56 >> 2] = o4, E3[A8 + 60 >> 2] = Q4, !Q4 & o4 >>> 0 < 16) break A; + z(A8, A8 - -64 | 0, 16, 0), E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, g6 = (o4 = g6) - y4 | 0, B4 = B4 - ((o4 >>> 0 < y4 >>> 0) + e4 | 0) | 0, I7 = I7 + y4 | 0; + } + if (!B4 & g6 >>> 0 >= 16 | B4 && (z(A8, I7, o4 = -16 & g6, B4), g6 &= 15, B4 = 0, I7 = I7 + o4 | 0), g6 | B4) { + if (D4 = A8 - -64 | 0, r4 = 0, h4 = 0, c4 = 0, o4 = 0, !B4 & g6 >>> 0 >= 4 | B4) for (y4 = 12 & g6, e4 = 0, a4 = 0; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], Q4 = (f4 = 1 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + f4 | 0], Q4 = (f4 = 2 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + f4 | 0], Q4 = (f4 = 3 | c4) + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + f4 | 0], o4 = (c4 = c4 + 4 | 0) >>> 0 < 4 ? o4 + 1 | 0 : o4, Q4 = t4, t4 = Q4 = (a4 = a4 + 4 | 0) >>> 0 < 4 ? Q4 + 1 | 0 : Q4, (0 | y4) != (0 | a4) | (0 | e4) != (0 | Q4); ) ; + if (t4 = Q4 = 0, Q4 | (a4 = 3 & g6)) for (; Q4 = c4 + E3[A8 + 56 >> 2] | 0, C3[Q4 + D4 | 0] = i3[I7 + c4 | 0], o4 = (c4 = c4 + 1 | 0) ? o4 : o4 + 1 | 0, Q4 = h4, h4 = Q4 = (r4 = r4 + 1 | 0) ? Q4 : Q4 + 1 | 0, (0 | a4) != (0 | r4) | (0 | t4) != (0 | Q4); ) ; + o4 = B4 + E3[A8 + 60 >> 2] | 0, o4 = (I7 = g6 + E3[A8 + 56 >> 2] | 0) >>> 0 < g6 >>> 0 ? o4 + 1 | 0 : o4, E3[A8 + 56 >> 2] = I7, E3[A8 + 60 >> 2] = o4; + } + } + } + function EA(A8, I7, g6) { + var C4, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0; + r4 = E3[I7 + 4 >> 2], B4 = E3[A8 + 4 >> 2], t4 = E3[I7 + 8 >> 2], Q4 = E3[A8 + 8 >> 2], h4 = E3[I7 + 12 >> 2], i4 = E3[A8 + 12 >> 2], k4 = E3[I7 + 16 >> 2], o4 = E3[A8 + 16 >> 2], n4 = E3[I7 + 20 >> 2], c4 = E3[A8 + 20 >> 2], e4 = E3[I7 + 24 >> 2], D4 = E3[A8 + 24 >> 2], s4 = E3[I7 + 28 >> 2], a4 = E3[A8 + 28 >> 2], F4 = E3[I7 + 32 >> 2], y4 = E3[A8 + 32 >> 2], S4 = E3[I7 + 36 >> 2], f4 = E3[A8 + 36 >> 2], g6 = 0 - g6 | 0, w4 = E3[A8 >> 2], E3[A8 >> 2] = g6 & (w4 ^ E3[I7 >> 2]) ^ w4, E3[A8 + 36 >> 2] = f4 ^ g6 & (f4 ^ S4), E3[A8 + 32 >> 2] = y4 ^ g6 & (y4 ^ F4), E3[A8 + 28 >> 2] = a4 ^ g6 & (a4 ^ s4), E3[A8 + 24 >> 2] = D4 ^ g6 & (D4 ^ e4), E3[A8 + 20 >> 2] = c4 ^ g6 & (c4 ^ n4), E3[A8 + 16 >> 2] = o4 ^ g6 & (o4 ^ k4), E3[A8 + 12 >> 2] = i4 ^ g6 & (i4 ^ h4), E3[A8 + 8 >> 2] = Q4 ^ g6 & (Q4 ^ t4), E3[A8 + 4 >> 2] = B4 ^ g6 & (B4 ^ r4), B4 = E3[A8 + 44 >> 2], r4 = E3[I7 + 44 >> 2], Q4 = E3[A8 + 48 >> 2], t4 = E3[I7 + 48 >> 2], i4 = E3[A8 + 52 >> 2], h4 = E3[I7 + 52 >> 2], o4 = E3[A8 + 56 >> 2], k4 = E3[I7 + 56 >> 2], c4 = E3[A8 + 60 >> 2], n4 = E3[I7 + 60 >> 2], D4 = E3[(e4 = A8 - -64 | 0) >> 2], s4 = E3[I7 - -64 >> 2], a4 = E3[A8 + 68 >> 2], F4 = E3[I7 + 68 >> 2], y4 = E3[A8 + 72 >> 2], S4 = E3[I7 + 72 >> 2], f4 = E3[A8 + 40 >> 2], w4 = E3[I7 + 40 >> 2], C4 = E3[A8 + 76 >> 2], E3[A8 + 76 >> 2] = C4 ^ g6 & (E3[I7 + 76 >> 2] ^ C4), E3[A8 + 72 >> 2] = y4 ^ g6 & (y4 ^ S4), E3[A8 + 68 >> 2] = a4 ^ g6 & (a4 ^ F4), E3[e4 >> 2] = D4 ^ g6 & (D4 ^ s4), E3[A8 + 60 >> 2] = c4 ^ g6 & (c4 ^ n4), E3[A8 + 56 >> 2] = o4 ^ g6 & (o4 ^ k4), E3[A8 + 52 >> 2] = i4 ^ g6 & (i4 ^ h4), E3[A8 + 48 >> 2] = Q4 ^ g6 & (Q4 ^ t4), E3[A8 + 44 >> 2] = B4 ^ g6 & (B4 ^ r4), E3[A8 + 40 >> 2] = f4 ^ g6 & (f4 ^ w4), B4 = E3[A8 + 84 >> 2], r4 = E3[I7 + 84 >> 2], Q4 = E3[A8 + 88 >> 2], t4 = E3[I7 + 88 >> 2], i4 = E3[A8 + 92 >> 2], h4 = E3[I7 + 92 >> 2], o4 = E3[A8 + 96 >> 2], k4 = E3[I7 + 96 >> 2], c4 = E3[A8 + 100 >> 2], n4 = E3[I7 + 100 >> 2], D4 = E3[A8 + 104 >> 2], e4 = E3[I7 + 104 >> 2], a4 = E3[A8 + 108 >> 2], s4 = E3[I7 + 108 >> 2], y4 = E3[A8 + 112 >> 2], F4 = E3[I7 + 112 >> 2], f4 = E3[A8 + 80 >> 2], S4 = E3[I7 + 80 >> 2], w4 = E3[I7 + 116 >> 2], I7 = E3[A8 + 116 >> 2], E3[A8 + 116 >> 2] = g6 & (w4 ^ I7) ^ I7, E3[A8 + 112 >> 2] = y4 ^ g6 & (y4 ^ F4), E3[A8 + 108 >> 2] = a4 ^ g6 & (a4 ^ s4), E3[A8 + 104 >> 2] = D4 ^ g6 & (D4 ^ e4), E3[A8 + 100 >> 2] = c4 ^ g6 & (c4 ^ n4), E3[A8 + 96 >> 2] = o4 ^ g6 & (o4 ^ k4), E3[A8 + 92 >> 2] = i4 ^ g6 & (i4 ^ h4), E3[A8 + 88 >> 2] = Q4 ^ g6 & (Q4 ^ t4), E3[A8 + 84 >> 2] = B4 ^ g6 & (B4 ^ r4), E3[A8 + 80 >> 2] = f4 ^ g6 & (f4 ^ S4); + } + function iA(A8, I7) { + var g6, C4, B4 = 0; + for (r3 = g6 = r3 - 192 | 0, U3(C4 = g6 + 144 | 0, I7), U3(B4 = g6 + 96 | 0, C4), U3(B4, B4), M3(B4, I7, B4), M3(C4, C4, B4), U3(I7 = g6 + 48 | 0, C4), M3(B4, B4, I7), U3(I7, B4), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(B4, I7, B4), U3(I7, B4), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(I7, I7, B4), U3(g6, I7), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), U3(g6, g6), M3(I7, g6, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(B4, I7, B4), U3(I7, B4), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(I7, I7, B4), U3(g6, I7), I7 = 1; U3(g6, g6), 100 != (0 | (I7 = I7 + 1 | 0)); ) ; + M3(I7 = g6 + 48 | 0, g6, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), U3(I7, I7), M3(B4 = g6 + 96 | 0, I7, B4), U3(B4, B4), U3(B4, B4), U3(B4, B4), U3(B4, B4), U3(B4, B4), M3(A8, B4, g6 + 144 | 0), r3 = g6 + 192 | 0; + } + function oA(A8, I7, g6) { + var C4, B4, Q4, i4, o4, D4, a4, y4, f4 = 0; + r3 = C4 = r3 - 128 | 0, E3[A8 >> 2] = 1, E3[A8 + 4 >> 2] = 0, E3[A8 + 8 >> 2] = 0, E3[A8 + 12 >> 2] = 0, E3[A8 + 16 >> 2] = 0, E3[A8 + 20 >> 2] = 0, E3[A8 + 24 >> 2] = 0, E3[A8 + 28 >> 2] = 0, E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, E3[A8 + 40 >> 2] = 1, VA(A8 + 44 | 0, 0, 76), EA(A8, I7 = c3(I7, 960) + 2688 | 0, (255 & (1 ^ (f4 = g6 - ((g6 >> 31 & g6) << 1) | 0))) - 1 >>> 31 | 0), EA(A8, I7 + 120 | 0, (255 & (2 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 240 | 0, (255 & (3 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 360 | 0, (255 & (4 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 480 | 0, (255 & (5 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 600 | 0, (255 & (6 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 720 | 0, (255 & (7 ^ f4)) - 1 >>> 31 | 0), EA(A8, I7 + 840 | 0, (255 & (8 ^ f4)) - 1 >>> 31 | 0), I7 = E3[A8 + 76 >> 2], E3[C4 + 40 >> 2] = E3[A8 + 72 >> 2], E3[C4 + 44 >> 2] = I7, f4 = E3[4 + (I7 = A8 - -64 | 0) >> 2], E3[C4 + 32 >> 2] = E3[I7 >> 2], E3[C4 + 36 >> 2] = f4, I7 = E3[A8 + 60 >> 2], E3[C4 + 24 >> 2] = E3[A8 + 56 >> 2], E3[C4 + 28 >> 2] = I7, I7 = E3[A8 + 52 >> 2], E3[C4 + 16 >> 2] = E3[A8 + 48 >> 2], E3[C4 + 20 >> 2] = I7, I7 = E3[A8 + 44 >> 2], E3[C4 + 8 >> 2] = E3[A8 + 40 >> 2], E3[C4 + 12 >> 2] = I7, I7 = E3[A8 + 12 >> 2], E3[C4 + 56 >> 2] = E3[A8 + 8 >> 2], E3[C4 + 60 >> 2] = I7, f4 = E3[A8 + 20 >> 2], E3[(I7 = C4 - -64 | 0) >> 2] = E3[A8 + 16 >> 2], E3[I7 + 4 >> 2] = f4, I7 = E3[A8 + 28 >> 2], E3[C4 + 72 >> 2] = E3[A8 + 24 >> 2], E3[C4 + 76 >> 2] = I7, I7 = E3[A8 + 36 >> 2], E3[C4 + 80 >> 2] = E3[A8 + 32 >> 2], E3[C4 + 84 >> 2] = I7, I7 = E3[A8 + 4 >> 2], E3[C4 + 48 >> 2] = E3[A8 >> 2], E3[C4 + 52 >> 2] = I7, I7 = E3[A8 + 84 >> 2], f4 = E3[A8 + 88 >> 2], B4 = E3[A8 + 92 >> 2], Q4 = E3[A8 + 96 >> 2], i4 = E3[A8 + 100 >> 2], o4 = E3[A8 + 104 >> 2], D4 = E3[A8 + 108 >> 2], a4 = E3[A8 + 112 >> 2], y4 = E3[A8 + 80 >> 2], E3[C4 + 124 >> 2] = 0 - E3[A8 + 116 >> 2], E3[C4 + 120 >> 2] = 0 - a4, E3[C4 + 116 >> 2] = 0 - D4, E3[C4 + 112 >> 2] = 0 - o4, E3[C4 + 108 >> 2] = 0 - i4, E3[C4 + 104 >> 2] = 0 - Q4, E3[C4 + 100 >> 2] = 0 - B4, E3[C4 + 96 >> 2] = 0 - f4, E3[C4 + 92 >> 2] = 0 - I7, E3[C4 + 88 >> 2] = 0 - y4, EA(A8, C4 + 8 | 0, (128 & g6) >>> 7 | 0), r3 = C4 + 128 | 0; + } + function cA(A8, I7, g6, B4) { + var Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (g6 | B4) A: for (y4 = A8 + 224 | 0, D4 = A8 + 96 | 0, E4 = i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24; ; ) { + if (Q4 = E4 + D4 | 0, !B4 & g6 >>> 0 <= (o4 = 256 - E4 | 0) >>> 0) { + TA(Q4, I7, g6), I7 = g6 + (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) | 0, C3[A8 + 352 | 0] = I7, C3[A8 + 353 | 0] = I7 >>> 8, C3[A8 + 354 | 0] = I7 >>> 16, C3[A8 + 355 | 0] = I7 >>> 24; + break A; + } + if (TA(Q4, I7, o4), Q4 = (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) + o4 | 0, C3[A8 + 352 | 0] = Q4, C3[A8 + 353 | 0] = Q4 >>> 8, C3[A8 + 354 | 0] = Q4 >>> 16, C3[A8 + 355 | 0] = Q4 >>> 24, a4 = E4 = i3[A8 + 68 | 0] | i3[A8 + 69 | 0] << 8 | i3[A8 + 70 | 0] << 16 | i3[A8 + 71 | 0] << 24, E4 = (c4 = 128 + (Q4 = i3[A8 + 64 | 0] | i3[A8 + 65 | 0] << 8 | i3[A8 + 66 | 0] << 16 | i3[A8 + 67 | 0] << 24) | 0) >>> 0 < 128 ? E4 + 1 | 0 : E4, C3[A8 + 64 | 0] = c4, C3[A8 + 65 | 0] = c4 >>> 8, C3[A8 + 66 | 0] = c4 >>> 16, C3[A8 + 67 | 0] = c4 >>> 24, C3[A8 + 68 | 0] = E4, C3[A8 + 69 | 0] = E4 >>> 8, C3[A8 + 70 | 0] = E4 >>> 16, C3[A8 + 71 | 0] = E4 >>> 24, E4 = i3[A8 + 76 | 0] | i3[A8 + 77 | 0] << 8 | i3[A8 + 78 | 0] << 16 | i3[A8 + 79 | 0] << 24, E4 = (a4 = Q4 = -1 == (0 | a4) & Q4 >>> 0 > 4294967167) >>> 0 > (Q4 = Q4 + (i3[A8 + 72 | 0] | i3[A8 + 73 | 0] << 8 | i3[A8 + 74 | 0] << 16 | i3[A8 + 75 | 0] << 24) | 0) >>> 0 ? E4 + 1 | 0 : E4, C3[A8 + 72 | 0] = Q4, C3[A8 + 73 | 0] = Q4 >>> 8, C3[A8 + 74 | 0] = Q4 >>> 16, C3[A8 + 75 | 0] = Q4 >>> 24, C3[A8 + 76 | 0] = E4, C3[A8 + 77 | 0] = E4 >>> 8, C3[A8 + 78 | 0] = E4 >>> 16, C3[A8 + 79 | 0] = E4 >>> 24, h3(A8, D4), TA(D4, y4, 128), Q4 = E4 = (i3[A8 + 352 | 0] | i3[A8 + 353 | 0] << 8 | i3[A8 + 354 | 0] << 16 | i3[A8 + 355 | 0] << 24) - 128 | 0, C3[A8 + 352 | 0] = Q4, C3[A8 + 353 | 0] = Q4 >>> 8, C3[A8 + 354 | 0] = Q4 >>> 16, C3[A8 + 355 | 0] = Q4 >>> 24, I7 = I7 + o4 | 0, !((B4 = B4 - (g6 >>> 0 < o4 >>> 0) | 0) | (g6 = g6 - o4 | 0))) break; + } + return 0; + } + function DA(A8, I7) { + var g6, C4 = 0, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0; + C4 = E3[I7 + 4 >> 2], Q4 = E3[I7 + 44 >> 2], i4 = E3[I7 + 8 >> 2], o4 = E3[I7 + 48 >> 2], c4 = E3[I7 + 12 >> 2], D4 = E3[I7 + 52 >> 2], a4 = E3[I7 + 16 >> 2], y4 = E3[I7 + 56 >> 2], f4 = E3[I7 + 20 >> 2], e4 = E3[I7 + 60 >> 2], w4 = E3[I7 + 24 >> 2], r4 = E3[(B4 = I7 - -64 | 0) >> 2], t4 = E3[I7 + 28 >> 2], h4 = E3[I7 + 68 >> 2], k4 = E3[I7 + 32 >> 2], n4 = E3[I7 + 72 >> 2], s4 = E3[I7 + 36 >> 2], g6 = E3[I7 + 76 >> 2], E3[A8 >> 2] = E3[I7 >> 2] + E3[I7 + 40 >> 2], E3[A8 + 36 >> 2] = s4 + g6, E3[A8 + 32 >> 2] = k4 + n4, E3[A8 + 28 >> 2] = t4 + h4, E3[A8 + 24 >> 2] = w4 + r4, E3[A8 + 20 >> 2] = f4 + e4, E3[A8 + 16 >> 2] = a4 + y4, E3[A8 + 12 >> 2] = c4 + D4, E3[A8 + 8 >> 2] = i4 + o4, E3[A8 + 4 >> 2] = C4 + Q4, C4 = E3[I7 + 4 >> 2], Q4 = E3[I7 + 44 >> 2], i4 = E3[I7 + 8 >> 2], o4 = E3[I7 + 48 >> 2], c4 = E3[I7 + 12 >> 2], D4 = E3[I7 + 52 >> 2], a4 = E3[I7 + 16 >> 2], y4 = E3[I7 + 56 >> 2], f4 = E3[I7 + 20 >> 2], e4 = E3[I7 + 60 >> 2], w4 = E3[I7 + 24 >> 2], B4 = E3[B4 >> 2], r4 = E3[I7 + 28 >> 2], t4 = E3[I7 + 68 >> 2], h4 = E3[I7 + 32 >> 2], k4 = E3[I7 + 72 >> 2], n4 = E3[I7 >> 2], s4 = E3[I7 + 40 >> 2], E3[A8 + 76 >> 2] = E3[I7 + 76 >> 2] - E3[I7 + 36 >> 2], E3[A8 + 72 >> 2] = k4 - h4, E3[A8 + 68 >> 2] = t4 - r4, E3[A8 - -64 >> 2] = B4 - w4, E3[A8 + 60 >> 2] = e4 - f4, E3[A8 + 56 >> 2] = y4 - a4, E3[A8 + 52 >> 2] = D4 - c4, E3[A8 + 48 >> 2] = o4 - i4, E3[A8 + 44 >> 2] = Q4 - C4, E3[A8 + 40 >> 2] = s4 - n4, C4 = E3[I7 + 84 >> 2], E3[A8 + 80 >> 2] = E3[I7 + 80 >> 2], E3[A8 + 84 >> 2] = C4, C4 = E3[I7 + 92 >> 2], E3[A8 + 88 >> 2] = E3[I7 + 88 >> 2], E3[A8 + 92 >> 2] = C4, C4 = E3[I7 + 100 >> 2], E3[A8 + 96 >> 2] = E3[I7 + 96 >> 2], E3[A8 + 100 >> 2] = C4, C4 = E3[I7 + 108 >> 2], E3[A8 + 104 >> 2] = E3[I7 + 104 >> 2], E3[A8 + 108 >> 2] = C4, C4 = E3[I7 + 116 >> 2], E3[A8 + 112 >> 2] = E3[I7 + 112 >> 2], E3[A8 + 116 >> 2] = C4, M3(A8 + 120 | 0, I7 + 120 | 0, 1424); + } + function aA(A8, I7, g6) { + var C4, B4, Q4, i4, o4, c4, D4, a4, y4, f4, e4, w4, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0; + t4 = E3[I7 + 12 >> 2], h4 = E3[I7 + 8 >> 2], k4 = E3[I7 + 4 >> 2], C4 = r3 + -64 & -64, I7 = E3[I7 >> 2], E3[C4 >> 2] = E3[35248 + ((255 & I7) << 2) >> 2], E3[C4 + 4 >> 2] = E3[35248 + (k4 >>> 6 & 1020) >> 2], E3[C4 + 8 >> 2] = E3[35248 + (h4 >>> 14 & 1020) >> 2], E3[C4 + 12 >> 2] = E3[35248 + (t4 >>> 22 & 1020) >> 2], E3[C4 + 16 >> 2] = E3[35248 + ((255 & k4) << 2) >> 2], E3[C4 + 20 >> 2] = E3[35248 + (h4 >>> 6 & 1020) >> 2], E3[C4 + 24 >> 2] = E3[35248 + (t4 >>> 14 & 1020) >> 2], E3[C4 + 28 >> 2] = E3[35248 + (I7 >>> 22 & 1020) >> 2], E3[C4 + 32 >> 2] = E3[35248 + ((255 & h4) << 2) >> 2], E3[C4 + 36 >> 2] = E3[35248 + (t4 >>> 6 & 1020) >> 2], E3[C4 + 40 >> 2] = E3[35248 + (I7 >>> 14 & 1020) >> 2], E3[C4 + 44 >> 2] = E3[35248 + (k4 >>> 22 & 1020) >> 2], E3[C4 + 48 >> 2] = E3[35248 + ((255 & t4) << 2) >> 2], E3[C4 + 52 >> 2] = E3[35248 + (I7 >>> 6 & 1020) >> 2], E3[C4 + 56 >> 2] = E3[35248 + (k4 >>> 14 & 1020) >> 2], E3[C4 + 60 >> 2] = E3[35248 + (h4 >>> 22 & 1020) >> 2], I7 = E3[C4 + 12 >> 2], t4 = E3[C4 >> 2], h4 = E3[C4 + 4 >> 2], k4 = E3[C4 + 8 >> 2], B4 = E3[C4 + 28 >> 2], Q4 = E3[C4 + 16 >> 2], i4 = E3[C4 + 20 >> 2], o4 = E3[C4 + 24 >> 2], c4 = E3[C4 + 44 >> 2], D4 = E3[C4 + 32 >> 2], a4 = E3[C4 + 36 >> 2], y4 = E3[C4 + 40 >> 2], f4 = E3[g6 >> 2], e4 = E3[g6 + 4 >> 2], w4 = E3[g6 + 8 >> 2], n4 = A8, s4 = E3[g6 + 12 >> 2] ^ E3[C4 + 48 >> 2] ^ gI(E3[C4 + 52 >> 2], 8) ^ gI(E3[C4 + 56 >> 2], 16) ^ gI(E3[C4 + 60 >> 2], 24), E3[n4 + 12 >> 2] = s4, n4 = A8, s4 = gI(a4, 8) ^ D4 ^ gI(y4, 16) ^ gI(c4, 24) ^ w4, E3[n4 + 8 >> 2] = s4, n4 = A8, s4 = gI(i4, 8) ^ Q4 ^ gI(o4, 16) ^ gI(B4, 24) ^ e4, E3[n4 + 4 >> 2] = s4, n4 = A8, s4 = gI(h4, 8) ^ t4 ^ gI(k4, 16) ^ gI(I7, 24) ^ f4, E3[n4 >> 2] = s4; + } + function yA(A8, I7) { + var g6, B4, Q4, i4, o4, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0; + (D4 = E3[A8 + 56 >> 2]) | (a4 = E3[A8 + 60 >> 2]) && (C3[(f4 = A8 - -64 | 0) + D4 | 0] = 1, !((k4 = D4 + 1 | 0) ? a4 : a4 + 1 | 0) & k4 >>> 0 <= 15 && VA(65 + (A8 + D4 | 0) | 0, 0, 15 - D4 | 0), C3[A8 + 80 | 0] = 1, z(A8, f4, 16, 0)), k4 = E3[A8 + 52 >> 2], t4 = E3[A8 + 48 >> 2], f4 = E3[A8 + 44 >> 2], D4 = E3[A8 + 24 >> 2], e4 = E3[A8 + 28 >> 2] + (D4 >>> 26 | 0) | 0, y4 = E3[A8 + 32 >> 2] + (e4 >>> 26 | 0) | 0, g6 = E3[A8 + 36 >> 2] + (y4 >>> 26 | 0) | 0, a4 = (r4 = (D4 = (D4 = (67108863 & D4) + ((w4 = E3[A8 + 20 >> 2] + c3(g6 >>> 26 | 0, 5) | 0) >>> 26 | 0) | 0) & (e4 = (y4 = (o4 = (67108863 & g6) + ((i4 = (B4 = 67108863 & y4) + ((Q4 = (h4 = 67108863 & e4) + ((w4 = D4 + ((a4 = 5 + (r4 = 67108863 & w4) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) >>> 26 | 0) | 0) - 67108864 | 0) >> 31) | w4 & (y4 = 67108863 & (w4 = (y4 >>> 31 | 0) - 1 | 0))) << 26 | a4 & y4 | e4 & r4) + E3[A8 + 40 >> 2] | 0, C3[0 | I7] = a4, C3[I7 + 1 | 0] = a4 >>> 8, C3[I7 + 2 | 0] = a4 >>> 16, C3[I7 + 3 | 0] = a4 >>> 24, r4 = a4 >>> 0 < r4 >>> 0, a4 = 0, a4 = (D4 = (h4 = e4 & h4 | y4 & Q4) << 20 | D4 >>> 6) >>> 0 > (D4 = D4 + f4 | 0) >>> 0 ? 1 : a4, a4 = (f4 = D4) >>> 0 > (D4 = D4 + r4 | 0) >>> 0 ? a4 + 1 | 0 : a4, C3[I7 + 4 | 0] = D4, C3[I7 + 5 | 0] = D4 >>> 8, C3[I7 + 6 | 0] = D4 >>> 16, C3[I7 + 7 | 0] = D4 >>> 24, D4 = 0, f4 = (f4 = (y4 = e4 & B4 | y4 & i4) << 14 | h4 >>> 12) >>> 0 > (t4 = f4 + t4 | 0) >>> 0 ? 1 : D4, D4 = t4, t4 = a4, D4 = D4 + a4 | 0, a4 = f4, a4 = D4 >>> 0 < t4 >>> 0 ? a4 + 1 | 0 : a4, C3[I7 + 8 | 0] = D4, C3[I7 + 9 | 0] = D4 >>> 8, C3[I7 + 10 | 0] = D4 >>> 16, C3[I7 + 11 | 0] = D4 >>> 24, a4 = (D4 = (D4 = (w4 & o4 | e4 & g6) << 8 | y4 >>> 18) + k4 | 0) + a4 | 0, C3[I7 + 12 | 0] = a4, C3[I7 + 13 | 0] = a4 >>> 8, C3[I7 + 14 | 0] = a4 >>> 16, C3[I7 + 15 | 0] = a4 >>> 24, MI(A8, 88); + } + function fA(A8, I7, g6) { + var B4, Q4 = 0; + return r3 = B4 = r3 - 16 | 0, C3[B4 + 15 | 0] = 0, Q4 = -1, 0 | vI[E3[8806]](A8, I7, g6) || (C3[B4 + 15 | 0] = i3[0 | A8] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 1 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 2 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 3 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 4 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 5 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 6 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 7 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 8 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 9 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 10 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 11 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 12 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 13 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 14 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 15 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 16 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 17 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 18 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 19 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 20 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 21 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 22 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 23 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 24 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 25 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 26 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 27 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 28 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 29 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 30 | 0] | i3[B4 + 15 | 0], C3[B4 + 15 | 0] = i3[A8 + 31 | 0] | i3[B4 + 15 | 0], Q4 = (i3[B4 + 15 | 0] << 23) - 8388608 >> 31), r3 = B4 + 16 | 0, Q4; + } + function eA(A8, I7) { + var g6, B4, Q4, i4, o4, D4, a4, y4 = 0, f4 = 0; + B4 = E3[I7 + 32 >> 2], Q4 = E3[I7 + 28 >> 2], i4 = E3[I7 + 24 >> 2], o4 = E3[I7 + 20 >> 2], D4 = E3[I7 + 16 >> 2], a4 = E3[I7 + 12 >> 2], y4 = E3[I7 + 4 >> 2], f4 = E3[I7 >> 2], g6 = E3[I7 + 36 >> 2], I7 = E3[I7 + 8 >> 2], f4 = c3((B4 + (Q4 + (i4 + (o4 + (D4 + (a4 + ((y4 + (f4 + (c3(g6, 19) + 16777216 >>> 25 | 0) >> 26) >> 25) + I7 >> 26) >> 25) >> 26) >> 25) >> 26) >> 25) >> 26) + g6 >> 25, 19) + f4 | 0, C3[0 | A8] = f4, C3[A8 + 2 | 0] = f4 >>> 16, C3[A8 + 1 | 0] = f4 >>> 8, y4 = y4 + (f4 >> 26) | 0, C3[A8 + 5 | 0] = y4 >>> 14, C3[A8 + 4 | 0] = y4 >>> 6, C3[A8 + 3 | 0] = f4 >>> 24 & 3 | y4 << 2, I7 = I7 + (y4 >> 25) | 0, C3[A8 + 8 | 0] = I7 >>> 13, C3[A8 + 7 | 0] = I7 >>> 5, C3[A8 + 6 | 0] = I7 << 3 | (29360128 & y4) >>> 22, f4 = (I7 >> 26) + a4 | 0, C3[A8 + 11 | 0] = f4 >>> 11, C3[A8 + 10 | 0] = f4 >>> 3, C3[A8 + 9 | 0] = f4 << 5 | (65011712 & I7) >>> 21, y4 = (f4 >> 25) + D4 | 0, C3[A8 + 15 | 0] = y4 >>> 18, C3[A8 + 14 | 0] = y4 >>> 10, C3[A8 + 13 | 0] = y4 >>> 2, I7 = (y4 >> 26) + o4 | 0, C3[A8 + 16 | 0] = I7, C3[A8 + 12 | 0] = y4 << 6 | (33030144 & f4) >>> 19, C3[A8 + 18 | 0] = I7 >>> 16, C3[A8 + 17 | 0] = I7 >>> 8, y4 = (I7 >> 25) + i4 | 0, C3[A8 + 21 | 0] = y4 >>> 15, C3[A8 + 20 | 0] = y4 >>> 7, C3[A8 + 19 | 0] = I7 >>> 24 & 1 | y4 << 1, I7 = (y4 >> 26) + Q4 | 0, C3[A8 + 24 | 0] = I7 >>> 13, C3[A8 + 23 | 0] = I7 >>> 5, C3[A8 + 22 | 0] = I7 << 3 | (58720256 & y4) >>> 23, y4 = (I7 >> 25) + B4 | 0, C3[A8 + 27 | 0] = y4 >>> 12, C3[A8 + 26 | 0] = y4 >>> 4, C3[A8 + 25 | 0] = y4 << 4 | (31457280 & I7) >>> 21, I7 = g6 + (y4 >> 26) | 0, C3[A8 + 30 | 0] = I7 >>> 10, C3[A8 + 29 | 0] = I7 >>> 2, C3[A8 + 31 | 0] = (33292288 & I7) >>> 18, C3[A8 + 28 | 0] = I7 << 6 | (66060288 & y4) >>> 20; + } + function wA(A8, I7, g6) { + var B4, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = B4 = r3 - 192 | 0, g6 >>> 0 >= 129 && (MA(A8), W(A8, I7, g6, 0), v3(A8, B4), g6 = 64, I7 = B4), MA(A8), VA(B4 - -64 | 0, 54, 128), g6) { + if (g6 >>> 0 >= 4) for (y4 = 252 & g6; C3[0 | (Q4 = (o4 = B4 - -64 | 0) + E4 | 0)] = i3[0 | Q4] ^ i3[I7 + E4 | 0], C3[0 | (c4 = (Q4 = 1 | E4) + o4 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (c4 = (Q4 = 2 | E4) + o4 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (Q4 = (Q4 = o4) + (o4 = 3 | E4) | 0)] = i3[0 | Q4] ^ i3[I7 + o4 | 0], E4 = E4 + 4 | 0, (0 | y4) != (0 | (D4 = D4 + 4 | 0)); ) ; + if (D4 = 3 & g6) for (; C3[0 | (o4 = (B4 - -64 | 0) + E4 | 0)] = i3[0 | o4] ^ i3[I7 + E4 | 0], E4 = E4 + 1 | 0, (0 | D4) != (0 | (a4 = a4 + 1 | 0)); ) ; + } + if (W(A8, E4 = B4 - -64 | 0, 128, 0), MA(o4 = A8 + 208 | 0), VA(E4, 92, 128), g6) { + if (a4 = 0, E4 = 0, g6 >>> 0 >= 4) for (y4 = 252 & g6, D4 = 0; C3[0 | (Q4 = (A8 = B4 - -64 | 0) + E4 | 0)] = i3[0 | Q4] ^ i3[I7 + E4 | 0], C3[0 | (c4 = (Q4 = 1 | E4) + A8 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (c4 = (Q4 = 2 | E4) + A8 | 0)] = i3[0 | c4] ^ i3[I7 + Q4 | 0], C3[0 | (Q4 = (Q4 = A8) + (A8 = 3 | E4) | 0)] = i3[0 | Q4] ^ i3[A8 + I7 | 0], E4 = E4 + 4 | 0, (0 | y4) != (0 | (D4 = D4 + 4 | 0)); ) ; + if (A8 = 3 & g6) for (; C3[0 | (g6 = (B4 - -64 | 0) + E4 | 0)] = i3[0 | g6] ^ i3[I7 + E4 | 0], E4 = E4 + 1 | 0, (0 | A8) != (0 | (a4 = a4 + 1 | 0)); ) ; + } + return W(o4, A8 = B4 - -64 | 0, 128, 0), MI(A8, 128), MI(B4, 64), r3 = B4 + 192 | 0, 0; + } + function rA(A8, I7) { + var g6; + return E3[12 + (g6 = r3 - 16 | 0) >> 2] = A8, E3[g6 + 8 >> 2] = I7, E3[g6 + 4 >> 2] = 0, E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2]] ^ i3[E3[g6 + 8 >> 2]], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 1 | 0] ^ i3[E3[g6 + 8 >> 2] + 1 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 2 | 0] ^ i3[E3[g6 + 8 >> 2] + 2 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 3 | 0] ^ i3[E3[g6 + 8 >> 2] + 3 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 4 | 0] ^ i3[E3[g6 + 8 >> 2] + 4 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 5 | 0] ^ i3[E3[g6 + 8 >> 2] + 5 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 6 | 0] ^ i3[E3[g6 + 8 >> 2] + 6 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 7 | 0] ^ i3[E3[g6 + 8 >> 2] + 7 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 8 | 0] ^ i3[E3[g6 + 8 >> 2] + 8 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 9 | 0] ^ i3[E3[g6 + 8 >> 2] + 9 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 10 | 0] ^ i3[E3[g6 + 8 >> 2] + 10 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 11 | 0] ^ i3[E3[g6 + 8 >> 2] + 11 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 12 | 0] ^ i3[E3[g6 + 8 >> 2] + 12 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 13 | 0] ^ i3[E3[g6 + 8 >> 2] + 13 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 14 | 0] ^ i3[E3[g6 + 8 >> 2] + 14 | 0], E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + 15 | 0] ^ i3[E3[g6 + 8 >> 2] + 15 | 0], (E3[g6 + 4 >> 2] - 1 >>> 8 & 1) - 1 | 0; + } + function tA(A8, I7, g6, C4, B4, Q4, i4) { + var o4, c4, D4, a4 = 0, y4 = 0, f4 = 0, e4 = 0; + r3 = o4 = r3 - 352 | 0, AA(o4, Q4, i4); + A: { + if (!(((a4 = !!(0 | B4)) | !B4 & C4 >>> 0 > A8 - g6 >>> 0) & A8 >>> 0 > g6 >>> 0) & (!B4 & g6 - A8 >>> 0 >= C4 >>> 0 | A8 >>> 0 >= g6 >>> 0)) { + if (E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, y4 = (i4 = (a4 = !!(0 | B4)) | !B4 & C4 >>> 0 >= 32) ? 32 : C4, f4 = i4 ? 0 : B4, i4 = a4 | !B4 & C4 >>> 0 > 32, !(C4 | B4)) { + e4 = 1; + break A; + } + } else g6 = lA(A8, g6, C4), E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, y4 = (i4 = a4 | !B4 & C4 >>> 0 >= 32) ? 32 : C4, f4 = i4 ? 0 : B4, i4 = a4 | !B4 & C4 >>> 0 > 32; + TA(o4 - -64 | 0, g6, y4), e4 = 0; + } + return a4 = f4, oI(c4 = o4 + 32 | 0, c4, D4 = y4 + 32 | 0, a4 = D4 >>> 0 < 32 ? a4 + 1 | 0 : a4, a4 = Q4 + 16 | 0, o4), nI(o4 + 96 | 0, c4), e4 || TA(A8, o4 - -64 | 0, y4), MI(o4 + 32 | 0, 64), i4 && DI(A8 + y4 | 0, g6 + y4 | 0, C4 - y4 | 0, B4 - ((C4 >>> 0 < y4 >>> 0) + f4 | 0) | 0, a4, o4), MI(o4, 32), rI(g6 = o4 + 96 | 0, A8, C4, B4), sI(g6, I7), MI(g6, 256), r3 = o4 + 352 | 0, 0; + } + function hA(A8, I7) { + var g6, C4 = 0, B4 = 0; + g6 = I7; + A: { + I: { + g: { + if (I7 &= 255) { + if (3 & A8) for (; ; ) { + if (!(C4 = i3[0 | A8]) | (0 | I7) == (0 | C4)) break A; + if (!(3 & (A8 = A8 + 1 | 0))) break; + } + if (-2139062144 != (-2139062144 & ((C4 = E3[A8 >> 2]) | 16843008 - C4))) break g; + for (B4 = c3(I7, 16843009); ; ) { + if (-2139062144 != (-2139062144 & (16843008 - (I7 = C4 ^ B4) | I7))) break g; + if (C4 = E3[A8 + 4 >> 2], A8 = I7 = A8 + 4 | 0, -2139062144 != (-2139062144 & (16843008 - C4 | C4))) break; + } + break I; + } + C4 = A8; + C: { + B: { + Q: if (3 & A8) { + if (I7 = 0, !i3[0 | A8]) break C; + for (; ; ) { + if (!(3 & (A8 = A8 + 1 | 0))) break Q; + if (!i3[0 | A8]) break; + } + break B; + } + for (; I7 = A8, A8 = A8 + 4 | 0, -2139062144 == (-2139062144 & (16843008 - (B4 = E3[I7 >> 2]) | B4)); ) ; + for (; I7 = (A8 = I7) + 1 | 0, i3[0 | A8]; ) ; + } + I7 = A8 - C4 | 0; + } + A8 = I7 + C4 | 0; + break A; + } + I7 = A8; + } + for (; ; ) { + if (!(C4 = i3[0 | (A8 = I7)])) break A; + if (I7 = A8 + 1 | 0, (0 | C4) == (255 & g6)) break; + } + } + return i3[0 | A8] == (255 & g6) ? A8 : 0; + } + function kA(A8, I7, g6, C4, B4, Q4, i4) { + var o4, c4, D4 = 0, a4 = 0, y4 = 0; + r3 = o4 = r3 - 96 | 0, AA(o4, Q4, i4), i4 = o4 + 32 | 0, c4 = Q4 + 16 | 0, vI[E3[8808]](i4, 32, 0, c4, o4), Q4 = -1; + A: { + I: if (!(0 | vI[E3[8802]](g6, I7, C4, B4, i4))) { + if (Q4 = 0, !A8) break A; + g: { + if (!(((g6 = !!(0 | B4)) | !B4 & C4 >>> 0 > I7 - A8 >>> 0) & A8 >>> 0 < I7 >>> 0) & (!B4 & C4 >>> 0 <= A8 - I7 >>> 0 | A8 >>> 0 <= I7 >>> 0)) { + if (!(C4 | B4)) break g; + g6 = (Q4 = !B4 & C4 >>> 0 >= 32 | !!(0 | B4)) ? 32 : C4, D4 = Q4 ? 0 : B4; + } else I7 = lA(A8, I7, C4), g6 = (Q4 = g6 | !B4 & C4 >>> 0 >= 32) ? 32 : C4, D4 = Q4 ? 0 : B4; + if (Q4 = D4, y4 = TA(o4 - -64 | 0, I7, g6), oI(i4 = o4 + 32 | 0, i4, a4 = g6 + 32 | 0, Q4 = a4 >>> 0 < 32 ? Q4 + 1 | 0 : Q4, c4, o4), A8 = TA(A8, y4, g6), MI(i4, 64), Q4 = 0, !B4 & C4 >>> 0 < 33) break I; + DI(A8 + g6 | 0, I7 + g6 | 0, C4 - g6 | 0, B4 - (D4 + (g6 >>> 0 > C4 >>> 0) | 0) | 0, c4, o4); + break I; + } + oI(A8 = o4 + 32 | 0, A8, 32, 0, c4, o4), MI(A8, 64); + } + MI(o4, 32); + } + return r3 = o4 + 96 | 0, Q4; + } + function nA(A8, I7, g6, C4, B4, Q4, o4, c4, D4, a4) { + var y4, f4; + return r3 = y4 = r3 - 400 | 0, E3[y4 + 4 >> 2] = 0, $(f4 = y4 + 16 | 0, D4, a4), a4 = i3[D4 + 20 | 0] | i3[D4 + 21 | 0] << 8 | i3[D4 + 22 | 0] << 16 | i3[D4 + 23 | 0] << 24, E3[y4 + 8 >> 2] = i3[D4 + 16 | 0] | i3[D4 + 17 | 0] << 8 | i3[D4 + 18 | 0] << 16 | i3[D4 + 19 | 0] << 24, E3[y4 + 12 >> 2] = a4, eI(a4 = y4 + 80 | 0, 64, y4 + 4 | 0, f4), nI(D4 = y4 + 144 | 0, a4), MI(a4, 64), rI(D4, Q4, o4, c4), rI(D4, 35104, 0 - o4 & 15, 0), rI(D4, I7, g6, C4), rI(D4, 35104, 0 - g6 & 15, 0), E3[y4 + 72 >> 2] = o4, E3[y4 + 76 >> 2] = c4, rI(D4, Q4 = y4 + 72 | 0, 8, 0), E3[y4 + 72 >> 2] = g6, E3[y4 + 76 >> 2] = C4, rI(D4, Q4, 8, 0), sI(D4, Q4 = y4 + 48 | 0), MI(D4, 256), D4 = rA(Q4, B4), MI(Q4, 16), A8 && (D4 ? (VA(A8, 0, g6), D4 = -1) : (BI(A8, I7, g6, C4, y4 + 4 | 0, y4 + 16 | 0), D4 = 0)), MI(y4 + 16 | 0, 32), r3 = y4 + 400 | 0, D4; + } + function sA(A8, I7, g6, C4, B4, Q4, o4, c4, D4, a4, y4) { + var f4, e4, w4; + return r3 = f4 = r3 - 384 | 0, E3[f4 + 4 >> 2] = 0, $(e4 = f4 + 16 | 0, a4, y4), y4 = i3[a4 + 20 | 0] | i3[a4 + 21 | 0] << 8 | i3[a4 + 22 | 0] << 16 | i3[a4 + 23 | 0] << 24, E3[f4 + 8 >> 2] = i3[a4 + 16 | 0] | i3[a4 + 17 | 0] << 8 | i3[a4 + 18 | 0] << 16 | i3[a4 + 19 | 0] << 24, E3[f4 + 12 >> 2] = y4, eI(y4 = f4 - -64 | 0, 64, w4 = f4 + 4 | 0, e4), nI(a4 = f4 + 128 | 0, y4), MI(y4, 64), rI(a4, o4, c4, D4), rI(a4, 35104, 0 - c4 & 15, 0), BI(A8, C4, B4, Q4, w4, e4), rI(a4, A8, B4, Q4), rI(a4, 35104, 0 - B4 & 15, 0), E3[f4 + 56 >> 2] = c4, E3[f4 + 60 >> 2] = D4, rI(a4, A8 = f4 + 56 | 0, 8, 0), E3[f4 + 56 >> 2] = B4, E3[f4 + 60 >> 2] = Q4, rI(a4, A8, 8, 0), sI(a4, I7), MI(a4, 256), g6 && (E3[g6 >> 2] = 16, E3[g6 + 4 >> 2] = 0), MI(f4 + 16 | 0, 32), r3 = f4 + 384 | 0, 0; + } + function FA(A8, I7, g6, C4) { + var B4, Q4 = 0; + return r3 = B4 = r3 - 208 | 0, E3[B4 + 72 >> 2] = 0, E3[B4 + 76 >> 2] = 0, Q4 = E3[8479], E3[B4 + 8 >> 2] = E3[8478], E3[B4 + 12 >> 2] = Q4, Q4 = E3[8481], E3[B4 + 16 >> 2] = E3[8480], E3[B4 + 20 >> 2] = Q4, Q4 = E3[8483], E3[B4 + 24 >> 2] = E3[8482], E3[B4 + 28 >> 2] = Q4, Q4 = E3[8485], E3[B4 + 32 >> 2] = E3[8484], E3[B4 + 36 >> 2] = Q4, Q4 = E3[8487], E3[B4 + 40 >> 2] = E3[8486], E3[B4 + 44 >> 2] = Q4, Q4 = E3[8489], E3[B4 + 48 >> 2] = E3[8488], E3[B4 + 52 >> 2] = Q4, Q4 = E3[8491], E3[B4 + 56 >> 2] = E3[8490], E3[B4 + 60 >> 2] = Q4, E3[B4 + 64 >> 2] = 0, E3[B4 + 68 >> 2] = 0, Q4 = E3[8477], E3[B4 >> 2] = E3[8476], E3[B4 + 4 >> 2] = Q4, W(B4, I7, g6, C4), v3(B4, A8), r3 = B4 + 208 | 0, 0; + } + function SA(A8, I7) { + var g6, B4 = 0, Q4 = 0, E4 = 0, o4 = 0; + if (C3[15 + (g6 = r3 - 16 | 0) | 0] = 0, I7) { + if (I7 >>> 0 >= 4) for (o4 = -4 & I7; B4 = A8 + Q4 | 0, C3[g6 + 15 | 0] = i3[0 | B4] | i3[g6 + 15 | 0], C3[g6 + 15 | 0] = i3[B4 + 1 | 0] | i3[g6 + 15 | 0], C3[g6 + 15 | 0] = i3[B4 + 2 | 0] | i3[g6 + 15 | 0], C3[g6 + 15 | 0] = i3[B4 + 3 | 0] | i3[g6 + 15 | 0], Q4 = Q4 + 4 | 0, (0 | o4) != (0 | (E4 = E4 + 4 | 0)); ) ; + if (B4 = 3 & I7) for (I7 = 0; C3[g6 + 15 | 0] = i3[A8 + Q4 | 0] | i3[g6 + 15 | 0], Q4 = Q4 + 1 | 0, (0 | B4) != (0 | (I7 = I7 + 1 | 0)); ) ; + } + return i3[g6 + 15 | 0] - 1 >>> 8 & 1; + } + function MA(A8) { + var I7 = 0; + E3[A8 + 64 >> 2] = 0, E3[A8 + 68 >> 2] = 0, E3[A8 + 72 >> 2] = 0, E3[A8 + 76 >> 2] = 0, I7 = E3[8477], E3[A8 >> 2] = E3[8476], E3[A8 + 4 >> 2] = I7, I7 = E3[8479], E3[A8 + 8 >> 2] = E3[8478], E3[A8 + 12 >> 2] = I7, I7 = E3[8481], E3[A8 + 16 >> 2] = E3[8480], E3[A8 + 20 >> 2] = I7, I7 = E3[8483], E3[A8 + 24 >> 2] = E3[8482], E3[A8 + 28 >> 2] = I7, I7 = E3[8485], E3[A8 + 32 >> 2] = E3[8484], E3[A8 + 36 >> 2] = I7, I7 = E3[8487], E3[A8 + 40 >> 2] = E3[8486], E3[A8 + 44 >> 2] = I7, I7 = E3[8489], E3[A8 + 48 >> 2] = E3[8488], E3[A8 + 52 >> 2] = I7, I7 = E3[8491], E3[A8 + 56 >> 2] = E3[8490], E3[A8 + 60 >> 2] = I7; + } + function NA(A8, I7, g6) { + var B4, Q4 = 0, o4 = 0; + if (E3[12 + (B4 = r3 - 16 | 0) >> 2] = A8, E3[B4 + 8 >> 2] = I7, A8 = 0, C3[B4 + 7 | 0] = 0, g6) { + if (I7 = 1 & g6, 1 != (0 | g6)) for (o4 = -2 & g6, g6 = 0; C3[B4 + 7 | 0] = i3[B4 + 7 | 0] | i3[E3[B4 + 12 >> 2] + A8 | 0] ^ i3[E3[B4 + 8 >> 2] + A8 | 0], Q4 = 1 | A8, C3[B4 + 7 | 0] = i3[B4 + 7 | 0] | i3[Q4 + E3[B4 + 12 >> 2] | 0] ^ i3[E3[B4 + 8 >> 2] + Q4 | 0], A8 = A8 + 2 | 0, (0 | o4) != (0 | (g6 = g6 + 2 | 0)); ) ; + I7 && (C3[B4 + 7 | 0] = i3[B4 + 7 | 0] | i3[E3[B4 + 12 >> 2] + A8 | 0] ^ i3[E3[B4 + 8 >> 2] + A8 | 0]); + } + return (i3[B4 + 7 | 0] - 1 >>> 8 & 1) - 1 | 0; + } + function KA(A8) { + for (var I7 = 0, g6 = 0, C4 = 0, B4 = 0, Q4 = 0, E4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0; B4 = (g6 = i3[A8 + C4 | 0]) ^ i3[0 | (I7 = C4 + 2432 | 0)] | B4, Q4 = g6 ^ i3[I7 + 192 | 0] | Q4, E4 = g6 ^ i3[I7 + 160 | 0] | E4, o4 = g6 ^ i3[I7 + 128 | 0] | o4, c4 = g6 ^ i3[I7 + 96 | 0] | c4, D4 = g6 ^ i3[I7 - -64 | 0] | D4, a4 = g6 ^ i3[I7 + 32 | 0] | a4, 31 != (0 | (C4 = C4 + 1 | 0)); ) ; + return ((255 & ((I7 = 127 ^ (A8 = 127 & i3[A8 + 31 | 0])) | Q4)) - 1 | (255 & (I7 | E4)) - 1 | (255 & (I7 | o4)) - 1 | (255 & (122 ^ A8 | c4)) - 1 | (255 & (5 ^ A8 | D4)) - 1 | (255 & (A8 | a4)) - 1 | (255 & (A8 | B4)) - 1) >>> 8 & 1; + } + function _A(A8, I7, g6) { + var C4 = 0, B4 = 0, Q4 = 0, E4 = 0; + return B4 = 31 & (Q4 = E4 = 63 & g6), Q4 = Q4 >>> 0 >= 32 ? -1 >>> B4 | 0 : (C4 = -1 >>> B4 | 0) | (1 << B4) - 1 << 32 - B4, Q4 &= A8, C4 &= I7, B4 = 31 & E4, E4 >>> 0 >= 32 ? (C4 = Q4 << B4, E4 = 0) : (C4 = (1 << B4) - 1 & Q4 >>> 32 - B4 | C4 << B4, E4 = Q4 << B4), Q4 = C4, C4 = 31 & (B4 = 0 - g6 & 63), B4 >>> 0 >= 32 ? (C4 = -1 << C4, g6 = 0) : C4 = (g6 = -1 << C4) | (1 << C4) - 1 & -1 >>> 32 - C4, A8 &= g6, I7 &= C4, C4 = 31 & B4, B4 >>> 0 >= 32 ? (g6 = 0, A8 = I7 >>> C4 | 0) : (g6 = I7 >>> C4 | 0, A8 = ((1 << C4) - 1 & I7) << 32 - C4 | A8 >>> C4), t3 = g6 | Q4, A8 | E4; + } + function pA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4) { + var a4, y4, f4; + return r3 = a4 = r3 - 352 | 0, eI(f4 = a4 + 32 | 0, 64, c4, D4), nI(y4 = a4 + 96 | 0, f4), MI(f4, 64), rI(y4, Q4, i4, o4), rI(y4, 35168, 0 - i4 & 15, 0), rI(y4, I7, g6, C4), rI(y4, 35168, 0 - g6 & 15, 0), E3[a4 + 24 >> 2] = i4, E3[a4 + 28 >> 2] = o4, rI(y4, Q4 = a4 + 24 | 0, 8, 0), E3[a4 + 24 >> 2] = g6, E3[a4 + 28 >> 2] = C4, rI(y4, Q4, 8, 0), sI(y4, a4), MI(y4, 256), Q4 = rA(a4, B4), MI(a4, 16), A8 && (Q4 ? (VA(A8, 0, g6), Q4 = -1) : (vA(A8, I7, g6, C4, c4, 1, D4), Q4 = 0)), r3 = a4 + 352 | 0, Q4; + } + function HA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + var y4, f4, e4; + return r3 = y4 = r3 - 336 | 0, eI(e4 = y4 + 16 | 0, 64, D4, a4), nI(f4 = y4 + 80 | 0, e4), MI(e4, 64), rI(f4, i4, o4, c4), rI(f4, 35168, 0 - o4 & 15, 0), vA(A8, C4, B4, Q4, D4, 1, a4), rI(f4, A8, B4, Q4), rI(f4, 35168, 0 - B4 & 15, 0), E3[y4 + 8 >> 2] = o4, E3[y4 + 12 >> 2] = c4, rI(f4, A8 = y4 + 8 | 0, 8, 0), E3[y4 + 8 >> 2] = B4, E3[y4 + 12 >> 2] = Q4, rI(f4, A8, 8, 0), sI(f4, I7), MI(f4, 256), g6 && (E3[g6 >> 2] = 16, E3[g6 + 4 >> 2] = 0), r3 = y4 + 336 | 0, 0; + } + function GA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4) { + var a4, y4, f4; + return r3 = a4 = r3 - 352 | 0, wI(f4 = a4 + 32 | 0, c4, D4), nI(y4 = a4 + 96 | 0, f4), MI(f4, 64), rI(y4, Q4, i4, o4), E3[a4 + 24 >> 2] = i4, E3[a4 + 28 >> 2] = o4, rI(y4, Q4 = a4 + 24 | 0, 8, 0), rI(y4, I7, g6, C4), E3[a4 + 24 >> 2] = g6, E3[a4 + 28 >> 2] = C4, rI(y4, Q4, 8, 0), sI(y4, a4), MI(y4, 256), Q4 = rA(a4, B4), MI(a4, 16), A8 && (Q4 ? (VA(A8, 0, g6), Q4 = -1) : (CI(A8, I7, g6, C4, c4, D4), Q4 = 0)), r3 = a4 + 352 | 0, Q4; + } + function JA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + var y4, f4, e4; + return r3 = y4 = r3 - 336 | 0, wI(e4 = y4 + 16 | 0, D4, a4), nI(f4 = y4 + 80 | 0, e4), MI(e4, 64), rI(f4, i4, o4, c4), E3[y4 + 8 >> 2] = o4, E3[y4 + 12 >> 2] = c4, rI(f4, i4 = y4 + 8 | 0, 8, 0), CI(A8, C4, B4, Q4, D4, a4), rI(f4, A8, B4, Q4), E3[y4 + 8 >> 2] = B4, E3[y4 + 12 >> 2] = Q4, rI(f4, i4, 8, 0), sI(f4, I7), MI(f4, 256), g6 && (E3[g6 >> 2] = 16, E3[g6 + 4 >> 2] = 0), r3 = y4 + 336 | 0, 0; + } + function YA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + var y4 = 0, f4 = 0, e4 = 0; + return f4 = -1, (y4 = C4 >>> 0 < 32) & !B4 || !(y4 = B4 - y4 | 0) & (e4 = C4 - 32 | 0) >>> 0 > 4294967263 | y4 | !o4 & i4 >>> 0 > 4294967263 | o4 || (f4 = 0 | vI[E3[a4 >> 2]](A8, g6, e4, (g6 + C4 | 0) - 32 | 0, 32, Q4, i4, c4, D4)), I7 && (E3[I7 >> 2] = f4 ? 0 : C4 - 32 | 0, E3[I7 + 4 >> 2] = f4 ? 0 : B4 - (C4 >>> 0 < 32) | 0), f4; + } + function UA(A8, I7) { + var g6; + for (E3[12 + (g6 = r3 - 16 | 0) >> 2] = A8, E3[g6 + 8 >> 2] = I7, A8 = 0, E3[g6 + 4 >> 2] = 0; E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[E3[g6 + 12 >> 2] + A8 | 0] ^ i3[E3[g6 + 8 >> 2] + A8 | 0], I7 = 1 | A8, E3[g6 + 4 >> 2] = E3[g6 + 4 >> 2] | i3[I7 + E3[g6 + 12 >> 2] | 0] ^ i3[I7 + E3[g6 + 8 >> 2] | 0], 32 != (0 | (A8 = A8 + 2 | 0)); ) ; + return (E3[g6 + 4 >> 2] - 1 >>> 8 & 1) - 1 | 0; + } + function dA(A8) { + var I7 = 0, g6 = 0, B4 = 0, Q4 = 0, E4 = 0; + for (I7 = 1; g6 = (B4 = I7) + i3[0 | (I7 = A8 + Q4 | 0)] | 0, C3[0 | I7] = g6, g6 = i3[I7 + 1 | 0] + (g6 >>> 8 | 0) | 0, C3[I7 + 1 | 0] = g6, g6 = i3[I7 + 2 | 0] + (g6 >>> 8 | 0) | 0, C3[I7 + 2 | 0] = g6, B4 = I7, I7 = i3[I7 + 3 | 0] + (g6 >>> 8 | 0) | 0, C3[B4 + 3 | 0] = I7, I7 = I7 >>> 8 | 0, Q4 = Q4 + 4 | 0, 4 != (0 | (E4 = E4 + 4 | 0)); ) ; + } + function bA(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return !B4 & C4 >>> 0 > 4294967263 | !!(0 | B4) | !c4 & o4 >>> 0 >= 4294967264 | !!(0 | c4) ? (iI(), Q3()) : (A8 = 0 | vI[E3[y4 >> 2]](A8, A8 + C4 | 0, 32, g6, C4, i4, o4, D4, a4), I7 && (C4 = (g6 = C4 + 32 | 0) >>> 0 < 32 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8 ? 0 : g6, E3[I7 + 4 >> 2] = A8 ? 0 : C4)), A8; + } + function PA(A8, I7, g6, C4) { + var B4, Q4, E4, i4, o4 = 0, D4 = 0; + return i4 = c3(o4 = g6 >>> 16 | 0, D4 = A8 >>> 16 | 0), o4 = (65535 & (D4 = ((E4 = c3(B4 = 65535 & g6, Q4 = 65535 & A8)) >>> 16 | 0) + c3(D4, B4) | 0)) + c3(o4, Q4) | 0, t3 = (c3(I7, g6) + i4 | 0) + c3(A8, C4) + (D4 >>> 16) + (o4 >>> 16) | 0, 65535 & E4 | o4 << 16; + } + function vA(A8, I7, g6, C4, B4, i4, o4) { + var c4 = 0, D4 = 0; + c4 = C4, 1 == (((c4 = (D4 = g6 + 63 | 0) >>> 0 < 63 ? c4 + 1 | 0 : c4) >>> 6 | 0) + !!(0 | (c4 = (63 & c4) << 26 | D4 >>> 6)) | 0) & i4 >>> 0 > (D4 = 0 - c4 | 0) >>> 0 | 1 == (0 | C4) | C4 >>> 0 > 1 ? (iI(), Q3()) : vI[E3[9075]](A8, I7, g6, C4, B4, i4, o4); + } + function RA(A8) { + var I7 = 0; + E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, I7 = E3[8689], E3[A8 >> 2] = E3[8688], E3[A8 + 4 >> 2] = I7, I7 = E3[8691], E3[A8 + 8 >> 2] = E3[8690], E3[A8 + 12 >> 2] = I7, I7 = E3[8693], E3[A8 + 16 >> 2] = E3[8692], E3[A8 + 20 >> 2] = I7, I7 = E3[8695], E3[A8 + 24 >> 2] = E3[8694], E3[A8 + 28 >> 2] = I7; + } + function LA(A8, I7) { + A8 |= 0; + var g6, B4 = 0, Q4 = 0, E4 = 0; + if (r3 = g6 = r3 - 16 | 0, I7 |= 0) for (; C3[g6 + 15 | 0] = 0, Q4 = A8 + B4 | 0, E4 = 0 | y3(36304, g6 + 15 | 0, 0), C3[0 | Q4] = E4, (0 | (B4 = B4 + 1 | 0)) != (0 | I7); ) ; + r3 = g6 + 16 | 0; + } + function xA(A8, I7, g6, C4, B4, Q4, E4) { + var i4, o4, c4 = 0; + return r3 = i4 = r3 - 32 | 0, c4 = -1, (o4 = g6 >>> 0 < 16) & !C4 || OA(i4, Q4, E4) || (c4 = kA(A8, I7 + 16 | 0, I7, g6 - 16 | 0, C4 - o4 | 0, B4, i4), MI(i4, 32)), r3 = i4 + 32 | 0, c4; + } + function uA(A8) { + var I7, g6; + A: { + if (!((A8 = (I7 = E3[8800]) + (g6 = A8 + 7 & -8) | 0) >>> 0 <= I7 >>> 0 && g6)) { + if (A8 >>> 0 <= RI() << 16 >>> 0) break A; + if (0 | w3(0 | A8)) break A; + } + return E3[9280] = 48, -1; + } + return E3[8800] = A8, I7; + } + function mA(A8, I7) { + var g6, B4, Q4; + r3 = g6 = r3 - 176 | 0, iA(B4 = g6 + 96 | 0, I7 + 80 | 0), M3(Q4 = g6 + 48 | 0, I7, B4), M3(g6, I7 + 40 | 0, B4), eA(A8, g6), eA(g6 + 144 | 0, Q4), C3[A8 + 31 | 0] = i3[A8 + 31 | 0] ^ i3[g6 + 144 | 0] << 7, r3 = g6 + 176 | 0; + } + function qA(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4, f4) { + return g6 && (E3[g6 >> 2] = 32, E3[g6 + 4 >> 2] = 0), !D4 & c4 >>> 0 < 4294967264 & !i4 & B4 >>> 0 <= 4294967263 || (iI(), Q3()), 0 | vI[E3[f4 >> 2]](A8, I7, 32, C4, B4, o4, c4, a4, y4); + } + function lA(A8, I7, g6) { + var B4 = 0; + if (A8 >>> 0 < I7 >>> 0) return TA(A8, I7, g6); + if (g6) for (B4 = A8 + g6 | 0, I7 = I7 + g6 | 0; I7 = I7 - 1 | 0, C3[0 | (B4 = B4 - 1 | 0)] = i3[0 | I7], g6 = g6 - 1 | 0; ) ; + return A8; + } + function zA(A8, I7, g6, C4, B4, E4, i4) { + var o4, c4 = 0; + if (r3 = o4 = r3 - 32 | 0, !C4 & g6 >>> 0 < 4294967280) return c4 = -1, OA(o4, E4, i4) || (c4 = tA(A8 + 16 | 0, A8, I7, g6, C4, B4, o4), MI(o4, 32)), r3 = o4 + 32 | 0, c4; + iI(), Q3(); + } + function jA(A8, I7, g6, C4, B4, Q4) { + return I7 |= 0, 0 | (!(C4 |= 0) & (g6 |= 0) >>> 0 >= 16 | C4 ? kA(A8 |= 0, I7 + 16 | 0, I7, g6 - 16 | 0, C4 - (g6 >>> 0 < 16) | 0, B4 |= 0, Q4 |= 0) : -1); + } + function XA(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return !C4 & g6 >>> 0 > 4294967263 | C4 | !o4 & i4 >>> 0 > 4294967263 | o4 ? -1 : 0 | vI[E3[a4 >> 2]](A8, I7, g6, B4, 32, Q4, i4, c4, D4); + } + function OA(A8, I7, g6) { + A8 |= 0; + var C4, B4 = 0; + return r3 = C4 = r3 - 32 | 0, B4 = -1, fA(C4, g6 |= 0, I7 |= 0) || (B4 = AA(A8, 35184, C4)), r3 = C4 + 32 | 0, 0 | B4; + } + function TA(A8, I7, g6) { + var B4 = 0; + if (g6) for (B4 = A8; C3[0 | B4] = i3[0 | I7], B4 = B4 + 1 | 0, I7 = I7 + 1 | 0, g6 = g6 - 1 | 0; ) ; + return A8; + } + function VA(A8, I7, g6) { + var B4 = 0; + if (g6) for (B4 = A8; C3[0 | B4] = I7, B4 = B4 + 1 | 0, g6 = g6 - 1 | 0; ) ; + return A8; + } + function ZA(A8, I7, g6) { + return A8 |= 0, I7 |= 0, (g6 |= 0) >>> 0 >= 256 && (f3(1248, 1175, 107, 1055), Q3()), 0 | m3(A8, I7, 255 & g6); + } + function WA(A8, I7) { + var g6; + r3 = g6 = r3 + -64 | 0, v3(A8, g6), W(A8 = A8 + 208 | 0, g6, 64, 0), v3(A8, I7), MI(g6, 64), r3 = g6 - -64 | 0; + } + function $A(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | tA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + } + function AI(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | kA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + } + function II(A8, I7) { + var g6; + r3 = g6 = r3 - 32 | 0, IA(A8, g6), BA(A8 = A8 + 104 | 0, g6, 32), IA(A8, I7), MI(g6, 32), r3 = g6 + 32 | 0; + } + function gI(A8, I7) { + var g6 = 0; + return (-1 >>> (g6 = 31 & I7) & A8) << g6 | ((g6 = A8) & -1 << (A8 = 0 - I7 & 31)) >>> A8; + } + function CI(A8, I7, g6, C4, B4, i4) { + 1 == (0 | C4) | C4 >>> 0 > 1 && (iI(), Q3()), vI[E3[9074]](A8, I7, g6, C4, B4, 1, 0, i4); + } + function BI(A8, I7, g6, C4, B4, i4) { + 1 == (0 | C4) | C4 >>> 0 > 1 && (iI(), Q3()), vI[E3[9075]](A8, I7, g6, C4, B4, 1, i4); + } + function QI() { + var A8; + r3 = A8 = r3 - 16 | 0, C3[A8 + 15 | 0] = 0, y3(36340, A8 + 15 | 0, 0), r3 = A8 + 16 | 0; + } + function EI(A8, I7, g6) { + return 0 | fA(A8 |= 0, I7 |= 0, g6 |= 0); + } + function iI() { + var A8; + (A8 = E3[9413]) && vI[0 | A8](), e3(), Q3(); + } + function oI(A8, I7, g6, C4, B4, Q4) { + vI[E3[8809]](A8, I7, g6, C4, B4, 0, 0, Q4); + } + function cI(A8, I7) { + return A8 |= 0, LA(I7 |= 0, 32), 0 | hI(A8, I7); + } + function DI(A8, I7, g6, C4, B4, Q4) { + vI[E3[8809]](A8, I7, g6, C4, B4, 1, 0, Q4); + } + function aI(A8) { + return A8 ? 31 - D3(A8 - 1 ^ A8) | 0 : 32; + } + function yI(A8, I7, g6, C4) { + vI[E3[9075]](A8, I7, 40, 0, g6, 0, C4); + } + function fI(A8, I7) { + return 0 | hI(A8 |= 0, I7 |= 0); + } + function eI(A8, I7, g6, C4) { + vI[E3[9073]](A8, I7, 0, g6, C4); + } + function wI(A8, I7, g6) { + vI[E3[9072]](A8, 64, 0, I7, g6); + } + function rI(A8, I7, g6, C4) { + vI[E3[8804]](A8, I7, g6, C4); + } + function tI(A8, I7, g6, C4) { + return W(A8, I7, g6, C4), 0; + } + function hI(A8, I7) { + return 0 | vI[E3[8807]](A8, I7); + } + function kI(A8, I7, g6) { + return BA(A8, I7, g6), 0; + } + function nI(A8, I7) { + vI[E3[8803]](A8, I7); + } + function sI(A8, I7) { + vI[E3[8805]](A8, I7); + } + function FI(A8) { + LA(A8 |= 0, 32); + } + function SI(A8) { + LA(A8 |= 0, 16); + } + function MI(A8, I7) { + VA(A8, 0, I7); + } + function NI() { + return 208; + } + function KI() { + return 16; + } + function _I() { + return 32; + } + function pI() { + return 24; + } + function HI() { + return -17; + } + function GI() { + return -33; + } + function JI() { + return 64; + } + function YI() { + return 0; + } + function UI() { + return 8; + } + function dI() { + return 1; + } + function bI() { + return 2; + } + B3(I6 = i3, 1024, "cmFuZG9tYnl0ZXMAYjY0X3BvcyA8PSBiNjRfbGVuAGNyeXB0b19nZW5lcmljaGFzaF9ibGFrZTJiX2ZpbmFsAHJhbmRvbWJ5dGVzL3JhbmRvbWJ5dGVzLmMAc29kaXVtL2NvZGVjcy5jAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9ibGFrZTJiLXJlZi5jAGNyeXB0b19nZW5lcmljaGFzaC9ibGFrZTJiL3JlZi9nZW5lcmljaGFzaF9ibGFrZTJiLmMAYnVmX2xlbiA8PSBTSVpFX01BWABvdXRsZW4gPD0gVUlOVDhfTUFYAFMtPmJ1ZmxlbiA8PSBCTEFLRTJCX0JMT0NLQllURVMAc29kaXVtX2JpbjJiYXNlNjQAMS4wLjIwAAAAALZ4Wf+FctMAvW4V/w8KagApwAEAmOh5/7w8oP+Zcc7/ALfi/rQNSP8AAAAAAAAAALCgDv7TyYb/nhiPAH9pNQBgDL0Ap9f7/59MgP5qZeH/HvwEAJIMrg=="), B3(I6, 1424, "WfGy/grlpv973Sr+HhTUAFKAAwAw0fMAd3lA/zLjnP8AbsUBZxuQ"), B3(I6, 1472, "hTuMAb3xJP/4JcMBYNw3ALdMPv/DQj0AMkykAeGkTP9MPaP/dT4fAFGRQP92QQ4AonPW/waKLgB85vT/CoqPADQawgC49EwAgY8pAb70E/97qnr/YoFEAHnVkwBWZR7/oWebAIxZQ//v5b4BQwu1AMbwif7uRbz/Q5fuABMqbP/lVXEBMkSH/xFqCQAyZwH/UAGoASOYHv8QqLkBOFno/2XS/AAp+kcAzKpP/w4u7/9QTe8AvdZL/xGN+QAmUEz/vlV1AFbkqgCc2NABw8+k/5ZCTP+v4RD/jVBiAUzb8gDGonIALtqYAJsr8f6boGj/M7ulAAIRrwBCVKAB9zoeACNBNf5F7L8ALYb1AaN73QAgbhT/NBelALrWRwDpsGAA8u82ATlZigBTAFT/iKBkAFyOeP5ofL4AtbE+//opVQCYgioBYPz2AJeXP/7vhT4AIDicAC2nvf+OhbMBg1bTALuzlv76qg7/0qNOACU0lwBjTRoA7pzV/9XA0QFJLlQAFEEpATbOTwDJg5L+qm8Y/7EhMv6rJsv/Tvd0ANHdmQCFgLIBOiwZAMknOwG9E/wAMeXSAXW7dQC1s7gBAHLbADBekwD1KTgAfQ3M/vStdwAs3SD+VOoUAPmgxgHsfur/L2Oo/qrimf9ms9gA4o16/3pCmf629YYA4+QZAdY56//YrTj/tefSAHeAnf+BX4j/bn4zAAKpt/8HgmL+RbBe/3QE4wHZ8pH/yq0fAWkBJ/8ur0UA5C86/9fgRf7POEX/EP6L/xfP1P/KFH7/X9Vg/wmwIQDIBc//8SqA/iMhwP/45cQBgRF4APtnl/8HNHD/jDhC/yji9f/ZRiX+rNYJ/0hDhgGSwNb/LCZwAES4S//OWvsAleuNALWqOgB09O8AXJ0CAGatYgDpiWABfzHLAAWblAAXlAn/03oMACKGGv/bzIgAhggp/+BTK/5VGfcAbX8A/qmIMADud9v/563VAM4S/v4Iugf/fgkHAW8qSABvNOz+YD+NAJO/f/7NTsD/DmrtAbvbTACv87v+aVmtAFUZWQGi85QAAnbR/iGeCQCLoy7/XUYoAGwqjv5v/I7/m9+QADPlp/9J/Jv/XnQM/5ig2v+c7iX/s+rP/8UAs/+apI0A4cRoAAojGf7R1PL/Yf3e/rhl5QDeEn8BpIiH/x7PjP6SYfMAgcAa/slUIf9vCk7/k1Gy/wQEGACh7tf/Bo0hADXXDv8ptdD/54udALPL3f//uXEAveKs/3FC1v/KPi3/ZkAI/06uEP6FdUT/"), B3(I6, 2464, "AQ=="), B3(I6, 2496, "JuiVj8KyJ7BFw/SJ8u+Y8NXfrAXTxjM5sTgCiG1T/AXHF2pwPU3YT7o8C3YNEGcPKiBT+iw5zMZOx/13kqwDeuz///////////////////////////////////////9/7f///////////////////////////////////////3/u////////////////////////////////////////f+3T9VwaYxJY1pz3ot753hQ="), B3(I6, 2687, "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"), B3(I6, 33660, "AQ=="), B3(I6, 33696, "AQ=="), B3(I6, 33728, "4Ot6fDtBuK4WVuP68Z/EatoJjeucMrH9hmIFFl9JuABfnJW8o1CMJLHQsVWcg+9bBERcxFgcjobYIk7d0J8RV+z///////////////////////////////////////9/7f///////////////////////////////////////3/u////////////////////////////////////////f0xpYnNvZGl1bURSRwAAAAAIybzzZ+YJajunyoSFrme7K/iU/nLzbjzxNh1fOvVPpdGC5q1/Ug5RH2w+K4xoBZtrvUH7q9mDH3khfhMZzeBbIq4o15gvikLNZe8jkUQ3cS87TezP+8C1vNuJgaXbtek4tUjzW8JWORnQBbbxEfFZm08Zr6SCP5IYgW3a1V4cq0ICA6OYqgfYvm9wRQFbgxKMsuROvoUxJOK0/9XDfQxVb4l78nRdvnKxlhY7/rHegDUSxyWnBtyblCZpz3Txm8HSSvGewWmb5OMlTziGR77vtdWMi8adwQ9lnKx3zKEMJHUCK1lvLOktg+SmbqqEdErU+0G93KmwXLVTEYPaiPl2q99m7lJRPpgQMrQtbcYxqD8h+5jIJwOw5A7vvsd/Wb/Cj6g98wvgxiWnCpNHkafVb4ID4FFjygZwbg4KZykpFPwv0kaFCrcnJskmXDghGy7tKsRa/G0sTd+zlZ0TDThT3mOvi1RzCmWosnc8uwpqduau7UcuycKBOzWCFIUscpJkA/FMoei/ogEwQrxLZhqokZf40HCLS8IwvlQGo1FsxxhS79YZ6JLREKllVSQGmdYqIHFXhTUO9LjRuzJwoGoQyNDSuBbBpBlTq0FRCGw3Hpnrjt9Md0gnqEib4bW8sDRjWsnFswwcOcuKQeNKqthOc+Njd0/KnFujuLLW828uaPyy713ugo90YC8XQ29jpXhyq/ChFHjIhOw5ZBoIAseMKB5jI/r/vpDpvYLe62xQpBV5xrL3o/m+K1Ny4/J4ccacYSbqzj4nygfCwCHHuIbRHuvgzdZ92up40W7uf0999bpvF3KqZ/AGppjIosV9YwquDfm+BJg/ERtHHBM1C3EbhH0EI/V32yiTJMdAe6vKMry+yRUKvp48TA0QnMRnHUO2Qj7LvtTFTCp+ZfycKX9Z7PrWOqtvy18XWEdKjBlEbIA="), B3(I6, 34752, "Z+YJaoWuZ7ty8248OvVPpX9SDlGMaAWbq9mDHxnN4FuYL4pCkUQ3cc/7wLWl27XpW8JWOfER8Vmkgj+S1V4cq5iqB9gBW4MSvoUxJMN9DFV0Xb5y/rHegKcG3Jt08ZvBwWmb5IZHvu/GncEPzKEMJG8s6S2qhHRK3KmwXNqI+XZSUT6YbcYxqMgnA7DHf1m/8wvgxkeRp9VRY8oGZykpFIUKtyc4IRsu/G0sTRMNOFNUcwpluwpqdi7JwoGFLHKSoei/oktmGqhwi0vCo1FsxxnoktEkBpnWhTUO9HCgahAWwaQZCGw3Hkx3SCe1vLA0swwcOUqq2E5Pypxb828uaO6Cj3RvY6V4FHjIhAgCx4z6/76Q62xQpPej+b7yeHHGgA=="), B3(I6, 35120, "U2lnRWQyNTUxOSBubyBFZDI1NTE5IGNvbGxpc2lvbnMB"), B3(I6, 35200, "IJMBAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQ=="), B3(I6, 35248, "xmNjpfh8fITud3eZ9nt7jf/y8g3Wa2u93m9vsZHFxVRgMDBQAgEBA85nZ6lWKyt95/7+GbXX12JNq6vm7HZ2mo/KykUfgoKdicnJQPp9fYfv+voVsllZ645HR8n78PALQa2t7LPU1GdfoqL9Ra+v6iOcnL9TpKT35HJylpvAwFt1t7fC4f39HD2Tk65MJiZqbDY2Wn4/P0H19/cCg8zMT2g0NFxRpaX00eXlNPnx8QjicXGTq9jYc2IxMVMqFRU/CAQEDJXHx1JGIyNlncPDXjAYGCg3lpahCgUFDy+amrUOBwcJJBISNhuAgJvf4uI9zevrJk4nJ2l/srLN6nV1nxIJCRsdg4OeWCwsdDQaGi42Gxst3G5usrRaWu5boKD7pFJS9nY7O0231tZhfbOzzlIpKXvd4+M+Xi8vcROEhJemU1P1udHRaAAAAADB7e0sQCAgYOP8/B95sbHItltb7dRqar6Ny8tGZ76+2XI5OUuUSkremExM1LBYWOiFz89Ku9DQa8Xv7ypPqqrl7fv7FoZDQ8WaTU3XZjMzVRGFhZSKRUXP6fn5EAQCAgb+f3+BoFBQ8Hg8PEQln5+6S6io46JRUfNdo6P+gEBAwAWPj4o/kpKtIZ2dvHA4OEjx9fUEY7y833e2tsGv2tp1QiEhYyAQEDDl//8a/fPzDr/S0m2Bzc1MGAwMFCYTEzXD7Owvvl9f4TWXl6KIRETMLhcXOZPExFdVp6fy/H5+gno9PUfIZGSsul1d5zIZGSvmc3OVwGBgoBmBgZieT0/Ro9zcf0QiImZUKip+O5CQqwuIiIOMRkbKx+7uKWu4uNMoFBQ8p97eebxeXuIWCwsdrdvbdtvg4DtkMjJWdDo6ThQKCh6SSUnbDAYGCkgkJGy4XFzkn8LCXb3T025DrKzvxGJipjmRkagxlZWk0+TkN/J5eYvV5+cyi8jIQ243N1nabW23AY2NjLHV1WScTk7SSamp4NhsbLSsVlb68/T0B8/q6iXKZWWv9Hp6jkeurukQCAgYb7q61fB4eIhKJSVvXC4ucjgcHCRXpqbxc7S0x5fGxlHL6Ogjod3dfOh0dJw+Hx8hlktL3WG9vdwNi4uGD4qKheBwcJB8Pj5CcbW1xMxmZqqQSEjYBgMDBff29gEcDg4SwmFho2o1NV+uV1f5abm50BeGhpGZwcFYOh0dJyeenrnZ4eE46/j4EyuYmLMiEREz0mlpu6nZ2XAHjo6JM5SUpy2bm7Y8Hh4iFYeHksnp6SCHzs5JqlVV/1AoKHil3996A4yMj1mhofgJiYmAGg0NF2W/v9rX5uYxhEJCxtBoaLiCQUHDKZmZsFotLXceDw8Re7Cwy6hUVPxtu7vWLBYWOgoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAAR"); + var PI, vI = (PI = [null, function(A8, I7, g6, B4, Q4) { + var o4, c4, D4; + return A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0, r3 = o4 = (c4 = r3) - 128 & -64, E3[o4 >> 2] = 67108863 & (i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), E3[o4 + 4 >> 2] = (i3[Q4 + 3 | 0] | i3[Q4 + 4 | 0] << 8 | i3[Q4 + 5 | 0] << 16 | i3[Q4 + 6 | 0] << 24) >>> 2 & 67108611, E3[o4 + 8 >> 2] = (i3[Q4 + 6 | 0] | i3[Q4 + 7 | 0] << 8 | i3[Q4 + 8 | 0] << 16 | i3[Q4 + 9 | 0] << 24) >>> 4 & 67092735, E3[o4 + 12 >> 2] = (i3[Q4 + 9 | 0] | i3[Q4 + 10 | 0] << 8 | i3[Q4 + 11 | 0] << 16 | i3[Q4 + 12 | 0] << 24) >>> 6 & 66076671, D4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[o4 + 20 >> 2] = 0, E3[o4 + 24 >> 2] = 0, E3[o4 + 28 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, E3[o4 + 16 >> 2] = D4 >>> 8 & 1048575, E3[o4 + 40 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[o4 + 44 >> 2] = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[o4 + 48 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, Q4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, C3[o4 + 80 | 0] = 0, E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 52 >> 2] = Q4, QA(o4, I7, g6, B4), yA(o4, A8), r3 = c4, 0; + }, function(A8, I7, g6, B4, Q4) { + var o4, c4, D4; + return A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0, r3 = o4 = (c4 = r3) - 192 & -64, E3[o4 + 64 >> 2] = 67108863 & (i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), E3[o4 + 68 >> 2] = (i3[Q4 + 3 | 0] | i3[Q4 + 4 | 0] << 8 | i3[Q4 + 5 | 0] << 16 | i3[Q4 + 6 | 0] << 24) >>> 2 & 67108611, E3[o4 + 72 >> 2] = (i3[Q4 + 6 | 0] | i3[Q4 + 7 | 0] << 8 | i3[Q4 + 8 | 0] << 16 | i3[Q4 + 9 | 0] << 24) >>> 4 & 67092735, E3[o4 + 76 >> 2] = (i3[Q4 + 9 | 0] | i3[Q4 + 10 | 0] << 8 | i3[Q4 + 11 | 0] << 16 | i3[Q4 + 12 | 0] << 24) >>> 6 & 66076671, D4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[o4 + 84 >> 2] = 0, E3[o4 + 88 >> 2] = 0, E3[o4 + 92 >> 2] = 0, E3[o4 + 96 >> 2] = 0, E3[o4 + 100 >> 2] = 0, E3[o4 + 80 >> 2] = D4 >>> 8 & 1048575, E3[o4 + 104 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[o4 + 108 >> 2] = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[o4 + 112 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, Q4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, C3[o4 + 144 | 0] = 0, E3[o4 + 120 >> 2] = 0, E3[o4 + 124 >> 2] = 0, E3[o4 + 116 >> 2] = Q4, QA(Q4 = o4 - -64 | 0, I7, g6, B4), yA(Q4, I7 = o4 + 48 | 0), A8 = rA(A8, I7), r3 = c4, 0 | A8; + }, function(A8, I7) { + var g6; + return I7 |= 0, E3[(A8 |= 0) >> 2] = 67108863 & (i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24), E3[A8 + 4 >> 2] = (i3[I7 + 3 | 0] | i3[I7 + 4 | 0] << 8 | i3[I7 + 5 | 0] << 16 | i3[I7 + 6 | 0] << 24) >>> 2 & 67108611, E3[A8 + 8 >> 2] = (i3[I7 + 6 | 0] | i3[I7 + 7 | 0] << 8 | i3[I7 + 8 | 0] << 16 | i3[I7 + 9 | 0] << 24) >>> 4 & 67092735, E3[A8 + 12 >> 2] = (i3[I7 + 9 | 0] | i3[I7 + 10 | 0] << 8 | i3[I7 + 11 | 0] << 16 | i3[I7 + 12 | 0] << 24) >>> 6 & 66076671, g6 = i3[I7 + 12 | 0] | i3[I7 + 13 | 0] << 8 | i3[I7 + 14 | 0] << 16 | i3[I7 + 15 | 0] << 24, E3[A8 + 20 >> 2] = 0, E3[A8 + 24 >> 2] = 0, E3[A8 + 28 >> 2] = 0, E3[A8 + 32 >> 2] = 0, E3[A8 + 36 >> 2] = 0, E3[A8 + 16 >> 2] = g6 >>> 8 & 1048575, E3[A8 + 40 >> 2] = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, E3[A8 + 44 >> 2] = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, E3[A8 + 48 >> 2] = i3[I7 + 24 | 0] | i3[I7 + 25 | 0] << 8 | i3[I7 + 26 | 0] << 16 | i3[I7 + 27 | 0] << 24, I7 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, C3[A8 + 80 | 0] = 0, E3[A8 + 56 >> 2] = 0, E3[A8 + 60 >> 2] = 0, E3[A8 + 52 >> 2] = I7, 0; + }, function(A8, I7, g6, C4) { + return QA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0), 0; + }, function(A8, I7) { + return yA(A8 |= 0, I7 |= 0), 0; + }, function(A8, I7, g6) { + A8 |= 0, I7 |= 0, g6 |= 0; + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, _4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, q4 = 0, l3 = 0, z2 = 0, j2 = 0, X2 = 0, O2 = 0, T2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, oA2 = 0, cA2 = 0, DA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, SA2 = 0, MA2 = 0, NA2 = 0; + for (r3 = B4 = r3 - 368 | 0; k4 = (c4 = i3[g6 + Q4 | 0]) ^ i3[0 | (a4 = Q4 + 33664 | 0)] | k4, h4 = c4 ^ i3[a4 + 192 | 0] | h4, w4 = c4 ^ i3[a4 + 160 | 0] | w4, e4 = c4 ^ i3[a4 + 128 | 0] | e4, D4 = c4 ^ i3[a4 + 96 | 0] | D4, y4 = c4 ^ i3[a4 - -64 | 0] | y4, o4 = c4 ^ i3[a4 + 32 | 0] | o4, 31 != (0 | (Q4 = Q4 + 1 | 0)); ) ; + if (Q4 = -1, !(256 & ((255 & ((c4 = 127 ^ (a4 = 127 & i3[g6 + 31 | 0])) | h4)) - 1 | (255 & (c4 | w4)) - 1 | (255 & (c4 | e4)) - 1 | (255 & (87 ^ a4 | D4)) - 1 | (255 & (y4 | a4)) - 1 | (255 & (o4 | a4)) - 1 | (255 & (a4 | k4)) - 1))) { + for (Q4 = I7, I7 = i3[I7 + 28 | 0] | i3[I7 + 29 | 0] << 8 | i3[I7 + 30 | 0] << 16 | i3[I7 + 31 | 0] << 24, E3[B4 + 360 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, E3[B4 + 364 >> 2] = I7, I7 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[B4 + 352 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[B4 + 356 >> 2] = I7, o4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, I7 = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, E3[B4 + 336 >> 2] = I7, E3[B4 + 340 >> 2] = o4, o4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[B4 + 344 >> 2] = i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24, E3[B4 + 348 >> 2] = o4, C3[B4 + 336 | 0] = 248 & I7, C3[B4 + 367 | 0] = 63 & i3[B4 + 367 | 0] | 64, V(B4 + 288 | 0, g6), E3[B4 + 260 >> 2] = 0, E3[B4 + 264 >> 2] = 0, E3[B4 + 268 >> 2] = 0, E3[B4 + 272 >> 2] = 0, E3[B4 + 276 >> 2] = 0, E3[B4 + 208 >> 2] = 0, E3[B4 + 212 >> 2] = 0, E3[B4 + 216 >> 2] = 0, E3[B4 + 220 >> 2] = 0, E3[B4 + 224 >> 2] = 0, E3[B4 + 228 >> 2] = 0, I7 = E3[B4 + 308 >> 2], E3[B4 + 160 >> 2] = E3[B4 + 304 >> 2], E3[B4 + 164 >> 2] = I7, I7 = E3[B4 + 316 >> 2], E3[B4 + 168 >> 2] = E3[B4 + 312 >> 2], E3[B4 + 172 >> 2] = I7, I7 = E3[B4 + 324 >> 2], E3[B4 + 176 >> 2] = E3[B4 + 320 >> 2], E3[B4 + 180 >> 2] = I7, E3[B4 + 244 >> 2] = 0, E3[B4 + 248 >> 2] = 0, E3[B4 + 240 >> 2] = 1, E3[B4 + 252 >> 2] = 0, E3[B4 + 256 >> 2] = 0, E3[B4 + 192 >> 2] = 0, E3[B4 + 196 >> 2] = 0, E3[B4 + 200 >> 2] = 0, E3[B4 + 204 >> 2] = 0, I7 = E3[B4 + 292 >> 2], E3[B4 + 144 >> 2] = E3[B4 + 288 >> 2], E3[B4 + 148 >> 2] = I7, I7 = E3[B4 + 300 >> 2], E3[B4 + 152 >> 2] = E3[B4 + 296 >> 2], E3[B4 + 156 >> 2] = I7, E3[B4 + 116 >> 2] = 0, E3[B4 + 120 >> 2] = 0, E3[B4 + 124 >> 2] = 0, E3[B4 + 128 >> 2] = 0, E3[B4 + 132 >> 2] = 0, E3[B4 + 100 >> 2] = 0, E3[B4 + 104 >> 2] = 0, E3[B4 + 96 >> 2] = 1, E3[B4 + 108 >> 2] = 0, E3[B4 + 112 >> 2] = 0, g6 = 254; W2 = E3[B4 + 276 >> 2], c4 = E3[B4 + 180 >> 2], $2 = E3[B4 + 96 >> 2], AA2 = E3[B4 + 192 >> 2], IA2 = E3[B4 + 144 >> 2], gA2 = E3[B4 + 240 >> 2], CA2 = E3[B4 + 100 >> 2], BA2 = E3[B4 + 196 >> 2], QA2 = E3[B4 + 148 >> 2], EA2 = E3[B4 + 244 >> 2], J4 = E3[B4 + 104 >> 2], oA2 = E3[B4 + 200 >> 2], Y4 = E3[B4 + 152 >> 2], cA2 = E3[B4 + 248 >> 2], P4 = E3[B4 + 108 >> 2], DA2 = E3[B4 + 204 >> 2], v4 = E3[B4 + 156 >> 2], aA2 = E3[B4 + 252 >> 2], d4 = E3[B4 + 112 >> 2], yA2 = E3[B4 + 208 >> 2], H4 = E3[B4 + 160 >> 2], fA2 = E3[B4 + 256 >> 2], k4 = E3[B4 + 116 >> 2], wA2 = E3[B4 + 212 >> 2], f4 = E3[B4 + 164 >> 2], rA2 = E3[B4 + 260 >> 2], h4 = E3[B4 + 120 >> 2], tA2 = E3[B4 + 216 >> 2], w4 = E3[B4 + 168 >> 2], hA2 = E3[B4 + 264 >> 2], e4 = E3[B4 + 124 >> 2], kA2 = E3[B4 + 220 >> 2], D4 = E3[B4 + 172 >> 2], nA2 = E3[B4 + 268 >> 2], y4 = E3[B4 + 128 >> 2], sA2 = E3[B4 + 224 >> 2], o4 = E3[B4 + 176 >> 2], p4 = E3[B4 + 272 >> 2], FA2 = g6, G4 = (N4 = (I7 = 0 - ((I7 = Z2) ^ (Z2 = i3[(SA2 = B4 + 336 | 0) + (g6 >>> 3 | 0) | 0] >>> (7 & g6) & 1)) | 0) & ((Q4 = E3[B4 + 132 >> 2]) ^ (j2 = E3[B4 + 228 >> 2]))) ^ Q4, E3[B4 + 132 >> 2] = G4, X2 = c4 ^ (K4 = I7 & (c4 ^ W2)), E3[B4 + 84 >> 2] = X2 - G4, b4 = y4 ^ (s4 = I7 & (y4 ^ sA2)), E3[B4 + 128 >> 2] = b4, O2 = (_4 = I7 & (o4 ^ p4)) ^ o4, E3[B4 + 80 >> 2] = O2 - b4, L4 = e4 ^ (F4 = I7 & (e4 ^ kA2)), E3[B4 + 124 >> 2] = L4, MA2 = D4 ^ (S4 = I7 & (D4 ^ nA2)), E3[B4 + 76 >> 2] = MA2 - L4, x4 = h4 ^ (n4 = I7 & (h4 ^ tA2)), E3[B4 + 120 >> 2] = x4, NA2 = w4 ^ (a4 = I7 & (w4 ^ hA2)), E3[B4 + 72 >> 2] = NA2 - x4, u4 = k4 ^ (c4 = I7 & (k4 ^ wA2)), E3[B4 + 116 >> 2] = u4, m4 = f4 ^ (k4 = I7 & (f4 ^ rA2)), E3[B4 + 68 >> 2] = m4 - u4, q4 = d4 ^ (h4 = I7 & (d4 ^ yA2)), E3[B4 + 112 >> 2] = q4, R4 = H4 ^ (w4 = I7 & (H4 ^ fA2)), E3[B4 + 64 >> 2] = R4 - q4, l3 = P4 ^ (e4 = I7 & (P4 ^ DA2)), E3[B4 + 108 >> 2] = l3, T2 = v4 ^ (D4 = I7 & (v4 ^ aA2)), E3[B4 + 60 >> 2] = T2 - l3, z2 = J4 ^ (y4 = I7 & (J4 ^ oA2)), E3[B4 + 104 >> 2] = z2, P4 = Y4 ^ (o4 = I7 & (Y4 ^ cA2)), E3[B4 + 56 >> 2] = P4 - z2, J4 = CA2 ^ (Q4 = I7 & (CA2 ^ BA2)), E3[B4 + 100 >> 2] = J4, v4 = QA2 ^ (g6 = I7 & (QA2 ^ EA2)), E3[B4 + 52 >> 2] = v4 - J4, Y4 = $2 ^ (d4 = I7 & ($2 ^ AA2)), E3[B4 + 96 >> 2] = Y4, H4 = (I7 &= IA2 ^ gA2) ^ IA2, E3[B4 + 48 >> 2] = H4 - Y4, f4 = K4 ^ W2, N4 ^= j2, E3[B4 + 36 >> 2] = f4 - N4, K4 = _4 ^ p4, s4 ^= sA2, E3[B4 + 32 >> 2] = K4 - s4, _4 = S4 ^ nA2, F4 ^= kA2, E3[B4 + 28 >> 2] = _4 - F4, S4 = a4 ^ hA2, n4 ^= tA2, E3[B4 + 24 >> 2] = S4 - n4, a4 = k4 ^ rA2, c4 ^= wA2, E3[B4 + 20 >> 2] = a4 - c4, k4 = w4 ^ fA2, h4 ^= yA2, E3[B4 + 16 >> 2] = k4 - h4, w4 = D4 ^ aA2, e4 ^= DA2, E3[B4 + 12 >> 2] = w4 - e4, D4 = o4 ^ cA2, y4 ^= oA2, E3[B4 + 8 >> 2] = D4 - y4, o4 = g6 ^ EA2, Q4 ^= BA2, E3[B4 + 4 >> 2] = o4 - Q4, g6 = I7 ^ gA2, I7 = d4 ^ AA2, E3[B4 >> 2] = g6 - I7, E3[B4 + 276 >> 2] = f4 + N4, E3[B4 + 272 >> 2] = K4 + s4, E3[B4 + 268 >> 2] = F4 + _4, E3[B4 + 264 >> 2] = n4 + S4, E3[B4 + 260 >> 2] = c4 + a4, E3[B4 + 256 >> 2] = h4 + k4, E3[B4 + 248 >> 2] = D4 + y4, E3[B4 + 244 >> 2] = Q4 + o4, E3[B4 + 240 >> 2] = I7 + g6, E3[B4 + 252 >> 2] = e4 + w4, E3[B4 + 228 >> 2] = G4 + X2, E3[B4 + 224 >> 2] = b4 + O2, E3[B4 + 220 >> 2] = L4 + MA2, E3[B4 + 216 >> 2] = x4 + NA2, E3[B4 + 212 >> 2] = u4 + m4, E3[B4 + 208 >> 2] = R4 + q4, E3[B4 + 204 >> 2] = l3 + T2, E3[B4 + 200 >> 2] = P4 + z2, E3[B4 + 196 >> 2] = J4 + v4, E3[B4 + 192 >> 2] = H4 + Y4, M3(X2 = B4 + 96 | 0, b4 = B4 + 48 | 0, G4 = B4 + 240 | 0), M3(p4 = B4 + 192 | 0, p4, B4), U3(b4, B4), U3(B4, G4), f4 = E3[B4 + 192 >> 2], N4 = E3[B4 + 96 >> 2], K4 = E3[B4 + 196 >> 2], s4 = E3[B4 + 100 >> 2], _4 = E3[B4 + 200 >> 2], F4 = E3[B4 + 104 >> 2], S4 = E3[B4 + 204 >> 2], n4 = E3[B4 + 108 >> 2], a4 = E3[B4 + 208 >> 2], c4 = E3[B4 + 112 >> 2], k4 = E3[B4 + 212 >> 2], h4 = E3[B4 + 116 >> 2], w4 = E3[B4 + 216 >> 2], e4 = E3[B4 + 120 >> 2], D4 = E3[B4 + 220 >> 2], y4 = E3[B4 + 124 >> 2], o4 = E3[B4 + 224 >> 2], Q4 = E3[B4 + 128 >> 2], g6 = E3[B4 + 228 >> 2], I7 = E3[B4 + 132 >> 2], E3[B4 + 180 >> 2] = g6 + I7, E3[B4 + 176 >> 2] = Q4 + o4, E3[B4 + 172 >> 2] = D4 + y4, E3[B4 + 168 >> 2] = e4 + w4, E3[B4 + 164 >> 2] = h4 + k4, E3[B4 + 160 >> 2] = c4 + a4, E3[B4 + 156 >> 2] = n4 + S4, E3[B4 + 152 >> 2] = F4 + _4, E3[B4 + 148 >> 2] = K4 + s4, E3[B4 + 144 >> 2] = f4 + N4, E3[B4 + 228 >> 2] = I7 - g6, E3[B4 + 224 >> 2] = Q4 - o4, E3[B4 + 220 >> 2] = y4 - D4, E3[B4 + 216 >> 2] = e4 - w4, E3[B4 + 212 >> 2] = h4 - k4, E3[B4 + 208 >> 2] = c4 - a4, E3[B4 + 204 >> 2] = n4 - S4, E3[B4 + 200 >> 2] = F4 - _4, E3[B4 + 196 >> 2] = s4 - K4, E3[B4 + 192 >> 2] = N4 - f4, M3(G4, B4, b4), L4 = E3[B4 + 52 >> 2], n4 = E3[B4 + 4 >> 2], x4 = E3[B4 + 56 >> 2], a4 = E3[B4 + 8 >> 2], u4 = E3[B4 + 64 >> 2], w4 = E3[B4 + 16 >> 2], q4 = E3[B4 + 60 >> 2], e4 = E3[B4 + 12 >> 2], l3 = E3[B4 + 72 >> 2], D4 = E3[B4 + 24 >> 2], z2 = E3[B4 + 68 >> 2], y4 = E3[B4 + 20 >> 2], J4 = E3[B4 + 80 >> 2], o4 = E3[B4 + 32 >> 2], Y4 = E3[B4 + 76 >> 2], Q4 = E3[B4 + 28 >> 2], j2 = E3[B4 + 84 >> 2], I7 = E3[B4 + 36 >> 2], O2 = E3[B4 + 48 >> 2], g6 = E3[B4 >> 2] - O2 | 0, E3[B4 >> 2] = g6, I7 = I7 - j2 | 0, E3[B4 + 36 >> 2] = I7, d4 = Q4 - Y4 | 0, E3[B4 + 28 >> 2] = d4, H4 = o4 - J4 | 0, E3[B4 + 32 >> 2] = H4, c4 = y4 - z2 | 0, E3[B4 + 20 >> 2] = c4, k4 = D4 - l3 | 0, E3[B4 + 24 >> 2] = k4, h4 = e4 - q4 | 0, E3[B4 + 12 >> 2] = h4, w4 = w4 - u4 | 0, E3[B4 + 16 >> 2] = w4, e4 = a4 - x4 | 0, E3[B4 + 8 >> 2] = e4, o4 = n4 - L4 | 0, E3[B4 + 4 >> 2] = o4, U3(p4, p4), I7 = PA(I7, I7 >> 31, 121666, 0), Q4 = t3, T2 = I7, I7 = PA((33554431 & (Q4 = (f4 = I7 + 16777216 | 0) >>> 0 < 16777216 ? Q4 + 1 | 0 : Q4)) << 7 | f4 >>> 25, Q4 >> 25, 19, 0), y4 = t3, Q4 = I7, I7 = PA(g6, g6 >> 31, 121666, 0), R4 = t3 + y4 | 0, I7 = I7 >>> 0 > (Q4 = Q4 + I7 | 0) >>> 0 ? R4 + 1 | 0 : R4, g6 = (D4 = Q4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, N4 = Q4 - (-67108864 & D4) | 0, E3[B4 + 96 >> 2] = N4, y4 = PA(o4, o4 >> 31, 121666, 0), Q4 = t3, Q4 = (o4 = y4 + 16777216 | 0) >>> 0 < 16777216 ? Q4 + 1 | 0 : Q4, K4 = (y4 - (-33554432 & o4) | 0) + ((67108863 & g6) << 6 | D4 >>> 26) | 0, E3[B4 + 100 >> 2] = K4, R4 = (I7 = Q4) >> 25, Q4 = (33554431 & I7) << 7 | o4 >>> 25, g6 = PA(e4, e4 >> 31, 121666, 0) + Q4 | 0, I7 = R4 + t3 | 0, I7 = g6 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, y4 = (s4 = g6 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, _4 = g6 - (-67108864 & s4) | 0, E3[B4 + 104 >> 2] = _4, Q4 = PA(w4, w4 >> 31, 121666, 0), o4 = t3, g6 = PA(h4, h4 >> 31, 121666, 0), I7 = t3, m4 = Q4, P4 = g6, Q4 = (33554431 & (I7 = (F4 = g6 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | F4 >>> 25, I7 = (I7 >> 25) + o4 | 0, I7 = (g6 = m4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, o4 = (S4 = g6 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, n4 = g6 - (-67108864 & S4) | 0, E3[B4 + 112 >> 2] = n4, Q4 = PA(k4, k4 >> 31, 121666, 0), D4 = t3, g6 = PA(c4, c4 >> 31, 121666, 0), I7 = t3, m4 = Q4, v4 = g6, Q4 = (33554431 & (I7 = (a4 = g6 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | a4 >>> 25, I7 = (I7 >> 25) + D4 | 0, I7 = (g6 = m4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (c4 = g6 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, k4 = g6 - (-67108864 & c4) | 0, E3[B4 + 120 >> 2] = k4, D4 = PA(H4, H4 >> 31, 121666, 0), e4 = t3, g6 = PA(d4, d4 >> 31, 121666, 0), I7 = t3, H4 = g6, g6 = (33554431 & (I7 = (h4 = g6 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | h4 >>> 25, I7 = (I7 >> 25) + e4 | 0, I7 = g6 >>> 0 > (D4 = g6 + D4 | 0) >>> 0 ? I7 + 1 | 0 : I7, g6 = (w4 = D4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7, e4 = D4 - (-67108864 & w4) | 0, E3[B4 + 128 >> 2] = e4, D4 = (y4 = P4 + ((67108863 & y4) << 6 | s4 >>> 26) | 0) - (-33554432 & F4) | 0, E3[B4 + 108 >> 2] = D4, y4 = (o4 = v4 + ((67108863 & o4) << 6 | S4 >>> 26) | 0) - (-33554432 & a4) | 0, E3[B4 + 116 >> 2] = y4, o4 = (I7 = H4 + ((67108863 & Q4) << 6 | c4 >>> 26) | 0) - (-33554432 & h4) | 0, E3[B4 + 124 >> 2] = o4, g6 = (g6 = T2 + ((67108863 & g6) << 6 | w4 >>> 26) | 0) - (-33554432 & f4) | 0, E3[B4 + 132 >> 2] = g6, U3(I7 = B4 + 144 | 0, I7), E3[B4 + 84 >> 2] = g6 + j2, E3[B4 + 80 >> 2] = e4 + J4, E3[B4 + 76 >> 2] = o4 + Y4, E3[B4 + 72 >> 2] = k4 + l3, E3[B4 + 68 >> 2] = y4 + z2, E3[B4 + 64 >> 2] = n4 + u4, E3[B4 + 60 >> 2] = D4 + q4, E3[B4 + 56 >> 2] = _4 + x4, E3[B4 + 52 >> 2] = K4 + L4, E3[B4 + 48 >> 2] = N4 + O2, g6 = FA2 - 1 | 0, M3(X2, B4 + 288 | 0, p4), M3(p4, B4, b4), FA2; ) ; + k4 = E3[B4 + 144 >> 2], N4 = E3[B4 + 240 >> 2], h4 = E3[B4 + 148 >> 2], K4 = E3[B4 + 244 >> 2], w4 = E3[B4 + 152 >> 2], s4 = E3[B4 + 248 >> 2], e4 = E3[B4 + 156 >> 2], _4 = E3[B4 + 252 >> 2], D4 = E3[B4 + 160 >> 2], F4 = E3[B4 + 256 >> 2], y4 = E3[B4 + 164 >> 2], S4 = E3[B4 + 260 >> 2], o4 = E3[B4 + 168 >> 2], n4 = E3[B4 + 264 >> 2], Q4 = E3[B4 + 172 >> 2], a4 = E3[B4 + 268 >> 2], g6 = E3[B4 + 176 >> 2], c4 = E3[B4 + 272 >> 2], f4 = 0 - Z2 | 0, I7 = E3[B4 + 276 >> 2], E3[B4 + 276 >> 2] = f4 & (I7 ^ E3[B4 + 180 >> 2]) ^ I7, E3[B4 + 272 >> 2] = c4 ^ f4 & (g6 ^ c4), E3[B4 + 268 >> 2] = a4 ^ f4 & (Q4 ^ a4), E3[B4 + 264 >> 2] = n4 ^ f4 & (o4 ^ n4), E3[B4 + 260 >> 2] = S4 ^ f4 & (y4 ^ S4), E3[B4 + 256 >> 2] = F4 ^ f4 & (D4 ^ F4), E3[B4 + 252 >> 2] = _4 ^ f4 & (e4 ^ _4), E3[B4 + 248 >> 2] = s4 ^ f4 & (w4 ^ s4), E3[B4 + 244 >> 2] = K4 ^ f4 & (h4 ^ K4), E3[B4 + 240 >> 2] = N4 ^ f4 & (k4 ^ N4), N4 = E3[B4 + 192 >> 2], k4 = E3[B4 + 96 >> 2], K4 = E3[B4 + 196 >> 2], h4 = E3[B4 + 100 >> 2], s4 = E3[B4 + 200 >> 2], w4 = E3[B4 + 104 >> 2], _4 = E3[B4 + 204 >> 2], e4 = E3[B4 + 108 >> 2], F4 = E3[B4 + 208 >> 2], D4 = E3[B4 + 112 >> 2], S4 = E3[B4 + 212 >> 2], y4 = E3[B4 + 116 >> 2], n4 = E3[B4 + 216 >> 2], o4 = E3[B4 + 120 >> 2], a4 = E3[B4 + 220 >> 2], Q4 = E3[B4 + 124 >> 2], c4 = E3[B4 + 224 >> 2], g6 = E3[B4 + 128 >> 2], I7 = E3[B4 + 228 >> 2], E3[B4 + 228 >> 2] = f4 & (I7 ^ E3[B4 + 132 >> 2]) ^ I7, E3[B4 + 224 >> 2] = c4 ^ f4 & (g6 ^ c4), E3[B4 + 220 >> 2] = a4 ^ f4 & (Q4 ^ a4), E3[B4 + 216 >> 2] = n4 ^ f4 & (o4 ^ n4), E3[B4 + 212 >> 2] = S4 ^ f4 & (y4 ^ S4), E3[B4 + 208 >> 2] = F4 ^ f4 & (D4 ^ F4), E3[B4 + 204 >> 2] = _4 ^ f4 & (e4 ^ _4), E3[B4 + 200 >> 2] = s4 ^ f4 & (w4 ^ s4), E3[B4 + 196 >> 2] = K4 ^ f4 & (h4 ^ K4), E3[B4 + 192 >> 2] = N4 ^ f4 & (k4 ^ N4), iA(p4, p4), M3(G4, G4, p4), eA(A8, G4), MI(SA2, 32), Q4 = 0; + } + return r3 = B4 + 368 | 0, 0 | Q4; + }, function(A8, I7) { + var g6, B4, Q4, o4, c4, D4, a4, y4, f4, e4, w4, t4, h4, k4, n4, s4, F4, S4, N4, K4; + return I7 |= 0, r3 = g6 = r3 - 304 | 0, C3[0 | (A8 |= 0)] = i3[0 | I7], C3[A8 + 1 | 0] = i3[I7 + 1 | 0], C3[A8 + 2 | 0] = i3[I7 + 2 | 0], C3[A8 + 3 | 0] = i3[I7 + 3 | 0], C3[A8 + 4 | 0] = i3[I7 + 4 | 0], C3[A8 + 5 | 0] = i3[I7 + 5 | 0], C3[A8 + 6 | 0] = i3[I7 + 6 | 0], C3[A8 + 7 | 0] = i3[I7 + 7 | 0], C3[A8 + 8 | 0] = i3[I7 + 8 | 0], C3[A8 + 9 | 0] = i3[I7 + 9 | 0], C3[A8 + 10 | 0] = i3[I7 + 10 | 0], C3[A8 + 11 | 0] = i3[I7 + 11 | 0], C3[A8 + 12 | 0] = i3[I7 + 12 | 0], C3[A8 + 13 | 0] = i3[I7 + 13 | 0], C3[A8 + 14 | 0] = i3[I7 + 14 | 0], C3[A8 + 15 | 0] = i3[I7 + 15 | 0], C3[A8 + 16 | 0] = i3[I7 + 16 | 0], C3[A8 + 17 | 0] = i3[I7 + 17 | 0], C3[A8 + 18 | 0] = i3[I7 + 18 | 0], C3[A8 + 19 | 0] = i3[I7 + 19 | 0], C3[A8 + 20 | 0] = i3[I7 + 20 | 0], C3[A8 + 21 | 0] = i3[I7 + 21 | 0], C3[A8 + 22 | 0] = i3[I7 + 22 | 0], C3[A8 + 23 | 0] = i3[I7 + 23 | 0], C3[A8 + 24 | 0] = i3[I7 + 24 | 0], C3[A8 + 25 | 0] = i3[I7 + 25 | 0], C3[A8 + 26 | 0] = i3[I7 + 26 | 0], C3[A8 + 27 | 0] = i3[I7 + 27 | 0], C3[A8 + 28 | 0] = i3[I7 + 28 | 0], C3[A8 + 29 | 0] = i3[I7 + 29 | 0], C3[A8 + 30 | 0] = i3[I7 + 30 | 0], I7 = i3[I7 + 31 | 0], C3[0 | A8] = 248 & i3[0 | A8], C3[A8 + 31 | 0] = 63 & I7 | 64, Z(g6 + 48 | 0, A8), I7 = E3[g6 + 128 >> 2], B4 = E3[g6 + 88 >> 2], Q4 = E3[g6 + 132 >> 2], o4 = E3[g6 + 92 >> 2], c4 = E3[g6 + 136 >> 2], D4 = E3[g6 + 96 >> 2], a4 = E3[g6 + 140 >> 2], y4 = E3[g6 + 100 >> 2], f4 = E3[g6 + 144 >> 2], e4 = E3[g6 + 104 >> 2], w4 = E3[g6 + 148 >> 2], t4 = E3[g6 + 108 >> 2], h4 = E3[g6 + 152 >> 2], k4 = E3[g6 + 112 >> 2], n4 = E3[g6 + 156 >> 2], s4 = E3[g6 + 116 >> 2], F4 = E3[g6 + 160 >> 2], S4 = E3[g6 + 120 >> 2], N4 = E3[g6 + 124 >> 2], K4 = E3[g6 + 164 >> 2], E3[g6 + 292 >> 2] = N4 + K4, E3[g6 + 288 >> 2] = F4 + S4, E3[g6 + 284 >> 2] = n4 + s4, E3[g6 + 280 >> 2] = h4 + k4, E3[g6 + 276 >> 2] = w4 + t4, E3[g6 + 272 >> 2] = f4 + e4, E3[g6 + 268 >> 2] = a4 + y4, E3[g6 + 264 >> 2] = c4 + D4, E3[g6 + 260 >> 2] = Q4 + o4, E3[g6 + 256 >> 2] = I7 + B4, E3[g6 + 244 >> 2] = K4 - N4, E3[g6 + 240 >> 2] = F4 - S4, E3[g6 + 236 >> 2] = n4 - s4, E3[g6 + 232 >> 2] = h4 - k4, E3[g6 + 228 >> 2] = w4 - t4, E3[g6 + 224 >> 2] = f4 - e4, E3[g6 + 220 >> 2] = a4 - y4, E3[g6 + 216 >> 2] = c4 - D4, E3[g6 + 212 >> 2] = Q4 - o4, E3[g6 + 208 >> 2] = I7 - B4, iA(I7 = g6 + 208 | 0, I7), M3(g6, g6 + 256 | 0, I7), eA(A8, g6), r3 = g6 + 304 | 0, 0; + }, function(A8, I7, g6, B4, Q4) { + A8 |= 0, B4 |= 0, Q4 |= 0; + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = o4 = r3 - 112 | 0, (I7 |= 0) | (g6 |= 0)) { + c4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, E3[o4 + 24 >> 2] = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, E3[o4 + 28 >> 2] = c4, c4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, E3[o4 + 16 >> 2] = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, E3[o4 + 20 >> 2] = c4, c4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, E3[o4 >> 2] = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, E3[o4 + 4 >> 2] = c4, c4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, E3[o4 + 8 >> 2] = i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24, E3[o4 + 12 >> 2] = c4, Q4 = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, B4 = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[o4 + 104 >> 2] = 0, E3[o4 + 108 >> 2] = 0, E3[o4 + 96 >> 2] = Q4, E3[o4 + 100 >> 2] = B4; + A: { + if (!g6 & I7 >>> 0 >= 64 | g6) { + for (; l2(A8, o4 + 96 | 0, o4), B4 = i3[o4 + 104 | 0] + 1 | 0, C3[o4 + 104 | 0] = B4, B4 = i3[o4 + 105 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 105 | 0] = B4, B4 = i3[o4 + 106 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 106 | 0] = B4, B4 = i3[o4 + 107 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 107 | 0] = B4, B4 = i3[o4 + 108 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 108 | 0] = B4, B4 = i3[o4 + 109 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 109 | 0] = B4, B4 = i3[o4 + 110 | 0] + (B4 >>> 8 | 0) | 0, C3[o4 + 110 | 0] = B4, C3[o4 + 111 | 0] = i3[o4 + 111 | 0] + (B4 >>> 8 | 0), A8 = A8 - -64 | 0, g6 = g6 - 1 | 0, !(g6 = (I7 = I7 + -64 | 0) >>> 0 < 4294967232 ? g6 + 1 | 0 : g6) & I7 >>> 0 > 63 | g6; ) ; + if (!(I7 | g6)) break A; + } + if (B4 = 0, l2(o4 + 32 | 0, o4 + 96 | 0, o4), c4 = 3 & I7, Q4 = 0, !g6 & I7 >>> 0 >= 4 | g6) for (g6 = 60 & I7, I7 = 0; D4 = a4 = o4 + 32 | 0, C3[A8 + Q4 | 0] = i3[D4 + Q4 | 0], C3[(y4 = 1 | Q4) + A8 | 0] = i3[D4 + y4 | 0], C3[(D4 = 2 | Q4) + A8 | 0] = i3[D4 + a4 | 0], C3[(D4 = 3 | Q4) + A8 | 0] = i3[D4 + (o4 + 32 | 0) | 0], Q4 = Q4 + 4 | 0, (0 | g6) != (0 | (I7 = I7 + 4 | 0)); ) ; + if (c4) for (; C3[A8 + Q4 | 0] = i3[(o4 + 32 | 0) + Q4 | 0], Q4 = Q4 + 1 | 0, (0 | c4) != (0 | (B4 = B4 + 1 | 0)); ) ; + } + MI(o4 + 32 | 0, 64), MI(o4, 32); + } + return r3 = o4 + 112 | 0, 0; + }, function(A8, I7, g6, B4, Q4, o4, c4, D4) { + A8 |= 0, I7 |= 0, Q4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0; + var a4, y4 = 0; + if (r3 = a4 = r3 - 112 | 0, (g6 |= 0) | (B4 |= 0)) { + y4 = i3[D4 + 28 | 0] | i3[D4 + 29 | 0] << 8 | i3[D4 + 30 | 0] << 16 | i3[D4 + 31 | 0] << 24, E3[a4 + 24 >> 2] = i3[D4 + 24 | 0] | i3[D4 + 25 | 0] << 8 | i3[D4 + 26 | 0] << 16 | i3[D4 + 27 | 0] << 24, E3[a4 + 28 >> 2] = y4, y4 = i3[D4 + 20 | 0] | i3[D4 + 21 | 0] << 8 | i3[D4 + 22 | 0] << 16 | i3[D4 + 23 | 0] << 24, E3[a4 + 16 >> 2] = i3[D4 + 16 | 0] | i3[D4 + 17 | 0] << 8 | i3[D4 + 18 | 0] << 16 | i3[D4 + 19 | 0] << 24, E3[a4 + 20 >> 2] = y4, y4 = i3[D4 + 4 | 0] | i3[D4 + 5 | 0] << 8 | i3[D4 + 6 | 0] << 16 | i3[D4 + 7 | 0] << 24, E3[a4 >> 2] = i3[0 | D4] | i3[D4 + 1 | 0] << 8 | i3[D4 + 2 | 0] << 16 | i3[D4 + 3 | 0] << 24, E3[a4 + 4 >> 2] = y4, y4 = i3[D4 + 12 | 0] | i3[D4 + 13 | 0] << 8 | i3[D4 + 14 | 0] << 16 | i3[D4 + 15 | 0] << 24, E3[a4 + 8 >> 2] = i3[D4 + 8 | 0] | i3[D4 + 9 | 0] << 8 | i3[D4 + 10 | 0] << 16 | i3[D4 + 11 | 0] << 24, E3[a4 + 12 >> 2] = y4, D4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, E3[a4 + 96 >> 2] = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, E3[a4 + 100 >> 2] = D4, C3[a4 + 104 | 0] = o4, C3[a4 + 111 | 0] = c4 >>> 24, C3[a4 + 110 | 0] = c4 >>> 16, C3[a4 + 109 | 0] = c4 >>> 8, C3[a4 + 108 | 0] = c4, C3[a4 + 107 | 0] = (16777215 & c4) << 8 | o4 >>> 24, C3[a4 + 106 | 0] = (65535 & c4) << 16 | o4 >>> 16, C3[a4 + 105 | 0] = (255 & c4) << 24 | o4 >>> 8; + A: { + if (!B4 & g6 >>> 0 >= 64 | B4) { + for (; ; ) { + for (D4 = 0, l2(a4 + 32 | 0, a4 + 96 | 0, a4); o4 = a4 + 32 | 0, C3[A8 + D4 | 0] = i3[o4 + D4 | 0] ^ i3[I7 + D4 | 0], C3[(Q4 = 1 | D4) + A8 | 0] = i3[Q4 + o4 | 0] ^ i3[I7 + Q4 | 0], 64 != (0 | (D4 = D4 + 2 | 0)); ) ; + if (Q4 = i3[a4 + 104 | 0] + 1 | 0, C3[a4 + 104 | 0] = Q4, Q4 = i3[a4 + 105 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 105 | 0] = Q4, Q4 = i3[a4 + 106 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 106 | 0] = Q4, Q4 = i3[a4 + 107 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 107 | 0] = Q4, Q4 = i3[a4 + 108 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 108 | 0] = Q4, Q4 = i3[a4 + 109 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 109 | 0] = Q4, Q4 = i3[a4 + 110 | 0] + (Q4 >>> 8 | 0) | 0, C3[a4 + 110 | 0] = Q4, C3[a4 + 111 | 0] = i3[a4 + 111 | 0] + (Q4 >>> 8 | 0), I7 = I7 - -64 | 0, A8 = A8 - -64 | 0, B4 = B4 - 1 | 0, !(!(B4 = (g6 = g6 + -64 | 0) >>> 0 < 4294967232 ? B4 + 1 | 0 : B4) & g6 >>> 0 > 63 | B4)) break; + } + if (!(g6 | B4)) break A; + } + if (D4 = 0, l2(a4 + 32 | 0, a4 + 96 | 0, a4), o4 = 1 & g6, 1 != (0 | g6) | B4) for (B4 = 62 & g6, Q4 = 0; c4 = a4 + 32 | 0, C3[A8 + D4 | 0] = i3[c4 + D4 | 0] ^ i3[I7 + D4 | 0], C3[(g6 = 1 | D4) + A8 | 0] = i3[g6 + c4 | 0] ^ i3[I7 + g6 | 0], D4 = D4 + 2 | 0, (0 | B4) != (0 | (Q4 = Q4 + 2 | 0)); ) ; + o4 && (C3[A8 + D4 | 0] = i3[(a4 + 32 | 0) + D4 | 0] ^ i3[I7 + D4 | 0]); + } + MI(a4 + 32 | 0, 64), MI(a4, 32); + } + return r3 = a4 + 112 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, E4, i4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0; + var c4, D4, a4 = 0; + if (D4 = a4 = r3, r3 = c4 = a4 - 192 & -32, b3(o4 |= 0, i4 |= 0, c4 - -64 | 0), o4 = 0, E4 >>> 0 <= 63) i4 = 0; + else for (a4 = 64; N3(Q4 + o4 | 0, c4 - -64 | 0), o4 = i4 = a4, (a4 = i4 - -64 | 0) >>> 0 <= E4 >>> 0; ) ; + if ((a4 = 32 | i4) >>> 0 > E4 >>> 0) o4 = i4; + else for (; x3(Q4 + i4 | 0, c4 - -64 | 0), o4 = a4, (a4 = (i4 = a4) + 32 | 0) >>> 0 <= E4 >>> 0; ) ; + if ((i4 = 31 & E4) && (VA((a4 = c4 + 32 | 0) | i4, 0, 32 - i4 | 0), TA(a4, Q4 + o4 | 0, i4), x3(a4, c4 - -64 | 0)), o4 = 32, i4 = 0, B4 >>> 0 < 32) Q4 = 0; + else for (; G3(A8 + i4 | 0, C4 + i4 | 0, c4 - -64 | 0), Q4 = o4, (o4 = (i4 = o4) + 32 | 0) >>> 0 <= B4 >>> 0; ) ; + return (i4 = 31 & B4) && (VA((o4 = c4 + 32 | 0) | i4, 0, 32 - i4 | 0), TA(o4, C4 + Q4 | 0, i4), G3(c4, o4, c4 - -64 | 0), TA(A8 + Q4 | 0, c4, i4)), K3(I7, g6, E4, B4, c4 - -64 | 0), r3 = D4, 0; + }, function(A8, I7, g6, C4, B4, Q4, E4, i4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0; + var c4, D4, a4 = 0; + if (D4 = a4 = r3, r3 = c4 = a4 - 224 & -32, b3(o4 |= 0, i4 |= 0, c4 + 96 | 0), o4 = 0, E4 >>> 0 <= 63) i4 = 0; + else for (a4 = 64; N3(Q4 + o4 | 0, c4 + 96 | 0), o4 = i4 = a4, (a4 = i4 - -64 | 0) >>> 0 <= E4 >>> 0; ) ; + if ((a4 = 32 | i4) >>> 0 > E4 >>> 0) o4 = i4; + else for (; x3(Q4 + i4 | 0, c4 + 96 | 0), o4 = a4, (a4 = (i4 = a4) + 32 | 0) >>> 0 <= E4 >>> 0; ) ; + (i4 = 31 & E4) && (VA((a4 = c4 - -64 | 0) | i4, 0, 32 - i4 | 0), TA(a4, Q4 + o4 | 0, i4), x3(a4, c4 + 96 | 0)); + A: { + I: { + g: { + C: { + B: { + if (A8) { + if (o4 = 32, g6 >>> 0 < 32) break B; + for (Q4 = 0; H3(A8 + Q4 | 0, I7 + Q4 | 0, c4 + 96 | 0), Q4 = i4 = o4, (o4 = i4 + 32 | 0) >>> 0 <= g6 >>> 0; ) ; + } else { + if (Q4 = 32, g6 >>> 0 < 32) break g; + for (o4 = 0; H3(c4 + 32 | 0, I7 + o4 | 0, c4 + 96 | 0), o4 = i4 = Q4, (Q4 = i4 + 32 | 0) >>> 0 <= g6 >>> 0; ) ; + } + if (!(Q4 = 31 & g6)) break A; + if (A8) break C; + break I; + } + if (i4 = 0, Q4 = g6, !g6) break A; + } + Y3(A8 + i4 | 0, I7 + i4 | 0, Q4, c4 + 96 | 0); + break A; + } + if (i4 = 0, Q4 = g6, !g6) break A; + } + Y3(c4 + 32 | 0, I7 + i4 | 0, Q4, c4 + 96 | 0); + } + K3(c4, B4, E4, g6, c4 + 96 | 0), i4 = -1; + A: { + I: { + if (I7 = B4 - 16 | 0) { + if (16 == (0 | I7)) break I; + break A; + } + i4 = rA(c4, C4); + break A; + } + i4 = UA(c4, C4); + } + return !A8 | !i4 || VA(A8, 0, g6), r3 = D4, 0 | i4; + }, function(A8, I7, g6, C4, B4, Q4, o4, c4, D4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0; + var a4, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0; + if (r3 = a4 = r3 - 528 | 0, S3(D4 |= 0, c4 |= 0, a4 + 400 | 0), D4 = 0, o4 >>> 0 <= 31) c4 = 0; + else for (f4 = 32; d3(Q4 + D4 | 0, a4 + 400 | 0), D4 = c4 = f4, (f4 = c4 + 32 | 0) >>> 0 <= o4 >>> 0; ) ; + if ((D4 = 16 | c4) >>> 0 <= o4 >>> 0) for (f4 = a4 + 416 | 0, w4 = a4 + 432 | 0, t4 = a4 + 448 | 0, e4 = a4 + 464 | 0, h4 = a4 + 480 | 0; k4 = i3[0 | (c4 = Q4 + c4 | 0)] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, n4 = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, s4 = i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, F4 = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, c4 = E3[h4 + 12 >> 2], E3[a4 + 520 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 524 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 512 >> 2] = E3[h4 >> 2], E3[a4 + 516 >> 2] = c4, c4 = E3[e4 + 12 >> 2], E3[a4 + 376 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 380 >> 2] = c4, c4 = E3[e4 + 4 >> 2], E3[a4 + 368 >> 2] = E3[e4 >> 2], E3[a4 + 372 >> 2] = c4, c4 = E3[h4 + 12 >> 2], E3[a4 + 360 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 364 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 352 >> 2] = E3[h4 >> 2], E3[a4 + 356 >> 2] = c4, aA(c4 = a4 + 496 | 0, a4 + 368 | 0, a4 + 352 | 0), y4 = E3[a4 + 508 >> 2], E3[h4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[h4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[h4 >> 2] = E3[a4 + 496 >> 2], E3[h4 + 4 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 344 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 348 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 336 >> 2] = E3[t4 >> 2], E3[a4 + 340 >> 2] = y4, y4 = E3[e4 + 12 >> 2], E3[a4 + 328 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 332 >> 2] = y4, y4 = E3[e4 + 4 >> 2], E3[a4 + 320 >> 2] = E3[e4 >> 2], E3[a4 + 324 >> 2] = y4, aA(c4, a4 + 336 | 0, a4 + 320 | 0), y4 = E3[a4 + 508 >> 2], E3[e4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[e4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[e4 >> 2] = E3[a4 + 496 >> 2], E3[e4 + 4 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 312 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 316 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 304 >> 2] = E3[w4 >> 2], E3[a4 + 308 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 296 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 300 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 288 >> 2] = E3[t4 >> 2], E3[a4 + 292 >> 2] = y4, aA(c4, a4 + 304 | 0, a4 + 288 | 0), y4 = E3[a4 + 508 >> 2], E3[t4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[t4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[t4 >> 2] = E3[a4 + 496 >> 2], E3[t4 + 4 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 280 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 284 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 272 >> 2] = E3[f4 >> 2], E3[a4 + 276 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 264 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 268 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 256 >> 2] = E3[w4 >> 2], E3[a4 + 260 >> 2] = y4, aA(c4, a4 + 272 | 0, a4 + 256 | 0), y4 = E3[a4 + 508 >> 2], E3[w4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[w4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[w4 >> 2] = E3[a4 + 496 >> 2], E3[w4 + 4 >> 2] = y4, y4 = E3[a4 + 412 >> 2], E3[a4 + 248 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 252 >> 2] = y4, y4 = E3[a4 + 404 >> 2], E3[a4 + 240 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 244 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 232 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 236 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 224 >> 2] = E3[f4 >> 2], E3[a4 + 228 >> 2] = y4, aA(c4, a4 + 240 | 0, a4 + 224 | 0), y4 = E3[a4 + 508 >> 2], E3[f4 + 8 >> 2] = E3[a4 + 504 >> 2], E3[f4 + 12 >> 2] = y4, y4 = E3[a4 + 500 >> 2], E3[f4 >> 2] = E3[a4 + 496 >> 2], E3[f4 + 4 >> 2] = y4, y4 = E3[a4 + 524 >> 2], E3[a4 + 216 >> 2] = E3[a4 + 520 >> 2], E3[a4 + 220 >> 2] = y4, y4 = E3[a4 + 412 >> 2], E3[a4 + 200 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 204 >> 2] = y4, y4 = E3[a4 + 516 >> 2], E3[a4 + 208 >> 2] = E3[a4 + 512 >> 2], E3[a4 + 212 >> 2] = y4, y4 = E3[a4 + 404 >> 2], E3[a4 + 192 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 196 >> 2] = y4, aA(c4, a4 + 208 | 0, a4 + 192 | 0), E3[a4 + 412 >> 2] = F4 ^ E3[a4 + 508 >> 2], E3[a4 + 408 >> 2] = E3[a4 + 504 >> 2] ^ s4, E3[a4 + 404 >> 2] = E3[a4 + 500 >> 2] ^ n4, E3[a4 + 400 >> 2] = E3[a4 + 496 >> 2] ^ k4, (D4 = (c4 = D4) + 16 | 0) >>> 0 <= o4 >>> 0; ) ; + if ((D4 = 15 & o4) && (VA((f4 = a4 + 384 | 0) | D4, 0, 16 - D4 | 0), TA(f4, Q4 + c4 | 0, D4), D4 = E3[a4 + 384 >> 2], f4 = E3[a4 + 388 >> 2], w4 = E3[a4 + 392 >> 2], t4 = E3[a4 + 396 >> 2], c4 = E3[a4 + 492 >> 2], Q4 = E3[a4 + 488 >> 2], E3[a4 + 520 >> 2] = Q4, E3[a4 + 524 >> 2] = c4, e4 = E3[a4 + 476 >> 2], E3[a4 + 184 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 188 >> 2] = e4, E3[a4 + 168 >> 2] = Q4, E3[a4 + 172 >> 2] = c4, c4 = E3[a4 + 484 >> 2], Q4 = E3[a4 + 480 >> 2], E3[a4 + 512 >> 2] = Q4, E3[a4 + 516 >> 2] = c4, e4 = E3[a4 + 468 >> 2], E3[a4 + 176 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 180 >> 2] = e4, E3[a4 + 160 >> 2] = Q4, E3[a4 + 164 >> 2] = c4, aA(Q4 = a4 + 496 | 0, a4 + 176 | 0, a4 + 160 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 488 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 492 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 152 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 156 >> 2] = c4, c4 = E3[a4 + 476 >> 2], E3[a4 + 136 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 140 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 480 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 484 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 144 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 148 >> 2] = c4, c4 = E3[a4 + 468 >> 2], E3[a4 + 128 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 132 >> 2] = c4, aA(Q4, a4 + 144 | 0, a4 + 128 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 472 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 476 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 120 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 124 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 104 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 108 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 464 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 468 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 + 112 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 116 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 96 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 100 >> 2] = c4, aA(Q4, a4 + 112 | 0, a4 + 96 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 456 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 460 >> 2] = c4, c4 = E3[a4 + 428 >> 2], E3[a4 + 88 >> 2] = E3[a4 + 424 >> 2], E3[a4 + 92 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 72 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 76 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 448 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 452 >> 2] = c4, c4 = E3[a4 + 420 >> 2], E3[a4 + 80 >> 2] = E3[a4 + 416 >> 2], E3[a4 + 84 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 + 64 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 68 >> 2] = c4, aA(Q4, a4 + 80 | 0, a4 - -64 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 440 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 444 >> 2] = c4, c4 = E3[a4 + 412 >> 2], E3[a4 + 56 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 60 >> 2] = c4, c4 = E3[a4 + 428 >> 2], E3[a4 + 40 >> 2] = E3[a4 + 424 >> 2], E3[a4 + 44 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 432 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 436 >> 2] = c4, c4 = E3[a4 + 404 >> 2], E3[a4 + 48 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 52 >> 2] = c4, c4 = E3[a4 + 420 >> 2], E3[a4 + 32 >> 2] = E3[a4 + 416 >> 2], E3[a4 + 36 >> 2] = c4, aA(Q4, a4 + 48 | 0, a4 + 32 | 0), c4 = E3[a4 + 508 >> 2], E3[a4 + 424 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 428 >> 2] = c4, c4 = E3[a4 + 524 >> 2], E3[a4 + 24 >> 2] = E3[a4 + 520 >> 2], E3[a4 + 28 >> 2] = c4, c4 = E3[a4 + 412 >> 2], E3[a4 + 8 >> 2] = E3[a4 + 408 >> 2], E3[a4 + 12 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 416 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 420 >> 2] = c4, c4 = E3[a4 + 516 >> 2], E3[a4 + 16 >> 2] = E3[a4 + 512 >> 2], E3[a4 + 20 >> 2] = c4, c4 = E3[a4 + 404 >> 2], E3[a4 >> 2] = E3[a4 + 400 >> 2], E3[a4 + 4 >> 2] = c4, aA(Q4, a4 + 16 | 0, a4), E3[a4 + 412 >> 2] = t4 ^ E3[a4 + 508 >> 2], E3[a4 + 408 >> 2] = w4 ^ E3[a4 + 504 >> 2], E3[a4 + 404 >> 2] = f4 ^ E3[a4 + 500 >> 2], E3[a4 + 400 >> 2] = D4 ^ E3[a4 + 496 >> 2]), f4 = 16, c4 = 0, B4 >>> 0 < 16) D4 = 0; + else for (; R3(A8 + c4 | 0, C4 + c4 | 0, a4 + 400 | 0), D4 = f4, (f4 = (c4 = f4) + 16 | 0) >>> 0 <= B4 >>> 0; ) ; + return (Q4 = 15 & B4) && (VA((c4 = a4 + 384 | 0) | Q4, 0, 16 - Q4 | 0), TA(c4, C4 + D4 | 0, Q4), R3(C4 = a4 + 512 | 0, c4, a4 + 400 | 0), TA(A8 + D4 | 0, C4, Q4)), J3(I7, g6, o4, B4, a4 + 400 | 0), r3 = a4 + 528 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, o4, c4, D4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0; + var a4, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0; + if (r3 = a4 = r3 - 544 | 0, S3(D4 |= 0, c4 |= 0, a4 + 432 | 0), D4 = 0, o4 >>> 0 <= 31) c4 = 0; + else for (f4 = 32; d3(Q4 + D4 | 0, a4 + 432 | 0), D4 = c4 = f4, (f4 = c4 + 32 | 0) >>> 0 <= o4 >>> 0; ) ; + if ((D4 = 16 | c4) >>> 0 <= o4 >>> 0) for (f4 = a4 + 448 | 0, w4 = a4 + 464 | 0, t4 = a4 + 480 | 0, e4 = a4 + 496 | 0, h4 = a4 + 512 | 0; k4 = i3[0 | (c4 = Q4 + c4 | 0)] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, n4 = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, s4 = i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, F4 = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, c4 = E3[h4 + 12 >> 2], E3[a4 + 392 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 396 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 384 >> 2] = E3[h4 >> 2], E3[a4 + 388 >> 2] = c4, c4 = E3[e4 + 12 >> 2], E3[a4 + 376 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 380 >> 2] = c4, c4 = E3[e4 + 4 >> 2], E3[a4 + 368 >> 2] = E3[e4 >> 2], E3[a4 + 372 >> 2] = c4, c4 = E3[h4 + 12 >> 2], E3[a4 + 360 >> 2] = E3[h4 + 8 >> 2], E3[a4 + 364 >> 2] = c4, c4 = E3[h4 + 4 >> 2], E3[a4 + 352 >> 2] = E3[h4 >> 2], E3[a4 + 356 >> 2] = c4, aA(c4 = a4 + 528 | 0, a4 + 368 | 0, a4 + 352 | 0), y4 = E3[a4 + 540 >> 2], E3[h4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[h4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[h4 >> 2] = E3[a4 + 528 >> 2], E3[h4 + 4 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 344 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 348 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 336 >> 2] = E3[t4 >> 2], E3[a4 + 340 >> 2] = y4, y4 = E3[e4 + 12 >> 2], E3[a4 + 328 >> 2] = E3[e4 + 8 >> 2], E3[a4 + 332 >> 2] = y4, y4 = E3[e4 + 4 >> 2], E3[a4 + 320 >> 2] = E3[e4 >> 2], E3[a4 + 324 >> 2] = y4, aA(c4, a4 + 336 | 0, a4 + 320 | 0), y4 = E3[a4 + 540 >> 2], E3[e4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[e4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[e4 >> 2] = E3[a4 + 528 >> 2], E3[e4 + 4 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 312 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 316 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 304 >> 2] = E3[w4 >> 2], E3[a4 + 308 >> 2] = y4, y4 = E3[t4 + 12 >> 2], E3[a4 + 296 >> 2] = E3[t4 + 8 >> 2], E3[a4 + 300 >> 2] = y4, y4 = E3[t4 + 4 >> 2], E3[a4 + 288 >> 2] = E3[t4 >> 2], E3[a4 + 292 >> 2] = y4, aA(c4, a4 + 304 | 0, a4 + 288 | 0), y4 = E3[a4 + 540 >> 2], E3[t4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[t4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[t4 >> 2] = E3[a4 + 528 >> 2], E3[t4 + 4 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 280 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 284 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 272 >> 2] = E3[f4 >> 2], E3[a4 + 276 >> 2] = y4, y4 = E3[w4 + 12 >> 2], E3[a4 + 264 >> 2] = E3[w4 + 8 >> 2], E3[a4 + 268 >> 2] = y4, y4 = E3[w4 + 4 >> 2], E3[a4 + 256 >> 2] = E3[w4 >> 2], E3[a4 + 260 >> 2] = y4, aA(c4, a4 + 272 | 0, a4 + 256 | 0), y4 = E3[a4 + 540 >> 2], E3[w4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[w4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[w4 >> 2] = E3[a4 + 528 >> 2], E3[w4 + 4 >> 2] = y4, y4 = E3[a4 + 444 >> 2], E3[a4 + 248 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 252 >> 2] = y4, y4 = E3[a4 + 436 >> 2], E3[a4 + 240 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 244 >> 2] = y4, y4 = E3[f4 + 12 >> 2], E3[a4 + 232 >> 2] = E3[f4 + 8 >> 2], E3[a4 + 236 >> 2] = y4, y4 = E3[f4 + 4 >> 2], E3[a4 + 224 >> 2] = E3[f4 >> 2], E3[a4 + 228 >> 2] = y4, aA(c4, a4 + 240 | 0, a4 + 224 | 0), y4 = E3[a4 + 540 >> 2], E3[f4 + 8 >> 2] = E3[a4 + 536 >> 2], E3[f4 + 12 >> 2] = y4, y4 = E3[a4 + 532 >> 2], E3[f4 >> 2] = E3[a4 + 528 >> 2], E3[f4 + 4 >> 2] = y4, y4 = E3[a4 + 396 >> 2], E3[a4 + 216 >> 2] = E3[a4 + 392 >> 2], E3[a4 + 220 >> 2] = y4, y4 = E3[a4 + 444 >> 2], E3[a4 + 200 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 204 >> 2] = y4, y4 = E3[a4 + 388 >> 2], E3[a4 + 208 >> 2] = E3[a4 + 384 >> 2], E3[a4 + 212 >> 2] = y4, y4 = E3[a4 + 436 >> 2], E3[a4 + 192 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 196 >> 2] = y4, aA(c4, a4 + 208 | 0, a4 + 192 | 0), E3[a4 + 444 >> 2] = F4 ^ E3[a4 + 540 >> 2], E3[a4 + 440 >> 2] = E3[a4 + 536 >> 2] ^ s4, E3[a4 + 436 >> 2] = E3[a4 + 532 >> 2] ^ n4, E3[a4 + 432 >> 2] = E3[a4 + 528 >> 2] ^ k4, (D4 = (c4 = D4) + 16 | 0) >>> 0 <= o4 >>> 0; ) ; + (D4 = 15 & o4) && (VA((f4 = a4 + 416 | 0) | D4, 0, 16 - D4 | 0), TA(f4, Q4 + c4 | 0, D4), D4 = E3[a4 + 416 >> 2], f4 = E3[a4 + 420 >> 2], w4 = E3[a4 + 424 >> 2], t4 = E3[a4 + 428 >> 2], c4 = E3[a4 + 524 >> 2], Q4 = E3[a4 + 520 >> 2], E3[a4 + 392 >> 2] = Q4, E3[a4 + 396 >> 2] = c4, e4 = E3[a4 + 508 >> 2], E3[a4 + 184 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 188 >> 2] = e4, E3[a4 + 168 >> 2] = Q4, E3[a4 + 172 >> 2] = c4, c4 = E3[a4 + 516 >> 2], Q4 = E3[a4 + 512 >> 2], E3[a4 + 384 >> 2] = Q4, E3[a4 + 388 >> 2] = c4, e4 = E3[a4 + 500 >> 2], E3[a4 + 176 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 180 >> 2] = e4, E3[a4 + 160 >> 2] = Q4, E3[a4 + 164 >> 2] = c4, aA(Q4 = a4 + 528 | 0, a4 + 176 | 0, a4 + 160 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 520 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 524 >> 2] = c4, c4 = E3[a4 + 492 >> 2], E3[a4 + 152 >> 2] = E3[a4 + 488 >> 2], E3[a4 + 156 >> 2] = c4, c4 = E3[a4 + 508 >> 2], E3[a4 + 136 >> 2] = E3[a4 + 504 >> 2], E3[a4 + 140 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 512 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 516 >> 2] = c4, c4 = E3[a4 + 484 >> 2], E3[a4 + 144 >> 2] = E3[a4 + 480 >> 2], E3[a4 + 148 >> 2] = c4, c4 = E3[a4 + 500 >> 2], E3[a4 + 128 >> 2] = E3[a4 + 496 >> 2], E3[a4 + 132 >> 2] = c4, aA(Q4, a4 + 144 | 0, a4 + 128 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 504 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 508 >> 2] = c4, c4 = E3[a4 + 476 >> 2], E3[a4 + 120 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 124 >> 2] = c4, c4 = E3[a4 + 492 >> 2], E3[a4 + 104 >> 2] = E3[a4 + 488 >> 2], E3[a4 + 108 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 496 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 500 >> 2] = c4, c4 = E3[a4 + 468 >> 2], E3[a4 + 112 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 116 >> 2] = c4, c4 = E3[a4 + 484 >> 2], E3[a4 + 96 >> 2] = E3[a4 + 480 >> 2], E3[a4 + 100 >> 2] = c4, aA(Q4, a4 + 112 | 0, a4 + 96 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 488 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 492 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 88 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 92 >> 2] = c4, c4 = E3[a4 + 476 >> 2], E3[a4 + 72 >> 2] = E3[a4 + 472 >> 2], E3[a4 + 76 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 480 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 484 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 80 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 84 >> 2] = c4, c4 = E3[a4 + 468 >> 2], E3[a4 + 64 >> 2] = E3[a4 + 464 >> 2], E3[a4 + 68 >> 2] = c4, aA(Q4, a4 + 80 | 0, a4 - -64 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 472 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 476 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 56 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 60 >> 2] = c4, c4 = E3[a4 + 460 >> 2], E3[a4 + 40 >> 2] = E3[a4 + 456 >> 2], E3[a4 + 44 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 464 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 468 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 + 48 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 52 >> 2] = c4, c4 = E3[a4 + 452 >> 2], E3[a4 + 32 >> 2] = E3[a4 + 448 >> 2], E3[a4 + 36 >> 2] = c4, aA(Q4, a4 + 48 | 0, a4 + 32 | 0), c4 = E3[a4 + 540 >> 2], E3[a4 + 456 >> 2] = E3[a4 + 536 >> 2], E3[a4 + 460 >> 2] = c4, c4 = E3[a4 + 396 >> 2], E3[a4 + 24 >> 2] = E3[a4 + 392 >> 2], E3[a4 + 28 >> 2] = c4, c4 = E3[a4 + 444 >> 2], E3[a4 + 8 >> 2] = E3[a4 + 440 >> 2], E3[a4 + 12 >> 2] = c4, c4 = E3[a4 + 532 >> 2], E3[a4 + 448 >> 2] = E3[a4 + 528 >> 2], E3[a4 + 452 >> 2] = c4, c4 = E3[a4 + 388 >> 2], E3[a4 + 16 >> 2] = E3[a4 + 384 >> 2], E3[a4 + 20 >> 2] = c4, c4 = E3[a4 + 436 >> 2], E3[a4 >> 2] = E3[a4 + 432 >> 2], E3[a4 + 4 >> 2] = c4, aA(Q4, a4 + 16 | 0, a4), E3[a4 + 444 >> 2] = t4 ^ E3[a4 + 540 >> 2], E3[a4 + 440 >> 2] = w4 ^ E3[a4 + 536 >> 2], E3[a4 + 436 >> 2] = f4 ^ E3[a4 + 532 >> 2], E3[a4 + 432 >> 2] = D4 ^ E3[a4 + 528 >> 2]); + A: { + I: { + g: { + C: { + B: { + if (A8) { + if (f4 = 16, g6 >>> 0 < 16) break B; + for (D4 = 0; L3(A8 + D4 | 0, I7 + D4 | 0, a4 + 432 | 0), D4 = c4 = f4, (f4 = c4 + 16 | 0) >>> 0 <= g6 >>> 0; ) ; + } else { + if (D4 = 16, g6 >>> 0 < 16) break g; + for (f4 = 0; L3(a4 + 528 | 0, I7 + f4 | 0, a4 + 432 | 0), f4 = c4 = D4, (D4 = c4 + 16 | 0) >>> 0 <= g6 >>> 0; ) ; + } + if (!(D4 = 15 & g6)) break A; + if (A8) break C; + break I; + } + if (c4 = 0, !(D4 = g6)) break A; + } + u3(A8 + c4 | 0, I7 + c4 | 0, D4, a4 + 432 | 0); + break A; + } + if (c4 = 0, !(D4 = g6)) break A; + } + u3(a4 + 528 | 0, I7 + c4 | 0, D4, a4 + 432 | 0); + } + J3(a4 + 384 | 0, B4, o4, g6, a4 + 432 | 0), c4 = -1; + A: { + I: { + if (I7 = B4 - 16 | 0) { + if (16 == (0 | I7)) break I; + break A; + } + c4 = rA(a4 + 384 | 0, C4); + break A; + } + c4 = UA(a4 + 384 | 0, C4); + } + return !A8 | !c4 || VA(A8, 0, g6), r3 = a4 + 544 | 0, 0 | c4; + }, function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 + -64 | 0, (I7 |= 0) | (g6 |= 0) && (E3[Q4 + 8 >> 2] = 2036477234, E3[Q4 + 12 >> 2] = 1797285236, E3[Q4 >> 2] = 1634760805, E3[Q4 + 4 >> 2] = 857760878, E3[Q4 + 16 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[Q4 + 20 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[Q4 + 24 >> 2] = i3[B4 + 8 | 0] | i3[B4 + 9 | 0] << 8 | i3[B4 + 10 | 0] << 16 | i3[B4 + 11 | 0] << 24, E3[Q4 + 28 >> 2] = i3[B4 + 12 | 0] | i3[B4 + 13 | 0] << 8 | i3[B4 + 14 | 0] << 16 | i3[B4 + 15 | 0] << 24, E3[Q4 + 32 >> 2] = i3[B4 + 16 | 0] | i3[B4 + 17 | 0] << 8 | i3[B4 + 18 | 0] << 16 | i3[B4 + 19 | 0] << 24, E3[Q4 + 36 >> 2] = i3[B4 + 20 | 0] | i3[B4 + 21 | 0] << 8 | i3[B4 + 22 | 0] << 16 | i3[B4 + 23 | 0] << 24, E3[Q4 + 40 >> 2] = i3[B4 + 24 | 0] | i3[B4 + 25 | 0] << 8 | i3[B4 + 26 | 0] << 16 | i3[B4 + 27 | 0] << 24, B4 = i3[B4 + 28 | 0] | i3[B4 + 29 | 0] << 8 | i3[B4 + 30 | 0] << 16 | i3[B4 + 31 | 0] << 24, E3[Q4 + 48 >> 2] = 0, E3[Q4 + 52 >> 2] = 0, E3[Q4 + 44 >> 2] = B4, E3[Q4 + 56 >> 2] = i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24, E3[Q4 + 60 >> 2] = i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24, P3(Q4, A8 = VA(A8, 0, I7), A8, I7, g6), MI(Q4, 64)), r3 = Q4 - -64 | 0, 0; + }, function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 + -64 | 0, (I7 |= 0) | (g6 |= 0) && (E3[Q4 + 8 >> 2] = 2036477234, E3[Q4 + 12 >> 2] = 1797285236, E3[Q4 >> 2] = 1634760805, E3[Q4 + 4 >> 2] = 857760878, E3[Q4 + 16 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[Q4 + 20 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[Q4 + 24 >> 2] = i3[B4 + 8 | 0] | i3[B4 + 9 | 0] << 8 | i3[B4 + 10 | 0] << 16 | i3[B4 + 11 | 0] << 24, E3[Q4 + 28 >> 2] = i3[B4 + 12 | 0] | i3[B4 + 13 | 0] << 8 | i3[B4 + 14 | 0] << 16 | i3[B4 + 15 | 0] << 24, E3[Q4 + 32 >> 2] = i3[B4 + 16 | 0] | i3[B4 + 17 | 0] << 8 | i3[B4 + 18 | 0] << 16 | i3[B4 + 19 | 0] << 24, E3[Q4 + 36 >> 2] = i3[B4 + 20 | 0] | i3[B4 + 21 | 0] << 8 | i3[B4 + 22 | 0] << 16 | i3[B4 + 23 | 0] << 24, E3[Q4 + 40 >> 2] = i3[B4 + 24 | 0] | i3[B4 + 25 | 0] << 8 | i3[B4 + 26 | 0] << 16 | i3[B4 + 27 | 0] << 24, B4 = i3[B4 + 28 | 0] | i3[B4 + 29 | 0] << 8 | i3[B4 + 30 | 0] << 16 | i3[B4 + 31 | 0] << 24, E3[Q4 + 48 >> 2] = 0, E3[Q4 + 44 >> 2] = B4, E3[Q4 + 52 >> 2] = i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24, E3[Q4 + 56 >> 2] = i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24, E3[Q4 + 60 >> 2] = i3[C4 + 8 | 0] | i3[C4 + 9 | 0] << 8 | i3[C4 + 10 | 0] << 16 | i3[C4 + 11 | 0] << 24, P3(Q4, A8 = VA(A8, 0, I7), A8, I7, g6), MI(Q4, 64)), r3 = Q4 - -64 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, o4, c4) { + var D4; + return A8 |= 0, I7 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0, c4 |= 0, r3 = D4 = r3 + -64 | 0, (g6 |= 0) | (C4 |= 0) && (E3[D4 + 8 >> 2] = 2036477234, E3[D4 + 12 >> 2] = 1797285236, E3[D4 >> 2] = 1634760805, E3[D4 + 4 >> 2] = 857760878, E3[D4 + 16 >> 2] = i3[0 | c4] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, E3[D4 + 20 >> 2] = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, E3[D4 + 24 >> 2] = i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, E3[D4 + 28 >> 2] = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, E3[D4 + 32 >> 2] = i3[c4 + 16 | 0] | i3[c4 + 17 | 0] << 8 | i3[c4 + 18 | 0] << 16 | i3[c4 + 19 | 0] << 24, E3[D4 + 36 >> 2] = i3[c4 + 20 | 0] | i3[c4 + 21 | 0] << 8 | i3[c4 + 22 | 0] << 16 | i3[c4 + 23 | 0] << 24, E3[D4 + 40 >> 2] = i3[c4 + 24 | 0] | i3[c4 + 25 | 0] << 8 | i3[c4 + 26 | 0] << 16 | i3[c4 + 27 | 0] << 24, E3[D4 + 44 >> 2] = i3[c4 + 28 | 0] | i3[c4 + 29 | 0] << 8 | i3[c4 + 30 | 0] << 16 | i3[c4 + 31 | 0] << 24, E3[D4 + 48 >> 2] = Q4, E3[D4 + 52 >> 2] = o4, E3[D4 + 56 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[D4 + 60 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, P3(D4, I7, A8, g6, C4), MI(D4, 64)), r3 = D4 - -64 | 0, 0; + }, function(A8, I7, g6, C4, B4, Q4, o4) { + var c4; + return A8 |= 0, I7 |= 0, B4 |= 0, Q4 |= 0, o4 |= 0, r3 = c4 = r3 + -64 | 0, (g6 |= 0) | (C4 |= 0) && (E3[c4 + 8 >> 2] = 2036477234, E3[c4 + 12 >> 2] = 1797285236, E3[c4 >> 2] = 1634760805, E3[c4 + 4 >> 2] = 857760878, E3[c4 + 16 >> 2] = i3[0 | o4] | i3[o4 + 1 | 0] << 8 | i3[o4 + 2 | 0] << 16 | i3[o4 + 3 | 0] << 24, E3[c4 + 20 >> 2] = i3[o4 + 4 | 0] | i3[o4 + 5 | 0] << 8 | i3[o4 + 6 | 0] << 16 | i3[o4 + 7 | 0] << 24, E3[c4 + 24 >> 2] = i3[o4 + 8 | 0] | i3[o4 + 9 | 0] << 8 | i3[o4 + 10 | 0] << 16 | i3[o4 + 11 | 0] << 24, E3[c4 + 28 >> 2] = i3[o4 + 12 | 0] | i3[o4 + 13 | 0] << 8 | i3[o4 + 14 | 0] << 16 | i3[o4 + 15 | 0] << 24, E3[c4 + 32 >> 2] = i3[o4 + 16 | 0] | i3[o4 + 17 | 0] << 8 | i3[o4 + 18 | 0] << 16 | i3[o4 + 19 | 0] << 24, E3[c4 + 36 >> 2] = i3[o4 + 20 | 0] | i3[o4 + 21 | 0] << 8 | i3[o4 + 22 | 0] << 16 | i3[o4 + 23 | 0] << 24, E3[c4 + 40 >> 2] = i3[o4 + 24 | 0] | i3[o4 + 25 | 0] << 8 | i3[o4 + 26 | 0] << 16 | i3[o4 + 27 | 0] << 24, o4 = i3[o4 + 28 | 0] | i3[o4 + 29 | 0] << 8 | i3[o4 + 30 | 0] << 16 | i3[o4 + 31 | 0] << 24, E3[c4 + 48 >> 2] = Q4, E3[c4 + 44 >> 2] = o4, E3[c4 + 52 >> 2] = i3[0 | B4] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, E3[c4 + 56 >> 2] = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[c4 + 60 >> 2] = i3[B4 + 8 | 0] | i3[B4 + 9 | 0] << 8 | i3[B4 + 10 | 0] << 16 | i3[B4 + 11 | 0] << 24, P3(c4, I7, A8, g6, C4), MI(c4, 64)), r3 = c4 - -64 | 0, 0; + }], PI.grow = function(A8) { + var I7 = this.length; + return this.length = this.length + A8, I7; + }, PI.set = function(A8, I7) { + this[A8] = I7; + }, PI.get = function(A8) { + return this[A8]; + }, PI); + function RI() { + return g5.byteLength / 65536 | 0; + } + return { e: Object.create(Object.prototype, { grow: { value: function(A8) { + A8 |= 0; + var B4 = 0 | RI(), Q4 = B4 + A8 | 0; + if (B4 < Q4 && Q4 < 65536) { + var D4 = new ArrayBuffer(c3(Q4, 65536)); + new Int8Array(D4).set(C3), C3 = new Int8Array(D4), new Int16Array(D4), E3 = new Int32Array(D4), i3 = new Uint8Array(D4), new Uint16Array(D4), o3 = new Uint32Array(D4), new Float32Array(D4), new Float64Array(D4), g5 = D4, I6 = i3; + } + return B4; + } }, buffer: { get: function() { + return g5; + } } }), f: function() { + }, g: KI, h: YI, i: KI, j: _I, k: GI, l: SI, m: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | bA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, c4 |= 0, D4 |= 0, 36272); + }, n: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | qA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, D4 |= 0, a4 |= 0, 36272); + }, o: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | YA(A8 |= 0, I7 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36276); + }, p: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | XA(A8 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36276); + }, q: _I, r: YI, s: _I, t: _I, u: GI, v: FI, w: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | bA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, c4 |= 0, D4 |= 0, 36280); + }, x: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | qA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, D4 |= 0, a4 |= 0, 36280); + }, y: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | YA(A8 |= 0, I7 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36284); + }, z: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | XA(A8 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0, i4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0, 36284); + }, A: YI, B: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | JA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, (A8 = 0) | (B4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, D4 |= 0, a4 |= 0); + }, C: function(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return A8 |= 0, I7 |= 0, C4 |= 0, o4 |= 0, D4 |= 0, o4 |= D4 = 0, !(B4 |= 0) & (C4 |= D4) >>> 0 < 4294967280 ? (JA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, i4 |= 0, o4, c4 |= 0, a4 |= 0, y4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8, E3[I7 + 4 >> 2] = B4)) : (iI(), Q3()), 0; + }, D: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | HA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, (A8 = 0) | (B4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, D4 |= 0, a4 |= 0); + }, E: function(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return A8 |= 0, I7 |= 0, C4 |= 0, o4 |= 0, D4 |= 0, o4 |= D4 = 0, !(B4 |= 0) & (C4 |= D4) >>> 0 < 4294967280 ? (HA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, i4 |= 0, o4, c4 |= 0, a4 |= 0, y4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8, E3[I7 + 4 >> 2] = B4)) : (iI(), Q3()), 0; + }, F: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | GA(A8 |= 0, g6 |= 0, (A8 = 0) | (C4 |= 0), B4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, c4 |= 0, D4 |= 0); + }, G: function(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, o4 |= 0, o4 |= 0, g6 = -1, !(Q4 |= 0) & (B4 |= 0) >>> 0 >= 16 | Q4 && (g6 = GA(A8 |= 0, C4, B4 - 16 | 0, Q4 - (B4 >>> 0 < 16) | 0, (C4 + B4 | 0) - 16 | 0, i4 |= 0, o4, c4 |= 0, D4 |= 0, a4 |= 0)), I7 && (E3[I7 >> 2] = g6 ? 0 : B4 - 16 | 0, E3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (B4 >>> 0 < 16) | 0), 0 | g6; + }, H: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | pA(A8 |= 0, g6 |= 0, (A8 = 0) | (C4 |= 0), B4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, c4 |= 0, D4 |= 0); + }, I: function(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, o4 |= 0, o4 |= 0, g6 = -1, !(Q4 |= 0) & (B4 |= 0) >>> 0 >= 16 | Q4 && (g6 = pA(A8 |= 0, C4, B4 - 16 | 0, Q4 - (B4 >>> 0 < 16) | 0, (C4 + B4 | 0) - 16 | 0, i4 |= 0, o4, c4 |= 0, D4 |= 0, a4 |= 0)), I7 && (E3[I7 >> 2] = g6 ? 0 : B4 - 16 | 0, E3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (B4 >>> 0 < 16) | 0), 0 | g6; + }, J: _I, K: function() { + return 12; + }, L: YI, M: KI, N: HI, O: FI, P: _I, Q: UI, R: YI, S: KI, T: HI, U: FI, V: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4, a4) { + return 0 | sA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, (A8 = 0) | (B4 |= 0), Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, D4 |= 0, a4 |= 0); + }, W: function(A8, I7, g6, C4, B4, i4, o4, c4, D4, a4, y4) { + return A8 |= 0, I7 |= 0, C4 |= 0, o4 |= 0, D4 |= 0, o4 |= D4 = 0, !(B4 |= 0) & (C4 |= D4) >>> 0 < 4294967280 ? (sA(A8, A8 + C4 | 0, 0, g6 |= 0, C4, B4, i4 |= 0, o4, c4 |= 0, a4 |= 0, y4 |= 0), I7 && (B4 = (A8 = C4 + 16 | 0) >>> 0 < 16 ? B4 + 1 | 0 : B4, E3[I7 >> 2] = A8, E3[I7 + 4 >> 2] = B4)) : (iI(), Q3()), 0; + }, X: function(A8, I7, g6, C4, B4, Q4, E4, i4, o4, c4, D4) { + return 0 | nA(A8 |= 0, g6 |= 0, (A8 = 0) | (C4 |= 0), B4 |= 0, Q4 |= 0, E4 |= 0, A8 | (i4 |= 0), o4 |= 0, c4 |= 0, D4 |= 0); + }, Y: function(A8, I7, g6, C4, B4, Q4, i4, o4, c4, D4, a4) { + return I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, o4 |= 0, o4 |= 0, g6 = -1, !(Q4 |= 0) & (B4 |= 0) >>> 0 >= 16 | Q4 && (g6 = nA(A8 |= 0, C4, B4 - 16 | 0, Q4 - (B4 >>> 0 < 16) | 0, (C4 + B4 | 0) - 16 | 0, i4 |= 0, o4, c4 |= 0, D4 |= 0, a4 |= 0)), I7 && (E3[I7 >> 2] = g6 ? 0 : B4 - 16 | 0, E3[I7 + 4 >> 2] = g6 ? 0 : Q4 - (B4 >>> 0 < 16) | 0), 0 | g6; + }, Z: _I, _: pI, $: YI, aa: KI, ba: HI, ca: FI, da: _I, ea: _I, fa: function(A8, I7, g6, B4, Q4) { + var i4; + return A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, r3 = i4 = r3 - 480 | 0, wA(i4, Q4 |= 0, 32), tI(i4, I7, g6, B4), WA(i4, i4 + 416 | 0), I7 = E3[i4 + 444 >> 2], g6 = E3[i4 + 440 >> 2], C3[A8 + 24 | 0] = g6, C3[A8 + 25 | 0] = g6 >>> 8, C3[A8 + 26 | 0] = g6 >>> 16, C3[A8 + 27 | 0] = g6 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[i4 + 436 >> 2], g6 = E3[i4 + 432 >> 2], C3[A8 + 16 | 0] = g6, C3[A8 + 17 | 0] = g6 >>> 8, C3[A8 + 18 | 0] = g6 >>> 16, C3[A8 + 19 | 0] = g6 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[i4 + 428 >> 2], g6 = E3[i4 + 424 >> 2], C3[A8 + 8 | 0] = g6, C3[A8 + 9 | 0] = g6 >>> 8, C3[A8 + 10 | 0] = g6 >>> 16, C3[A8 + 11 | 0] = g6 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[i4 + 420 >> 2], g6 = E3[i4 + 416 >> 2], C3[0 | A8] = g6, C3[A8 + 1 | 0] = g6 >>> 8, C3[A8 + 2 | 0] = g6 >>> 16, C3[A8 + 3 | 0] = g6 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, r3 = i4 + 480 | 0, 0; + }, ga: function(A8, I7, g6, C4, B4) { + var Q4, i4; + return A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, r3 = Q4 = r3 - 512 | 0, wA(i4 = Q4 + 32 | 0, B4 |= 0, 32), tI(i4, I7, g6, C4), WA(i4, Q4 + 448 | 0), I7 = E3[Q4 + 476 >> 2], E3[Q4 + 24 >> 2] = E3[Q4 + 472 >> 2], E3[Q4 + 28 >> 2] = I7, I7 = E3[Q4 + 468 >> 2], E3[Q4 + 16 >> 2] = E3[Q4 + 464 >> 2], E3[Q4 + 20 >> 2] = I7, I7 = E3[Q4 + 460 >> 2], E3[Q4 + 8 >> 2] = E3[Q4 + 456 >> 2], E3[Q4 + 12 >> 2] = I7, I7 = E3[Q4 + 452 >> 2], E3[Q4 >> 2] = E3[Q4 + 448 >> 2], E3[Q4 + 4 >> 2] = I7, I7 = UA(A8, Q4), g6 = NA(Q4, A8, 32), r3 = Q4 + 512 | 0, ((0 | A8) == (0 | Q4) ? -1 : I7) | g6; + }, ha: FI, ia: _I, ja: _I, ka: _I, la: _I, ma: pI, na: KI, oa: HI, pa: function(A8, I7, g6) { + A8 |= 0, I7 |= 0; + var B4, Q4 = 0; + return r3 = B4 = r3 + -64 | 0, FA(B4, g6 |= 0, 32, 0), g6 = E3[B4 + 28 >> 2], Q4 = E3[B4 + 24 >> 2], C3[I7 + 24 | 0] = Q4, C3[I7 + 25 | 0] = Q4 >>> 8, C3[I7 + 26 | 0] = Q4 >>> 16, C3[I7 + 27 | 0] = Q4 >>> 24, C3[I7 + 28 | 0] = g6, C3[I7 + 29 | 0] = g6 >>> 8, C3[I7 + 30 | 0] = g6 >>> 16, C3[I7 + 31 | 0] = g6 >>> 24, g6 = E3[B4 + 20 >> 2], Q4 = E3[B4 + 16 >> 2], C3[I7 + 16 | 0] = Q4, C3[I7 + 17 | 0] = Q4 >>> 8, C3[I7 + 18 | 0] = Q4 >>> 16, C3[I7 + 19 | 0] = Q4 >>> 24, C3[I7 + 20 | 0] = g6, C3[I7 + 21 | 0] = g6 >>> 8, C3[I7 + 22 | 0] = g6 >>> 16, C3[I7 + 23 | 0] = g6 >>> 24, g6 = E3[B4 + 12 >> 2], Q4 = E3[B4 + 8 >> 2], C3[I7 + 8 | 0] = Q4, C3[I7 + 9 | 0] = Q4 >>> 8, C3[I7 + 10 | 0] = Q4 >>> 16, C3[I7 + 11 | 0] = Q4 >>> 24, C3[I7 + 12 | 0] = g6, C3[I7 + 13 | 0] = g6 >>> 8, C3[I7 + 14 | 0] = g6 >>> 16, C3[I7 + 15 | 0] = g6 >>> 24, g6 = E3[B4 + 4 >> 2], Q4 = E3[B4 >> 2], C3[0 | I7] = Q4, C3[I7 + 1 | 0] = Q4 >>> 8, C3[I7 + 2 | 0] = Q4 >>> 16, C3[I7 + 3 | 0] = Q4 >>> 24, C3[I7 + 4 | 0] = g6, C3[I7 + 5 | 0] = g6 >>> 8, C3[I7 + 6 | 0] = g6 >>> 16, C3[I7 + 7 | 0] = g6 >>> 24, MI(B4, 64), A8 = hI(A8, I7), r3 = B4 - -64 | 0, 0 | A8; + }, qa: cI, ra: OA, sa: $A, ta: function(A8, I7, g6, C4, B4, Q4, E4, i4) { + A8 |= 0, I7 |= 0, g6 |= 0, Q4 |= 0; + var o4, c4 = 0; + return c4 = C4 |= 0, C4 = B4 |= 0, o4 = 0 | c4, r3 = c4 = r3 - 32 | 0, B4 = -1, OA(c4, E4 |= 0, i4 |= 0) || (B4 = tA(A8, I7, g6, o4, C4, Q4, c4), MI(c4, 32)), r3 = c4 + 32 | 0, 0 | B4; + }, ua: function(A8, I7, g6, C4, B4, E4) { + return A8 |= 0, I7 |= 0, B4 |= 0, E4 |= 0, !(C4 |= 0) & (g6 |= 0) >>> 0 >= 4294967280 | C4 && (iI(), Q3()), 0 | tA(A8 + 16 | 0, A8, I7, g6, C4, B4, E4); + }, va: function(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | zA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + }, wa: AI, xa: function(A8, I7, g6, C4, B4, Q4, E4, i4) { + A8 |= 0, I7 |= 0, g6 |= 0, Q4 |= 0; + var o4, c4 = 0; + return c4 = C4 |= 0, C4 = B4 |= 0, o4 = 0 | c4, r3 = c4 = r3 - 32 | 0, B4 = -1, OA(c4, E4 |= 0, i4 |= 0) || (B4 = kA(A8, I7, g6, o4, C4, Q4, c4), MI(c4, 32)), r3 = c4 + 32 | 0, 0 | B4; + }, ya: jA, za: function(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | xA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + }, Aa: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, Q4 |= 0; + var i4, o4, c4, D4, a4 = 0, y4 = 0; + return a4 = g6 |= 0, g6 = B4 |= 0, D4 = 0 | a4, a4 = B4 = r3, r3 = i4 = B4 - 512 & -64, B4 = -1, cI(o4 = i4 - -64 | 0, c4 = i4 + 32 | 0) || (j(B4 = i4 + 128 | 0, 0, 0, 24), cA(B4, o4, 32, 0), cA(B4, Q4, 32, 0), ZA(B4, y4 = i4 + 96 | 0, 24), B4 = zA(A8 + 32 | 0, I7, D4, g6, y4, Q4, c4), I7 = E3[i4 + 92 >> 2], g6 = E3[i4 + 88 >> 2], C3[A8 + 24 | 0] = g6, C3[A8 + 25 | 0] = g6 >>> 8, C3[A8 + 26 | 0] = g6 >>> 16, C3[A8 + 27 | 0] = g6 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[i4 + 84 >> 2], g6 = E3[i4 + 80 >> 2], C3[A8 + 16 | 0] = g6, C3[A8 + 17 | 0] = g6 >>> 8, C3[A8 + 18 | 0] = g6 >>> 16, C3[A8 + 19 | 0] = g6 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[i4 + 76 >> 2], g6 = E3[i4 + 72 >> 2], C3[A8 + 8 | 0] = g6, C3[A8 + 9 | 0] = g6 >>> 8, C3[A8 + 10 | 0] = g6 >>> 16, C3[A8 + 11 | 0] = g6 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[i4 + 68 >> 2], g6 = E3[i4 + 64 >> 2], C3[0 | A8] = g6, C3[A8 + 1 | 0] = g6 >>> 8, C3[A8 + 2 | 0] = g6 >>> 16, C3[A8 + 3 | 0] = g6 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, MI(c4, 32), MI(o4, 32), MI(y4, 24)), r3 = a4, 0 | B4; + }, Ba: function(A8, I7, g6, C4, B4, Q4) { + A8 |= 0, I7 |= 0, B4 |= 0, Q4 |= 0; + var E4, i4, o4 = 0; + return i4 = o4 = r3, r3 = E4 = o4 - 448 & -64, o4 = -1, !(C4 |= 0) & (g6 |= 0) >>> 0 >= 48 | C4 && (j(o4 = E4 - -64 | 0, 0, 0, 24), cA(o4, I7, 32, 0), cA(o4, B4, 32, 0), ZA(o4, B4 = E4 + 32 | 0, 24), o4 = xA(A8, I7 + 32 | 0, g6 - 32 | 0, C4 - (g6 >>> 0 < 32) | 0, B4, I7, Q4)), r3 = i4, 0 | o4; + }, Ca: function() { + return 48; + }, Da: KI, Ea: JI, Fa: _I, Ga: KI, Ha: JI, Ia: _I, Ja: function() { + return 384; + }, Ka: function(A8, I7, g6, C4, B4, Q4, E4) { + return 0 | CA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, E4 |= 0); + }, La: j, Ma: function(A8, I7, g6, C4) { + return 0 | cA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0); + }, Na: ZA, Oa: FI, Pa: JI, Qa: function(A8, I7, g6, C4) { + return 0 | FA(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0); + }, Ra: KI, Sa: JI, Ta: UI, Ua: _I, Va: function(A8, I7, g6, C4, B4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, o4 |= 0; + var c4, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0; + return r3 = c4 = r3 - 32 | 0, D4 = i3[0 | (B4 |= 0)] | i3[B4 + 1 | 0] << 8 | i3[B4 + 2 | 0] << 16 | i3[B4 + 3 | 0] << 24, B4 = i3[B4 + 4 | 0] | i3[B4 + 5 | 0] << 8 | i3[B4 + 6 | 0] << 16 | i3[B4 + 7 | 0] << 24, E3[c4 + 24 >> 2] = 0, E3[c4 + 28 >> 2] = 0, E3[c4 + 16 >> 2] = D4, E3[c4 + 20 >> 2] = B4, E3[c4 + 8 >> 2] = 0, E3[c4 + 12 >> 2] = 0, E3[(B4 = c4) >> 2] = g6, E3[B4 + 4 >> 2] = C4, I7 - 65 >>> 0 <= 4294967246 ? (E3[9280] = 28, A8 = -1) : I7 - 65 >>> 0 < 4294967232 ? A8 = -1 : (r3 = B4 = (y4 = r3) - 512 & -64, !o4 | !A8 | ((a4 = 255 & I7) - 65 & 255) >>> 0 <= 191 ? (iI(), Q3()) : (C4 = c4 + 16 | 0, c4 ? (f4 = 725511199 ^ (i3[c4 + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24), e4 = -1694144372 ^ (i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24), g6 = -1377402159 ^ (i3[0 | c4] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24), I7 = 1359893119 ^ (i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24)) : (f4 = 725511199, e4 = -1694144372, g6 = -1377402159, I7 = 1359893119), C4 ? (w4 = 327033209 ^ (i3[C4 + 8 | 0] | i3[C4 + 9 | 0] << 8 | i3[C4 + 10 | 0] << 16 | i3[C4 + 11 | 0] << 24), t4 = 1541459225 ^ (i3[C4 + 12 | 0] | i3[C4 + 13 | 0] << 8 | i3[C4 + 14 | 0] << 16 | i3[C4 + 15 | 0] << 24), D4 = -79577749 ^ (i3[0 | C4] | i3[C4 + 1 | 0] << 8 | i3[C4 + 2 | 0] << 16 | i3[C4 + 3 | 0] << 24), C4 = 528734635 ^ (i3[C4 + 4 | 0] | i3[C4 + 5 | 0] << 8 | i3[C4 + 6 | 0] << 16 | i3[C4 + 7 | 0] << 24)) : (w4 = 327033209, t4 = 1541459225, D4 = -79577749, C4 = 528734635), VA(B4 - -64 | 0, 0, 293), E3[B4 + 56 >> 2] = w4, E3[B4 + 60 >> 2] = t4, E3[B4 + 48 >> 2] = D4, E3[B4 + 52 >> 2] = C4, E3[B4 + 40 >> 2] = f4, E3[B4 + 44 >> 2] = e4, E3[B4 + 32 >> 2] = g6, E3[B4 + 36 >> 2] = I7, E3[B4 + 24 >> 2] = 1595750129, E3[B4 + 28 >> 2] = -1521486534, E3[B4 + 16 >> 2] = -23791573, E3[B4 + 20 >> 2] = 1013904242, E3[B4 + 8 >> 2] = -2067093701, E3[B4 + 12 >> 2] = -1150833019, E3[B4 >> 2] = -222443256 ^ (8192 | a4), E3[B4 + 4 >> 2] = 1779033703, VA(32 + (I7 = B4 + 384 | 0) | 0, 0, 96), TA(I7, o4, 32), TA(B4 + 96 | 0, I7, 128), E3[B4 + 352 >> 2] = 128, MI(I7, 128), m3(B4, A8, a4), r3 = y4), A8 = 0), r3 = c4 + 32 | 0, 0 | A8; + }, Wa: FI, Xa: function(A8, I7, g6) { + return 0 | gA(A8 |= 0, I7 |= 0, g6 |= 0); + }, Ya: function(A8, I7, g6) { + return 0 | kI(A8 |= 0, I7 |= 0, g6 |= 0); + }, Za: function(A8, I7) { + return II(A8 |= 0, I7 |= 0), MI(A8, 4), 0; + }, _a: function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 - 208 | 0, gA(Q4, I7 |= 0, g6 |= 0), kI(Q4, C4, B4), II(Q4, A8), MI(Q4, 4), r3 = Q4 + 208 | 0, 0; + }, $a: FI, ab: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0; + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = o4 = r3 - 256 | 0, C3[o4 + 15 | 0] = 1, I7 >>> 0 <= 8160) { + if (I7 >>> 0 >= 32) for (y4 = A8 - 32 | 0, c4 = 32; a4 = c4, gA(c4 = o4 + 48 | 0, Q4, 32), D4 && kI(c4, D4 + y4 | 0, 32), kI(c4 = o4 + 48 | 0, g6, B4), kI(c4, o4 + 15 | 0, 1), II(c4, A8 + D4 | 0), C3[o4 + 15 | 0] = i3[o4 + 15 | 0] + 1, (c4 = (D4 = a4) + 32 | 0) >>> 0 <= I7 >>> 0; ) ; + (D4 = 31 & I7) && (gA(I7 = o4 + 48 | 0, Q4, 32), a4 && kI(I7, (A8 + a4 | 0) - 32 | 0, 32), kI(I7 = o4 + 48 | 0, g6, B4), kI(I7, o4 + 15 | 0, 1), II(g6 = I7, I7 = o4 + 16 | 0), TA(A8 + a4 | 0, I7, D4), MI(I7, 32)), MI(o4 + 48 | 0, 208), A8 = 0; + } else E3[9280] = 28, A8 = -1; + return r3 = o4 + 256 | 0, 0 | A8; + }, bb: _I, cb: YI, db: function() { + return 8160; + }, eb: NI, fb: function(A8, I7, g6) { + return 0 | wA(A8 |= 0, I7 |= 0, g6 |= 0); + }, gb: function(A8, I7, g6) { + return 0 | tI(A8 |= 0, I7 |= 0, g6 |= 0, 0); + }, hb: function(A8, I7) { + return WA(A8 |= 0, I7 |= 0), MI(A8, 4), 0; + }, ib: function(A8, I7, g6, C4, B4) { + var Q4; + return A8 |= 0, C4 |= 0, B4 |= 0, r3 = Q4 = r3 - 416 | 0, wA(Q4, I7 |= 0, g6 |= 0), tI(Q4, C4, B4, 0), WA(Q4, A8), MI(Q4, 4), r3 = Q4 + 416 | 0, 0; + }, jb: function(A8) { + LA(A8 |= 0, 64); + }, kb: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, Q4 |= 0; + var o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0; + if (r3 = o4 = r3 - 496 | 0, C3[o4 + 15 | 0] = 1, I7 >>> 0 <= 16320) { + if (I7 >>> 0 >= 64) for (y4 = A8 + -64 | 0, c4 = 64; a4 = c4, wA(c4 = o4 + 80 | 0, Q4, 64), D4 && tI(c4, D4 + y4 | 0, 64, 0), tI(c4 = o4 + 80 | 0, g6, B4, 0), tI(c4, o4 + 15 | 0, 1, 0), WA(c4, A8 + D4 | 0), C3[o4 + 15 | 0] = i3[o4 + 15 | 0] + 1, (c4 = (D4 = a4) - -64 | 0) >>> 0 <= I7 >>> 0; ) ; + (D4 = 63 & I7) && (wA(I7 = o4 + 80 | 0, Q4, 64), a4 && tI(I7, (A8 + a4 | 0) - 64 | 0, 64, 0), tI(I7 = o4 + 80 | 0, g6, B4, 0), tI(I7, o4 + 15 | 0, 1, 0), WA(g6 = I7, I7 = o4 + 16 | 0), TA(A8 + a4 | 0, I7, D4), MI(I7, 64)), MI(o4 + 80 | 0, 416), A8 = 0; + } else E3[9280] = 28, A8 = -1; + return r3 = o4 + 496 | 0, 0 | A8; + }, lb: JI, mb: YI, nb: function() { + return 16320; + }, ob: function() { + return 416; + }, pb: function(A8, I7, g6) { + return A8 |= 0, CA(I7 |= 0, 32, g6 |= 0, 32, 0, 0, 0), 0 | fI(A8, I7); + }, qb: function(A8, I7) { + return A8 |= 0, LA(I7 |= 0, 32), 0 | fI(A8, I7); + }, rb: function(A8, I7, g6, B4, E4) { + I7 |= 0, g6 |= 0, B4 |= 0, E4 |= 0; + var o4, c4, D4 = 0, a4 = 0, y4 = 0; + if (c4 = D4 = r3, r3 = D4 = D4 - 512 & -64, o4 = (A8 |= 0) || I7) { + if (y4 = -1, !EI(a4 = D4 + 96 | 0, B4, E4)) { + for (B4 = I7 || A8, A8 = 0, j(I7 = D4 + 128 | 0, 0, 0, 64), cA(I7, a4, 32, 0), MI(a4, 32), cA(I7, g6, 32, 0), cA(I7, E4, 32, 0), ZA(I7, D4 + 32 | 0, 64), MI(I7, 384); g6 = (I7 = D4 + 32 | 0) + A8 | 0, C3[A8 + o4 | 0] = i3[0 | g6], C3[A8 + B4 | 0] = i3[g6 + 32 | 0], C3[(g6 = 1 | A8) + o4 | 0] = i3[I7 + g6 | 0], C3[g6 + B4 | 0] = i3[I7 + (33 | A8) | 0], 32 != (0 | (A8 = A8 + 2 | 0)); ) ; + MI(I7, 64), y4 = 0; + } + return r3 = c4, 0 | y4; + } + iI(), Q3(); + }, sb: function(A8, I7, g6, B4, E4) { + I7 |= 0, g6 |= 0, B4 |= 0, E4 |= 0; + var o4, c4, D4 = 0, a4 = 0, y4 = 0; + if (c4 = D4 = r3, r3 = D4 = D4 - 512 & -64, o4 = (A8 |= 0) || I7) { + if (y4 = -1, !EI(a4 = D4 + 96 | 0, B4, E4)) { + for (B4 = I7 || A8, A8 = 0, j(I7 = D4 + 128 | 0, 0, 0, 64), cA(I7, a4, 32, 0), MI(a4, 32), cA(I7, E4, 32, 0), cA(I7, g6, 32, 0), ZA(I7, D4 + 32 | 0, 64), MI(I7, 384); g6 = (I7 = D4 + 32 | 0) + A8 | 0, C3[A8 + B4 | 0] = i3[0 | g6], C3[A8 + o4 | 0] = i3[g6 + 32 | 0], C3[(g6 = 1 | A8) + B4 | 0] = i3[I7 + g6 | 0], C3[g6 + o4 | 0] = i3[I7 + (33 | A8) | 0], 32 != (0 | (A8 = A8 + 2 | 0)); ) ; + MI(I7, 64), y4 = 0; + } + return r3 = c4, 0 | y4; + } + iI(), Q3(); + }, tb: _I, ub: _I, vb: _I, wb: _I, xb: fI, yb: EI, zb: _I, Ab: _I, Bb: _I, Cb: pI, Db: KI, Eb: HI, Fb: FI, Gb: $A, Hb: function(A8, I7, g6, C4, B4, E4) { + return A8 |= 0, I7 |= 0, B4 |= 0, E4 |= 0, !(C4 |= 0) & (g6 |= 0) >>> 0 >= 4294967280 | C4 && (iI(), Q3()), tA(A8 + 16 | 0, A8, I7, g6, C4, B4, E4), 0; + }, Ib: AI, Jb: jA, Kb: FI, Lb: function(A8, I7, g6) { + return A8 |= 0, g6 |= 0, LA(I7 |= 0, 24), $(A8, I7, g6), C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, g6 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, I7 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, C3[A8 + 44 | 0] = 0, C3[A8 + 45 | 0] = 0, C3[A8 + 46 | 0] = 0, C3[A8 + 47 | 0] = 0, C3[A8 + 48 | 0] = 0, C3[A8 + 49 | 0] = 0, C3[A8 + 50 | 0] = 0, C3[A8 + 51 | 0] = 0, C3[A8 + 36 | 0] = g6, C3[A8 + 37 | 0] = g6 >>> 8, C3[A8 + 38 | 0] = g6 >>> 16, C3[A8 + 39 | 0] = g6 >>> 24, C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, 0; + }, Mb: function(A8, I7, g6) { + return $(A8 |= 0, I7 |= 0, g6 |= 0), C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, g6 = i3[I7 + 16 | 0] | i3[I7 + 17 | 0] << 8 | i3[I7 + 18 | 0] << 16 | i3[I7 + 19 | 0] << 24, I7 = i3[I7 + 20 | 0] | i3[I7 + 21 | 0] << 8 | i3[I7 + 22 | 0] << 16 | i3[I7 + 23 | 0] << 24, C3[A8 + 44 | 0] = 0, C3[A8 + 45 | 0] = 0, C3[A8 + 46 | 0] = 0, C3[A8 + 47 | 0] = 0, C3[A8 + 48 | 0] = 0, C3[A8 + 49 | 0] = 0, C3[A8 + 50 | 0] = 0, C3[A8 + 51 | 0] = 0, C3[A8 + 36 | 0] = g6, C3[A8 + 37 | 0] = g6 >>> 8, C3[A8 + 38 | 0] = g6 >>> 16, C3[A8 + 39 | 0] = g6 >>> 24, C3[A8 + 40 | 0] = I7, C3[A8 + 41 | 0] = I7 >>> 8, C3[A8 + 42 | 0] = I7 >>> 16, C3[A8 + 43 | 0] = I7 >>> 24, 0; + }, Nb: function(A8) { + var I7, g6 = 0, B4 = 0; + r3 = I7 = r3 - 48 | 0, g6 = i3[28 + (A8 |= 0) | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[I7 + 24 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[I7 + 28 >> 2] = g6, g6 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[I7 + 16 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[I7 + 20 >> 2] = g6, g6 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[I7 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[I7 + 4 >> 2] = g6, g6 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[I7 + 8 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[I7 + 12 >> 2] = g6, g6 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[I7 + 32 >> 2] = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[I7 + 36 >> 2] = g6, yI(I7, I7, A8 + 32 | 0, A8), g6 = E3[I7 + 28 >> 2], B4 = E3[I7 + 24 >> 2], C3[A8 + 24 | 0] = B4, C3[A8 + 25 | 0] = B4 >>> 8, C3[A8 + 26 | 0] = B4 >>> 16, C3[A8 + 27 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = g6, C3[A8 + 29 | 0] = g6 >>> 8, C3[A8 + 30 | 0] = g6 >>> 16, C3[A8 + 31 | 0] = g6 >>> 24, g6 = E3[I7 + 20 >> 2], B4 = E3[I7 + 16 >> 2], C3[A8 + 16 | 0] = B4, C3[A8 + 17 | 0] = B4 >>> 8, C3[A8 + 18 | 0] = B4 >>> 16, C3[A8 + 19 | 0] = B4 >>> 24, C3[A8 + 20 | 0] = g6, C3[A8 + 21 | 0] = g6 >>> 8, C3[A8 + 22 | 0] = g6 >>> 16, C3[A8 + 23 | 0] = g6 >>> 24, g6 = E3[I7 + 12 >> 2], B4 = E3[I7 + 8 >> 2], C3[A8 + 8 | 0] = B4, C3[A8 + 9 | 0] = B4 >>> 8, C3[A8 + 10 | 0] = B4 >>> 16, C3[A8 + 11 | 0] = B4 >>> 24, C3[A8 + 12 | 0] = g6, C3[A8 + 13 | 0] = g6 >>> 8, C3[A8 + 14 | 0] = g6 >>> 16, C3[A8 + 15 | 0] = g6 >>> 24, g6 = E3[I7 + 4 >> 2], B4 = E3[I7 >> 2], C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 4 | 0] = g6, C3[A8 + 5 | 0] = g6 >>> 8, C3[A8 + 6 | 0] = g6 >>> 16, C3[A8 + 7 | 0] = g6 >>> 24, B4 = E3[I7 + 36 >> 2], g6 = E3[I7 + 32 >> 2], C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, C3[A8 + 36 | 0] = g6, C3[A8 + 37 | 0] = g6 >>> 8, C3[A8 + 38 | 0] = g6 >>> 16, C3[A8 + 39 | 0] = g6 >>> 24, C3[A8 + 40 | 0] = B4, C3[A8 + 41 | 0] = B4 >>> 8, C3[A8 + 42 | 0] = B4 >>> 16, C3[A8 + 43 | 0] = B4 >>> 24, r3 = I7 + 48 | 0; + }, Ob: function(A8, I7, g6, B4, o4, c4, D4, a4, y4, f4) { + A8 |= 0, I7 |= 0, B4 |= 0, c4 |= 0, D4 |= 0, y4 |= 0, f4 |= 0; + var e4, w4 = 0, t4 = 0, h4 = 0; + return w4 = o4 |= 0, w4 |= o4 = 0, e4 = o4 | (a4 |= 0), r3 = o4 = r3 - 384 | 0, (g6 |= 0) && (E3[g6 >> 2] = 0, E3[g6 + 4 >> 2] = 0), !c4 & w4 >>> 0 < 4294967279 ? (eI(t4 = o4 + 16 | 0, 64, h4 = A8 + 32 | 0, A8), nI(a4 = o4 + 80 | 0, t4), MI(t4, 64), rI(a4, D4, e4, y4), rI(a4, 34736, 0 - e4 & 15, 0), E3[o4 + 72 >> 2] = 0, E3[o4 + 76 >> 2] = 0, E3[(D4 = o4 - -64 | 0) >> 2] = 0, E3[D4 + 4 >> 2] = 0, E3[o4 + 56 >> 2] = 0, E3[o4 + 60 >> 2] = 0, E3[o4 + 48 >> 2] = 0, E3[o4 + 52 >> 2] = 0, E3[o4 + 40 >> 2] = 0, E3[o4 + 44 >> 2] = 0, E3[o4 + 32 >> 2] = 0, E3[o4 + 36 >> 2] = 0, E3[o4 + 16 >> 2] = 0, E3[o4 + 20 >> 2] = 0, E3[o4 + 24 >> 2] = 0, E3[o4 + 28 >> 2] = 0, C3[o4 + 16 | 0] = f4, vA(t4, t4, 64, 0, h4, 1, A8), rI(a4, t4, 64, 0), C3[0 | I7] = i3[o4 + 16 | 0], vA(I7 = I7 + 1 | 0, B4, w4, c4, h4, 2, A8), rI(a4, I7, w4, c4), rI(a4, 34736, 15 & w4, 0), E3[o4 + 8 >> 2] = e4, E3[o4 + 12 >> 2] = y4, rI(a4, B4 = o4 + 8 | 0, 8, 0), E3[o4 + 8 >> 2] = w4 - -64, E3[o4 + 12 >> 2] = c4 - ((w4 >>> 0 < 4294967232) - 1 | 0), rI(a4, B4, 8, 0), sI(a4, I7 = I7 + w4 | 0), MI(a4, 256), C3[A8 + 36 | 0] = i3[A8 + 36 | 0] ^ i3[0 | I7], C3[A8 + 37 | 0] = i3[A8 + 37 | 0] ^ i3[I7 + 1 | 0], C3[A8 + 38 | 0] = i3[A8 + 38 | 0] ^ i3[I7 + 2 | 0], C3[A8 + 39 | 0] = i3[A8 + 39 | 0] ^ i3[I7 + 3 | 0], C3[A8 + 40 | 0] = i3[A8 + 40 | 0] ^ i3[I7 + 4 | 0], C3[A8 + 41 | 0] = i3[A8 + 41 | 0] ^ i3[I7 + 5 | 0], C3[A8 + 42 | 0] = i3[A8 + 42 | 0] ^ i3[I7 + 6 | 0], C3[A8 + 43 | 0] = i3[A8 + 43 | 0] ^ i3[I7 + 7 | 0], dA(h4), (2 & f4 || SA(h4, 4)) && (I7 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[o4 + 360 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[o4 + 364 >> 2] = I7, I7 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[o4 + 352 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[o4 + 356 >> 2] = I7, I7 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[o4 + 336 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[o4 + 340 >> 2] = I7, I7 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[o4 + 344 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[o4 + 348 >> 2] = I7, I7 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[o4 + 368 >> 2] = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[o4 + 372 >> 2] = I7, yI(I7 = o4 + 336 | 0, I7, h4, A8), I7 = E3[o4 + 364 >> 2], B4 = E3[o4 + 360 >> 2], C3[A8 + 24 | 0] = B4, C3[A8 + 25 | 0] = B4 >>> 8, C3[A8 + 26 | 0] = B4 >>> 16, C3[A8 + 27 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[o4 + 356 >> 2], B4 = E3[o4 + 352 >> 2], C3[A8 + 16 | 0] = B4, C3[A8 + 17 | 0] = B4 >>> 8, C3[A8 + 18 | 0] = B4 >>> 16, C3[A8 + 19 | 0] = B4 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[o4 + 348 >> 2], B4 = E3[o4 + 344 >> 2], C3[A8 + 8 | 0] = B4, C3[A8 + 9 | 0] = B4 >>> 8, C3[A8 + 10 | 0] = B4 >>> 16, C3[A8 + 11 | 0] = B4 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[o4 + 340 >> 2], B4 = E3[o4 + 336 >> 2], C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = E3[o4 + 368 >> 2], B4 = E3[o4 + 372 >> 2], C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, C3[A8 + 36 | 0] = I7, C3[A8 + 37 | 0] = I7 >>> 8, C3[A8 + 38 | 0] = I7 >>> 16, C3[A8 + 39 | 0] = I7 >>> 24, C3[A8 + 40 | 0] = B4, C3[A8 + 41 | 0] = B4 >>> 8, C3[A8 + 42 | 0] = B4 >>> 16, C3[A8 + 43 | 0] = B4 >>> 24), g6 && (c4 = (A8 = w4 + 17 | 0) >>> 0 < 17 ? c4 + 1 | 0 : c4, E3[g6 >> 2] = A8, E3[g6 + 4 >> 2] = c4), r3 = o4 + 384 | 0) : (iI(), Q3()), 0; + }, Pb: function(A8, I7, g6, B4, o4, c4, D4, a4, y4, f4) { + A8 |= 0, I7 |= 0, B4 |= 0, o4 |= 0, a4 |= 0, f4 |= 0; + var e4, w4 = 0, t4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0; + w4 = c4 |= 0, c4 = D4 |= 0, t4 = 0 | w4, e4 = y4 |= 0, r3 = D4 = r3 - 400 | 0, (g6 |= 0) && (E3[g6 >> 2] = 0, E3[g6 + 4 >> 2] = 0), B4 && (C3[0 | B4] = 255), s4 = -1; + A: { + I: { + if (!((y4 = t4 >>> 0 < 17) & !c4)) { + if (n4 = w4 = c4 - y4 | 0, !w4 & (y4 = t4 - 17 | 0) >>> 0 >= 4294967279 | w4) break I; + eI(h4 = D4 + 32 | 0, 64, k4 = A8 + 32 | 0, A8), nI(w4 = D4 + 96 | 0, h4), MI(h4, 64), rI(w4, a4, e4, f4), rI(w4, 34736, 0 - e4 & 15, 0), E3[D4 + 88 >> 2] = 0, E3[D4 + 92 >> 2] = 0, E3[D4 + 80 >> 2] = 0, E3[D4 + 84 >> 2] = 0, E3[D4 + 72 >> 2] = 0, E3[D4 + 76 >> 2] = 0, E3[(a4 = D4 - -64 | 0) >> 2] = 0, E3[a4 + 4 >> 2] = 0, E3[D4 + 56 >> 2] = 0, E3[D4 + 60 >> 2] = 0, E3[D4 + 48 >> 2] = 0, E3[D4 + 52 >> 2] = 0, E3[D4 + 40 >> 2] = 0, E3[D4 + 44 >> 2] = 0, E3[D4 + 32 >> 2] = 0, E3[D4 + 36 >> 2] = 0, C3[D4 + 32 | 0] = i3[0 | o4], vA(h4, h4, 64, 0, k4, 1, A8), a4 = i3[D4 + 32 | 0], C3[D4 + 32 | 0] = i3[0 | o4], rI(w4, h4, 64, 0), rI(w4, o4 = o4 + 1 | 0, y4, n4), rI(w4, 34736, t4 - 1 & 15, 0), E3[D4 + 24 >> 2] = e4, E3[D4 + 28 >> 2] = f4, rI(w4, f4 = D4 + 24 | 0, 8, 0), c4 = (t4 = t4 + 47 | 0) >>> 0 < 47 ? c4 + 1 | 0 : c4, E3[D4 + 24 >> 2] = t4, E3[D4 + 28 >> 2] = c4, rI(w4, f4, 8, 0), sI(w4, D4), MI(w4, 256), NA(D4, o4 + y4 | 0, 16) ? MI(D4, 16) : (vA(I7, o4, y4, n4, k4, 2, A8), C3[A8 + 36 | 0] = i3[A8 + 36 | 0] ^ i3[0 | D4], C3[A8 + 37 | 0] = i3[A8 + 37 | 0] ^ i3[D4 + 1 | 0], C3[A8 + 38 | 0] = i3[A8 + 38 | 0] ^ i3[D4 + 2 | 0], C3[A8 + 39 | 0] = i3[A8 + 39 | 0] ^ i3[D4 + 3 | 0], C3[A8 + 40 | 0] = i3[A8 + 40 | 0] ^ i3[D4 + 4 | 0], C3[A8 + 41 | 0] = i3[A8 + 41 | 0] ^ i3[D4 + 5 | 0], C3[A8 + 42 | 0] = i3[A8 + 42 | 0] ^ i3[D4 + 6 | 0], C3[A8 + 43 | 0] = i3[A8 + 43 | 0] ^ i3[D4 + 7 | 0], dA(k4), (2 & a4 || SA(k4, 4)) && (I7 = i3[A8 + 28 | 0] | i3[A8 + 29 | 0] << 8 | i3[A8 + 30 | 0] << 16 | i3[A8 + 31 | 0] << 24, E3[D4 + 376 >> 2] = i3[A8 + 24 | 0] | i3[A8 + 25 | 0] << 8 | i3[A8 + 26 | 0] << 16 | i3[A8 + 27 | 0] << 24, E3[D4 + 380 >> 2] = I7, I7 = i3[A8 + 20 | 0] | i3[A8 + 21 | 0] << 8 | i3[A8 + 22 | 0] << 16 | i3[A8 + 23 | 0] << 24, E3[D4 + 368 >> 2] = i3[A8 + 16 | 0] | i3[A8 + 17 | 0] << 8 | i3[A8 + 18 | 0] << 16 | i3[A8 + 19 | 0] << 24, E3[D4 + 372 >> 2] = I7, I7 = i3[A8 + 4 | 0] | i3[A8 + 5 | 0] << 8 | i3[A8 + 6 | 0] << 16 | i3[A8 + 7 | 0] << 24, E3[D4 + 352 >> 2] = i3[0 | A8] | i3[A8 + 1 | 0] << 8 | i3[A8 + 2 | 0] << 16 | i3[A8 + 3 | 0] << 24, E3[D4 + 356 >> 2] = I7, I7 = i3[A8 + 12 | 0] | i3[A8 + 13 | 0] << 8 | i3[A8 + 14 | 0] << 16 | i3[A8 + 15 | 0] << 24, E3[D4 + 360 >> 2] = i3[A8 + 8 | 0] | i3[A8 + 9 | 0] << 8 | i3[A8 + 10 | 0] << 16 | i3[A8 + 11 | 0] << 24, E3[D4 + 364 >> 2] = I7, I7 = i3[A8 + 40 | 0] | i3[A8 + 41 | 0] << 8 | i3[A8 + 42 | 0] << 16 | i3[A8 + 43 | 0] << 24, E3[D4 + 384 >> 2] = i3[A8 + 36 | 0] | i3[A8 + 37 | 0] << 8 | i3[A8 + 38 | 0] << 16 | i3[A8 + 39 | 0] << 24, E3[D4 + 388 >> 2] = I7, yI(I7 = D4 + 352 | 0, I7, k4, A8), I7 = E3[D4 + 380 >> 2], o4 = E3[D4 + 376 >> 2], C3[A8 + 24 | 0] = o4, C3[A8 + 25 | 0] = o4 >>> 8, C3[A8 + 26 | 0] = o4 >>> 16, C3[A8 + 27 | 0] = o4 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, I7 = E3[D4 + 372 >> 2], o4 = E3[D4 + 368 >> 2], C3[A8 + 16 | 0] = o4, C3[A8 + 17 | 0] = o4 >>> 8, C3[A8 + 18 | 0] = o4 >>> 16, C3[A8 + 19 | 0] = o4 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[D4 + 364 >> 2], o4 = E3[D4 + 360 >> 2], C3[A8 + 8 | 0] = o4, C3[A8 + 9 | 0] = o4 >>> 8, C3[A8 + 10 | 0] = o4 >>> 16, C3[A8 + 11 | 0] = o4 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[D4 + 356 >> 2], o4 = E3[D4 + 352 >> 2], C3[0 | A8] = o4, C3[A8 + 1 | 0] = o4 >>> 8, C3[A8 + 2 | 0] = o4 >>> 16, C3[A8 + 3 | 0] = o4 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = E3[D4 + 384 >> 2], o4 = E3[D4 + 388 >> 2], C3[A8 + 32 | 0] = 1, C3[A8 + 33 | 0] = 0, C3[A8 + 34 | 0] = 0, C3[A8 + 35 | 0] = 0, C3[A8 + 36 | 0] = I7, C3[A8 + 37 | 0] = I7 >>> 8, C3[A8 + 38 | 0] = I7 >>> 16, C3[A8 + 39 | 0] = I7 >>> 24, C3[A8 + 40 | 0] = o4, C3[A8 + 41 | 0] = o4 >>> 8, C3[A8 + 42 | 0] = o4 >>> 16, C3[A8 + 43 | 0] = o4 >>> 24), g6 && (E3[g6 >> 2] = y4, E3[g6 + 4 >> 2] = n4), s4 = 0, B4 && (C3[0 | B4] = a4)); + } + r3 = D4 + 400 | 0; + break A; + } + iI(), Q3(); + } + return 0 | s4; + }, Qb: function() { + return 52; + }, Rb: function() { + return 17; + }, Sb: pI, Tb: _I, Ub: function() { + return -18; + }, Vb: YI, Wb: dI, Xb: bI, Yb: function() { + return 3; + }, Zb: UI, _b: KI, $b: function(A8, I7, g6, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0; + var E4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0; + if (F4 = 1886610805 ^ (c4 = i3[0 | (Q4 |= 0)] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24), w4 = 1936682341 ^ (D4 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24), c4 ^= 1852142177, a4 = 1819895653 ^ D4, S4 = 1852075885 ^ (D4 = i3[Q4 + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24), n4 = 1685025377 ^ (Q4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24), f4 = 2037671283 ^ D4, D4 = 1952801890 ^ Q4, k4 = g6, (0 | (o4 = (g6 + I7 | 0) - (E4 = 7 & g6) | 0)) != (0 | I7)) for (; g6 = (y4 = D4 ^ (s4 = i3[I7 + 4 | 0] | i3[I7 + 5 | 0] << 8 | i3[I7 + 6 | 0] << 16 | i3[I7 + 7 | 0] << 24)) + a4 | 0, f4 = B4 = c4 + (Q4 = f4 ^ (r4 = i3[0 | I7] | i3[I7 + 1 | 0] << 8 | i3[I7 + 2 | 0] << 16 | i3[I7 + 3 | 0] << 24)) | 0, h4 = g6 = B4 >>> 0 < Q4 >>> 0 ? g6 + 1 | 0 : g6, c4 = B4, B4 = g6, g6 = w4 + n4 | 0, g6 = (D4 = F4 + S4 | 0) >>> 0 < F4 >>> 0 ? g6 + 1 | 0 : g6, e4 = (a4 = _A(S4, n4, 13) ^ D4) + c4 | 0, B4 = (c4 = t3 ^ g6) + B4 | 0, c4 = _A(a4, c4, 17) ^ e4, n4 = _A(c4, B4 = (a4 = a4 >>> 0 > e4 >>> 0 ? B4 + 1 | 0 : B4) ^ t3, 13), w4 = t3, y4 = _A(Q4, y4, 16), Q4 = h4 ^ t3, y4 ^= f4, h4 = _A(D4, g6, 32), g6 = t3 + Q4 | 0, g6 = (f4 = B4) + (B4 = (D4 = y4 + h4 | 0) >>> 0 < h4 >>> 0 ? g6 + 1 | 0 : g6) | 0, h4 = g6 = (f4 = c4 + D4 | 0) >>> 0 < D4 >>> 0 ? g6 + 1 | 0 : g6, n4 = _A(c4 = f4 ^ n4, g6 ^= w4, 17), w4 = t3, y4 = _A(y4, Q4, 21), Q4 = B4 ^ t3, y4 ^= D4, D4 = _A(e4, a4, 32), B4 = t3 + Q4 | 0, g6 = (D4 = D4 >>> 0 > (a4 = y4 + D4 | 0) >>> 0 ? B4 + 1 | 0 : B4) + g6 | 0, S4 = (c4 = c4 + a4 | 0) ^ n4, B4 = g6 = c4 >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, n4 = g6 ^ w4, g6 = _A(y4, Q4, 16), y4 = D4 ^= t3, e4 = _A(g6 ^= a4, D4, 21), a4 = t3, h4 = (D4 = _A(f4, h4, 32)) + g6 | 0, g6 = t3 + y4 | 0, f4 = e4 ^ h4, D4 = (g6 = D4 >>> 0 > h4 >>> 0 ? g6 + 1 | 0 : g6) ^ a4, c4 = _A(c4, B4, 32), a4 = t3, F4 = h4 ^ r4, w4 = g6 ^ s4, (0 | o4) != (0 | (I7 = I7 + 8 | 0)); ) ; + switch (s4 = 0, e4 = k4 << 24, E4 - 1 | 0) { + case 6: + e4 |= i3[I7 + 6 | 0] << 16; + case 5: + e4 |= i3[I7 + 5 | 0] << 8; + case 4: + e4 |= i3[I7 + 4 | 0]; + case 3: + s4 |= (g6 = i3[I7 + 3 | 0]) << 24, e4 |= B4 = g6 >>> 8 | 0; + case 2: + s4 |= (B4 = i3[I7 + 2 | 0]) << 16, e4 |= g6 = B4 >>> 16 | 0; + case 1: + s4 |= (g6 = i3[I7 + 1 | 0]) << 8, e4 |= B4 = g6 >>> 24 | 0; + case 0: + s4 = i3[0 | I7] | s4; + } + return I7 = A8, B4 = _A(Q4 = f4 ^ s4, A8 = D4 ^ e4, 16), A8 = A8 + a4 | 0, D4 = A8 = (h4 = Q4 + c4 | 0) >>> 0 < c4 >>> 0 ? A8 + 1 | 0 : A8, r4 = _A(Q4 = B4 ^ h4, A8 ^= g6 = t3, 21), a4 = t3, g6 = w4 + n4 | 0, B4 = g6 = (c4 = F4 + S4 | 0) >>> 0 < F4 >>> 0 ? g6 + 1 | 0 : g6, y4 = Q4, Q4 = _A(c4, g6, 32), g6 = t3 + A8 | 0, A8 = a4, a4 = g6 = Q4 >>> 0 > (f4 = y4 + Q4 | 0) >>> 0 ? g6 + 1 | 0 : g6, w4 = _A(Q4 = f4 ^ r4, A8 ^= g6, 16), y4 = t3, g6 = (c4 = k4 = _A(S4, n4, 13) ^ c4) + h4 | 0, B4 = (r4 = t3 ^ B4) + D4 | 0, h4 = Q4, Q4 = _A(g6, B4 = g6 >>> 0 < c4 >>> 0 ? B4 + 1 | 0 : B4, 32), A8 = t3 + A8 | 0, w4 = _A(c4 = w4 ^ (h4 = h4 + Q4 | 0), Q4 = (D4 = Q4 >>> 0 > h4 >>> 0 ? A8 + 1 | 0 : A8) ^ y4, 21), y4 = t3, k4 = _A(k4, r4, 17) ^ g6, g6 = (r4 = t3 ^ B4) + a4 | 0, A8 = g6 = (B4 = f4 = (A8 = k4) + f4 | 0) >>> 0 < A8 >>> 0 ? g6 + 1 | 0 : g6, a4 = c4, c4 = _A(B4, g6, 32), g6 = t3 + Q4 | 0, y4 = g6 = (c4 = c4 >>> 0 > (a4 = a4 + c4 | 0) >>> 0 ? g6 + 1 | 0 : g6) ^ y4, w4 = _A(n4 = a4 ^ w4, g6, 16), f4 = t3, k4 = _A(k4, r4, 13) ^ B4, A8 = (r4 = A8 ^ t3) + D4 | 0, B4 = A8 = (g6 = k4) >>> 0 > (Q4 = g6 + h4 | 0) >>> 0 ? A8 + 1 | 0 : A8, A8 = _A(Q4, A8, 32), g6 = y4 + t3 | 0, y4 = g6 = (D4 = (A8 = n4 + (255 ^ A8) | 0) >>> 0 < n4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, h4 = A8, w4 = _A(n4 = w4 ^ A8, g6, 21), f4 = t3, k4 = _A(k4, r4, 17) ^ Q4, g6 = (r4 = B4 ^ t3) + (c4 ^ e4) | 0, B4 = g6 = (A8 = a4 ^ s4) >>> 0 > (Q4 = k4 + A8 | 0) >>> 0 ? g6 + 1 | 0 : g6, A8 = _A(Q4, g6, 32), g6 = y4 + t3 | 0, y4 = g6 = (c4 = (A8 = A8 + n4 | 0) >>> 0 < n4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, a4 = A8, e4 = _A(w4 ^= A8, g6, 16), f4 = t3, k4 = _A(k4, r4, 13) ^ Q4, A8 = D4 + (r4 = t3 ^ B4) | 0, A8 = _A(Q4 = h4 + k4 | 0, g6 = A8 = Q4 >>> 0 < h4 >>> 0 ? A8 + 1 | 0 : A8, 32), B4 = y4 + t3 | 0, y4 = B4 = (D4 = (A8 = A8 + w4 | 0) >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4) ^ f4, h4 = A8, e4 = _A(w4 = e4 ^ A8, B4, 21), f4 = t3, A8 = _A(k4, r4, 17), g6 = c4 + (k4 = g6 ^ t3) | 0, B4 = g6 = (Q4 = a4 + (r4 = A8 ^ Q4) | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, A8 = _A(Q4, g6, 32), g6 = y4 + t3 | 0, a4 = A8 = A8 + w4 | 0, c4 = g6 = A8 >>> 0 < w4 >>> 0 ? g6 + 1 | 0 : g6, e4 = _A(y4 = e4 ^ A8, g6 ^= f4, 16), f4 = t3, A8 = _A(r4, k4, 13), B4 = D4 + (k4 = B4 ^ t3) | 0, A8 = _A(Q4 = h4 + (r4 = A8 ^ Q4) | 0, B4 = Q4 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, 32), g6 = g6 + t3 | 0, y4 = g6 = (D4 = (A8 = A8 + y4 | 0) >>> 0 < y4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, h4 = A8, e4 = _A(w4 = e4 ^ A8, g6, 21), f4 = t3, A8 = _A(r4, k4, 17), g6 = c4 + (k4 = B4 ^ t3) | 0, B4 = g6 = (Q4 = a4 + (r4 = A8 ^ Q4) | 0) >>> 0 < a4 >>> 0 ? g6 + 1 | 0 : g6, g6 = _A(Q4, g6, 32), A8 = y4 + t3 | 0, y4 = A8 = (c4 = (g6 = g6 + w4 | 0) >>> 0 < w4 >>> 0 ? A8 + 1 | 0 : A8) ^ f4, a4 = g6, e4 = _A(w4 = e4 ^ g6, A8, 16), f4 = t3, A8 = _A(r4, k4, 13), g6 = D4 + (k4 = B4 ^ t3) | 0, B4 = g6 = (Q4 = h4 + (r4 = A8 ^ Q4) | 0) >>> 0 < h4 >>> 0 ? g6 + 1 | 0 : g6, A8 = _A(Q4, g6, 32), g6 = y4 + t3 | 0, D4 = A8 = A8 + w4 | 0, e4 = _A(e4 ^ A8, (g6 = A8 >>> 0 < w4 >>> 0 ? g6 + 1 | 0 : g6) ^ f4, 21), f4 = t3, Q4 = _A(r4, k4, 17) ^ Q4, h4 = _A(Q4, A8 = B4 ^ t3, 13), A8 = A8 + c4 | 0, B4 = A8 = t3 ^ ((Q4 = Q4 + a4 | 0) >>> 0 < a4 >>> 0 ? A8 + 1 : A8), Q4 = _A(c4 = Q4 ^ h4, A8, 17) ^ e4, A8 = t3 ^ f4, B4 = g6 + B4 | 0, g6 = _A(g6 = c4 + D4 | 0, B4 = g6 >>> 0 < D4 >>> 0 ? B4 + 1 | 0 : B4, 32) ^ Q4 ^ g6, C3[0 | I7] = g6, C3[I7 + 1 | 0] = g6 >>> 8, C3[I7 + 2 | 0] = g6 >>> 16, C3[I7 + 3 | 0] = g6 >>> 24, A8 ^= B4 ^ t3, C3[I7 + 4 | 0] = A8, C3[I7 + 5 | 0] = A8 >>> 8, C3[I7 + 6 | 0] = A8 >>> 16, C3[I7 + 7 | 0] = A8 >>> 24, 0; + }, ac: SI, bc: NI, cc: JI, dc: _I, ec: _I, fc: JI, gc: function() { + return -65; + }, hc: function(A8, I7, g6) { + A8 |= 0; + var B4, Q4, E4, o4, c4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0; + return r3 = E4 = r3 - 160 | 0, FA(I7 |= 0, g6 |= 0, 32, 0), C3[0 | I7] = 248 & i3[0 | I7], C3[I7 + 31 | 0] = 63 & i3[I7 + 31 | 0] | 64, Z(E4, I7), mA(A8, E4), D4 = i3[(Q4 = g6) + 8 | 0] | i3[Q4 + 9 | 0] << 8 | i3[Q4 + 10 | 0] << 16 | i3[Q4 + 11 | 0] << 24, c4 = i3[Q4 + 12 | 0] | i3[Q4 + 13 | 0] << 8 | i3[Q4 + 14 | 0] << 16 | i3[Q4 + 15 | 0] << 24, a4 = i3[Q4 + 16 | 0] | i3[Q4 + 17 | 0] << 8 | i3[Q4 + 18 | 0] << 16 | i3[Q4 + 19 | 0] << 24, y4 = i3[Q4 + 20 | 0] | i3[Q4 + 21 | 0] << 8 | i3[Q4 + 22 | 0] << 16 | i3[Q4 + 23 | 0] << 24, f4 = i3[0 | Q4] | i3[Q4 + 1 | 0] << 8 | i3[Q4 + 2 | 0] << 16 | i3[Q4 + 3 | 0] << 24, g6 = i3[Q4 + 4 | 0] | i3[Q4 + 5 | 0] << 8 | i3[Q4 + 6 | 0] << 16 | i3[Q4 + 7 | 0] << 24, o4 = i3[Q4 + 28 | 0] | i3[Q4 + 29 | 0] << 8 | i3[Q4 + 30 | 0] << 16 | i3[Q4 + 31 | 0] << 24, B4 = I7, I7 = i3[Q4 + 24 | 0] | i3[Q4 + 25 | 0] << 8 | i3[Q4 + 26 | 0] << 16 | i3[Q4 + 27 | 0] << 24, C3[B4 + 24 | 0] = I7, C3[B4 + 25 | 0] = I7 >>> 8, C3[B4 + 26 | 0] = I7 >>> 16, C3[B4 + 27 | 0] = I7 >>> 24, C3[B4 + 28 | 0] = o4, C3[B4 + 29 | 0] = o4 >>> 8, C3[B4 + 30 | 0] = o4 >>> 16, C3[B4 + 31 | 0] = o4 >>> 24, C3[B4 + 16 | 0] = a4, C3[B4 + 17 | 0] = a4 >>> 8, C3[B4 + 18 | 0] = a4 >>> 16, C3[B4 + 19 | 0] = a4 >>> 24, C3[B4 + 20 | 0] = y4, C3[B4 + 21 | 0] = y4 >>> 8, C3[B4 + 22 | 0] = y4 >>> 16, C3[B4 + 23 | 0] = y4 >>> 24, C3[B4 + 8 | 0] = D4, C3[B4 + 9 | 0] = D4 >>> 8, C3[B4 + 10 | 0] = D4 >>> 16, C3[B4 + 11 | 0] = D4 >>> 24, C3[B4 + 12 | 0] = c4, C3[B4 + 13 | 0] = c4 >>> 8, C3[B4 + 14 | 0] = c4 >>> 16, C3[B4 + 15 | 0] = c4 >>> 24, C3[0 | B4] = f4, C3[B4 + 1 | 0] = f4 >>> 8, C3[B4 + 2 | 0] = f4 >>> 16, C3[B4 + 3 | 0] = f4 >>> 24, C3[B4 + 4 | 0] = g6, C3[B4 + 5 | 0] = g6 >>> 8, C3[B4 + 6 | 0] = g6 >>> 16, C3[B4 + 7 | 0] = g6 >>> 24, a4 = i3[(c4 = A8) + 8 | 0] | i3[c4 + 9 | 0] << 8 | i3[c4 + 10 | 0] << 16 | i3[c4 + 11 | 0] << 24, y4 = i3[c4 + 12 | 0] | i3[c4 + 13 | 0] << 8 | i3[c4 + 14 | 0] << 16 | i3[c4 + 15 | 0] << 24, f4 = i3[c4 + 16 | 0] | i3[c4 + 17 | 0] << 8 | i3[c4 + 18 | 0] << 16 | i3[c4 + 19 | 0] << 24, g6 = i3[c4 + 20 | 0] | i3[c4 + 21 | 0] << 8 | i3[c4 + 22 | 0] << 16 | i3[c4 + 23 | 0] << 24, I7 = i3[0 | c4] | i3[c4 + 1 | 0] << 8 | i3[c4 + 2 | 0] << 16 | i3[c4 + 3 | 0] << 24, A8 = i3[c4 + 4 | 0] | i3[c4 + 5 | 0] << 8 | i3[c4 + 6 | 0] << 16 | i3[c4 + 7 | 0] << 24, D4 = i3[c4 + 28 | 0] | i3[c4 + 29 | 0] << 8 | i3[c4 + 30 | 0] << 16 | i3[c4 + 31 | 0] << 24, c4 = i3[c4 + 24 | 0] | i3[c4 + 25 | 0] << 8 | i3[c4 + 26 | 0] << 16 | i3[c4 + 27 | 0] << 24, C3[B4 + 56 | 0] = c4, C3[B4 + 57 | 0] = c4 >>> 8, C3[B4 + 58 | 0] = c4 >>> 16, C3[B4 + 59 | 0] = c4 >>> 24, C3[B4 + 60 | 0] = D4, C3[B4 + 61 | 0] = D4 >>> 8, C3[B4 + 62 | 0] = D4 >>> 16, C3[B4 + 63 | 0] = D4 >>> 24, C3[B4 + 48 | 0] = f4, C3[B4 + 49 | 0] = f4 >>> 8, C3[B4 + 50 | 0] = f4 >>> 16, C3[B4 + 51 | 0] = f4 >>> 24, C3[B4 + 52 | 0] = g6, C3[B4 + 53 | 0] = g6 >>> 8, C3[B4 + 54 | 0] = g6 >>> 16, C3[B4 + 55 | 0] = g6 >>> 24, C3[B4 + 40 | 0] = a4, C3[B4 + 41 | 0] = a4 >>> 8, C3[B4 + 42 | 0] = a4 >>> 16, C3[B4 + 43 | 0] = a4 >>> 24, C3[B4 + 44 | 0] = y4, C3[B4 + 45 | 0] = y4 >>> 8, C3[B4 + 46 | 0] = y4 >>> 16, C3[B4 + 47 | 0] = y4 >>> 24, C3[B4 + 32 | 0] = I7, C3[B4 + 33 | 0] = I7 >>> 8, C3[B4 + 34 | 0] = I7 >>> 16, C3[B4 + 35 | 0] = I7 >>> 24, C3[B4 + 36 | 0] = A8, C3[B4 + 37 | 0] = A8 >>> 8, C3[B4 + 38 | 0] = A8 >>> 16, C3[B4 + 39 | 0] = A8 >>> 24, r3 = E4 + 160 | 0, 0; + }, ic: function(A8, I7) { + A8 |= 0, I7 |= 0; + var g6, B4, Q4, o4, c4, D4 = 0, a4 = 0, y4 = 0; + return r3 = a4 = r3 - 192 | 0, LA(a4, 32), FA(I7, a4, 32, 0), C3[0 | I7] = 248 & i3[0 | I7], C3[I7 + 31 | 0] = 63 & i3[I7 + 31 | 0] | 64, Z(y4 = a4 + 32 | 0, I7), mA(A8, y4), g6 = a4, y4 = E3[a4 + 28 >> 2], a4 = E3[a4 + 24 >> 2], C3[I7 + 24 | 0] = a4, C3[I7 + 25 | 0] = a4 >>> 8, C3[I7 + 26 | 0] = a4 >>> 16, C3[I7 + 27 | 0] = a4 >>> 24, C3[I7 + 28 | 0] = y4, C3[I7 + 29 | 0] = y4 >>> 8, C3[I7 + 30 | 0] = y4 >>> 16, C3[I7 + 31 | 0] = y4 >>> 24, y4 = E3[g6 + 20 >> 2], a4 = E3[g6 + 16 >> 2], C3[I7 + 16 | 0] = a4, C3[I7 + 17 | 0] = a4 >>> 8, C3[I7 + 18 | 0] = a4 >>> 16, C3[I7 + 19 | 0] = a4 >>> 24, C3[I7 + 20 | 0] = y4, C3[I7 + 21 | 0] = y4 >>> 8, C3[I7 + 22 | 0] = y4 >>> 16, C3[I7 + 23 | 0] = y4 >>> 24, y4 = E3[g6 + 12 >> 2], a4 = E3[g6 + 8 >> 2], C3[I7 + 8 | 0] = a4, C3[I7 + 9 | 0] = a4 >>> 8, C3[I7 + 10 | 0] = a4 >>> 16, C3[I7 + 11 | 0] = a4 >>> 24, C3[I7 + 12 | 0] = y4, C3[I7 + 13 | 0] = y4 >>> 8, C3[I7 + 14 | 0] = y4 >>> 16, C3[I7 + 15 | 0] = y4 >>> 24, y4 = E3[g6 + 4 >> 2], a4 = E3[g6 >> 2], C3[0 | I7] = a4, C3[I7 + 1 | 0] = a4 >>> 8, C3[I7 + 2 | 0] = a4 >>> 16, C3[I7 + 3 | 0] = a4 >>> 24, C3[I7 + 4 | 0] = y4, C3[I7 + 5 | 0] = y4 >>> 8, C3[I7 + 6 | 0] = y4 >>> 16, C3[I7 + 7 | 0] = y4 >>> 24, B4 = i3[(D4 = A8) + 8 | 0] | i3[D4 + 9 | 0] << 8 | i3[D4 + 10 | 0] << 16 | i3[D4 + 11 | 0] << 24, Q4 = i3[D4 + 12 | 0] | i3[D4 + 13 | 0] << 8 | i3[D4 + 14 | 0] << 16 | i3[D4 + 15 | 0] << 24, o4 = i3[D4 + 16 | 0] | i3[D4 + 17 | 0] << 8 | i3[D4 + 18 | 0] << 16 | i3[D4 + 19 | 0] << 24, y4 = i3[D4 + 20 | 0] | i3[D4 + 21 | 0] << 8 | i3[D4 + 22 | 0] << 16 | i3[D4 + 23 | 0] << 24, a4 = i3[0 | D4] | i3[D4 + 1 | 0] << 8 | i3[D4 + 2 | 0] << 16 | i3[D4 + 3 | 0] << 24, A8 = i3[D4 + 4 | 0] | i3[D4 + 5 | 0] << 8 | i3[D4 + 6 | 0] << 16 | i3[D4 + 7 | 0] << 24, c4 = i3[D4 + 28 | 0] | i3[D4 + 29 | 0] << 8 | i3[D4 + 30 | 0] << 16 | i3[D4 + 31 | 0] << 24, D4 = i3[D4 + 24 | 0] | i3[D4 + 25 | 0] << 8 | i3[D4 + 26 | 0] << 16 | i3[D4 + 27 | 0] << 24, C3[I7 + 56 | 0] = D4, C3[I7 + 57 | 0] = D4 >>> 8, C3[I7 + 58 | 0] = D4 >>> 16, C3[I7 + 59 | 0] = D4 >>> 24, C3[I7 + 60 | 0] = c4, C3[I7 + 61 | 0] = c4 >>> 8, C3[I7 + 62 | 0] = c4 >>> 16, C3[I7 + 63 | 0] = c4 >>> 24, C3[I7 + 48 | 0] = o4, C3[I7 + 49 | 0] = o4 >>> 8, C3[I7 + 50 | 0] = o4 >>> 16, C3[I7 + 51 | 0] = o4 >>> 24, C3[I7 + 52 | 0] = y4, C3[I7 + 53 | 0] = y4 >>> 8, C3[I7 + 54 | 0] = y4 >>> 16, C3[I7 + 55 | 0] = y4 >>> 24, C3[I7 + 40 | 0] = B4, C3[I7 + 41 | 0] = B4 >>> 8, C3[I7 + 42 | 0] = B4 >>> 16, C3[I7 + 43 | 0] = B4 >>> 24, C3[I7 + 44 | 0] = Q4, C3[I7 + 45 | 0] = Q4 >>> 8, C3[I7 + 46 | 0] = Q4 >>> 16, C3[I7 + 47 | 0] = Q4 >>> 24, C3[I7 + 32 | 0] = a4, C3[I7 + 33 | 0] = a4 >>> 8, C3[I7 + 34 | 0] = a4 >>> 16, C3[I7 + 35 | 0] = a4 >>> 24, C3[I7 + 36 | 0] = A8, C3[I7 + 37 | 0] = A8 >>> 8, C3[I7 + 38 | 0] = A8 >>> 16, C3[I7 + 39 | 0] = A8 >>> 24, MI(g6, 32), r3 = g6 + 192 | 0, 0; + }, jc: function(A8, I7, g6, C4, B4, Q4) { + I7 |= 0, B4 |= 0, Q4 |= 0; + var i4, o4 = 0; + return r3 = i4 = r3 - 16 | 0, k3(A8 |= 0, i4 + 8 | 0, lA(A8 - -64 | 0, g6 |= 0, C4 |= 0), C4, B4, Q4, 0), 64 != E3[i4 + 8 >> 2] | E3[i4 + 12 >> 2] ? (I7 && (E3[I7 >> 2] = 0, E3[I7 + 4 >> 2] = 0), VA(A8, 0, C4 - -64 | 0), o4 = -1) : I7 && (E3[I7 >> 2] = C4 - -64, E3[I7 + 4 >> 2] = B4 - ((C4 >>> 0 < 4294967232) - 1 | 0)), r3 = i4 + 16 | 0, 0 | o4; + }, kc: function(A8, I7, g6, C4, B4, Q4) { + A8 |= 0, I7 |= 0, g6 |= 0; + var i4 = 0; + A: { + I: { + if (i4 = C4 |= 0, !(!(B4 |= 0) & C4 >>> 0 < 64 || (C4 = B4 - 1 | 0, !(C4 = (B4 = i4 + -64 | 0) >>> 0 < 4294967232 ? C4 + 1 | 0 : C4) & B4 >>> 0 > 4294967231 | C4))) { + if (!F3(g6, i4 = g6 - -64 | 0, B4, C4, Q4 |= 0, 0)) break I; + A8 && VA(A8, 0, B4); + } + if (g6 = -1, !I7) break A; + E3[I7 >> 2] = 0, E3[I7 + 4 >> 2] = 0; + break A; + } + I7 && (E3[I7 >> 2] = B4, E3[I7 + 4 >> 2] = C4), g6 = 0, A8 && lA(A8, i4, B4); + } + return 0 | g6; + }, lc: function(A8, I7, g6, C4, B4, Q4) { + return k3(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, Q4 |= 0, 0), 0; + }, mc: function(A8, I7, g6, C4, B4) { + return 0 | F3(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0, B4 |= 0, 0); + }, nc: function(A8) { + return MA(A8 |= 0), 0; + }, oc: function(A8, I7, g6, C4) { + return 0 | W(A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0); + }, pc: function(A8, I7, g6, C4) { + var B4; + return I7 |= 0, g6 |= 0, C4 |= 0, r3 = B4 = r3 + -64 | 0, v3(A8 |= 0, B4), A8 = k3(I7, g6, B4, 64, 0, C4, 1), r3 = B4 - -64 | 0, 0 | A8; + }, qc: function(A8, I7, g6) { + var C4; + return I7 |= 0, g6 |= 0, r3 = C4 = r3 + -64 | 0, v3(A8 |= 0, C4), A8 = F3(I7, C4, 64, 0, g6, 1), r3 = C4 - -64 | 0, 0 | A8; + }, rc: function(A8, I7) { + A8 |= 0; + var g6, B4 = 0, Q4 = 0, i4 = 0, o4 = 0, D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, h4 = 0, k4 = 0, n4 = 0, s4 = 0, F4 = 0, S4 = 0, N4 = 0, K4 = 0, p4 = 0, H4 = 0, G4 = 0, J4 = 0, Y4 = 0, U4 = 0, d4 = 0, b4 = 0, P4 = 0, v4 = 0, R4 = 0, L4 = 0, x4 = 0, u4 = 0, m4 = 0, l3 = 0, z2 = 0, j2 = 0, T2 = 0, V2 = 0, Z2 = 0, W2 = 0, $2 = 0, AA2 = 0, IA2 = 0, gA2 = 0, CA2 = 0, BA2 = 0, QA2 = 0, EA2 = 0, oA2 = 0, cA2 = 0, aA2 = 0, yA2 = 0, fA2 = 0, wA2 = 0, rA2 = 0, tA2 = 0, hA2 = 0, kA2 = 0, nA2 = 0, sA2 = 0, FA2 = 0, MA2 = 0, NA2 = 0, _A2 = 0, pA2 = 0, HA2 = 0, GA2 = 0, JA2 = 0, YA2 = 0, UA2 = 0, dA2 = 0, bA2 = 0, vA2 = 0, RA2 = 0, LA2 = 0, xA2 = 0, uA2 = 0, mA2 = 0, qA2 = 0, lA2 = 0; + if (r3 = g6 = r3 - 256 | 0, bA2 = -1, !KA(I7 |= 0) && !q3(B4 = g6 + 96 | 0, I7)) { + for (r3 = i4 = r3 - 2048 | 0, DA(o4 = i4 + 640 | 0, B4), B4 = E3[(I7 = B4) + 36 >> 2], E3[i4 + 352 >> 2] = E3[I7 + 32 >> 2], E3[i4 + 356 >> 2] = B4, B4 = E3[I7 + 28 >> 2], E3[i4 + 344 >> 2] = E3[I7 + 24 >> 2], E3[i4 + 348 >> 2] = B4, B4 = E3[I7 + 20 >> 2], E3[i4 + 336 >> 2] = E3[I7 + 16 >> 2], E3[i4 + 340 >> 2] = B4, B4 = E3[I7 + 12 >> 2], E3[i4 + 328 >> 2] = E3[I7 + 8 >> 2], E3[i4 + 332 >> 2] = B4, B4 = E3[I7 + 4 >> 2], E3[i4 + 320 >> 2] = E3[I7 >> 2], E3[i4 + 324 >> 2] = B4, B4 = E3[I7 + 52 >> 2], E3[i4 + 368 >> 2] = E3[I7 + 48 >> 2], E3[i4 + 372 >> 2] = B4, B4 = E3[I7 + 60 >> 2], E3[i4 + 376 >> 2] = E3[I7 + 56 >> 2], E3[i4 + 380 >> 2] = B4, Q4 = E3[4 + (B4 = I7 - -64 | 0) >> 2], E3[i4 + 384 >> 2] = E3[B4 >> 2], E3[i4 + 388 >> 2] = Q4, B4 = E3[I7 + 76 >> 2], E3[i4 + 392 >> 2] = E3[I7 + 72 >> 2], E3[i4 + 396 >> 2] = B4, B4 = E3[I7 + 44 >> 2], E3[i4 + 360 >> 2] = E3[I7 + 40 >> 2], E3[i4 + 364 >> 2] = B4, B4 = E3[I7 + 92 >> 2], E3[i4 + 408 >> 2] = E3[I7 + 88 >> 2], E3[i4 + 412 >> 2] = B4, B4 = E3[I7 + 100 >> 2], E3[i4 + 416 >> 2] = E3[I7 + 96 >> 2], E3[i4 + 420 >> 2] = B4, B4 = E3[I7 + 108 >> 2], E3[i4 + 424 >> 2] = E3[I7 + 104 >> 2], E3[i4 + 428 >> 2] = B4, B4 = E3[I7 + 116 >> 2], E3[i4 + 432 >> 2] = E3[I7 + 112 >> 2], E3[i4 + 436 >> 2] = B4, B4 = E3[I7 + 84 >> 2], E3[i4 + 400 >> 2] = E3[I7 + 80 >> 2], E3[i4 + 404 >> 2] = B4, _3(I7 = i4 + 480 | 0, B4 = i4 + 320 | 0), M3(Q4 = i4 + 160 | 0, I7, a4 = i4 + 600 | 0), M3(i4 + 200 | 0, f4 = i4 + 520 | 0, e4 = i4 + 560 | 0), M3(i4 + 240 | 0, e4, a4), M3(i4 + 280 | 0, I7, f4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4 = i4 + 360 | 0, f4, e4), M3(S4 = i4 + 400 | 0, e4, a4), M3(k4 = i4 + 440 | 0, I7, f4), DA(o4 = i4 + 800 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 960 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1120 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1280 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1440 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(o4 = i4 + 1600 | 0, B4), X(I7, Q4, o4), M3(B4, I7, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, I7, f4), DA(i4 + 1760 | 0, B4), E3[i4 + 32 >> 2] = 0, E3[i4 + 36 >> 2] = 0, E3[i4 + 24 >> 2] = 0, E3[i4 + 28 >> 2] = 0, E3[i4 + 16 >> 2] = 0, E3[i4 + 20 >> 2] = 0, E3[i4 + 8 >> 2] = 0, E3[i4 + 12 >> 2] = 0, E3[i4 + 52 >> 2] = 0, E3[i4 + 56 >> 2] = 0, E3[i4 + 60 >> 2] = 0, E3[i4 + 64 >> 2] = 0, E3[i4 + 68 >> 2] = 0, E3[i4 + 72 >> 2] = 0, E3[i4 + 76 >> 2] = 0, E3[i4 + 80 >> 2] = 1, E3[i4 >> 2] = 0, E3[i4 + 4 >> 2] = 0, E3[i4 + 44 >> 2] = 0, E3[i4 + 48 >> 2] = 0, E3[i4 + 40 >> 2] = 1, VA(i4 + 84 | 0, 0, 76), w4 = i4 + 120 | 0, s4 = i4 + 2008 | 0, n4 = i4 + 1968 | 0, B4 = i4 + 80 | 0, Q4 = i4 + 40 | 0, o4 = 252; D4 = E3[i4 + 36 >> 2], E3[(I7 = i4 + 1960 | 0) >> 2] = E3[i4 + 32 >> 2], E3[I7 + 4 >> 2] = D4, D4 = E3[i4 + 28 >> 2], E3[(I7 = i4 + 1952 | 0) >> 2] = E3[i4 + 24 >> 2], E3[I7 + 4 >> 2] = D4, D4 = E3[i4 + 20 >> 2], E3[(I7 = i4 + 1944 | 0) >> 2] = E3[i4 + 16 >> 2], E3[I7 + 4 >> 2] = D4, D4 = E3[i4 + 12 >> 2], E3[(I7 = i4 + 1936 | 0) >> 2] = E3[i4 + 8 >> 2], E3[I7 + 4 >> 2] = D4, I7 = E3[i4 + 4 >> 2], E3[i4 + 1928 >> 2] = E3[i4 >> 2], E3[i4 + 1932 >> 2] = I7, D4 = E3[(I7 = Q4) + 36 >> 2], E3[n4 + 32 >> 2] = E3[I7 + 32 >> 2], E3[n4 + 36 >> 2] = D4, D4 = E3[I7 + 28 >> 2], E3[n4 + 24 >> 2] = E3[I7 + 24 >> 2], E3[n4 + 28 >> 2] = D4, D4 = E3[I7 + 20 >> 2], E3[n4 + 16 >> 2] = E3[I7 + 16 >> 2], E3[n4 + 20 >> 2] = D4, D4 = E3[I7 + 12 >> 2], E3[n4 + 8 >> 2] = E3[I7 + 8 >> 2], E3[n4 + 12 >> 2] = D4, D4 = E3[I7 + 4 >> 2], E3[n4 >> 2] = E3[I7 >> 2], E3[n4 + 4 >> 2] = D4, D4 = E3[(I7 = B4) + 36 >> 2], E3[s4 + 32 >> 2] = E3[I7 + 32 >> 2], E3[s4 + 36 >> 2] = D4, D4 = E3[I7 + 28 >> 2], E3[s4 + 24 >> 2] = E3[I7 + 24 >> 2], E3[s4 + 28 >> 2] = D4, D4 = E3[I7 + 20 >> 2], E3[s4 + 16 >> 2] = E3[I7 + 16 >> 2], E3[s4 + 20 >> 2] = D4, D4 = E3[I7 + 12 >> 2], E3[s4 + 8 >> 2] = E3[I7 + 8 >> 2], E3[s4 + 12 >> 2] = D4, D4 = E3[I7 + 4 >> 2], E3[s4 >> 2] = E3[I7 >> 2], E3[s4 + 4 >> 2] = D4, o4 = C3[(I7 = o4) + 33408 | 0], _3(D4 = i4 + 480 | 0, i4 + 1928 | 0), (0 | o4) > 0 ? (M3(K4 = i4 + 320 | 0, D4, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, D4, f4), X(D4, K4, (i4 + 640 | 0) + c3((254 & o4) >>> 1 | 0, 160) | 0)) : (0 | o4) >= 0 || (M3(K4 = i4 + 320 | 0, D4 = i4 + 480 | 0, a4), M3(F4, f4, e4), M3(S4, e4, a4), M3(k4, D4, f4), O(D4, K4, (i4 + 640 | 0) + c3((0 - o4 & 254) >>> 1 | 0, 160) | 0)), M3(i4, o4 = i4 + 480 | 0, a4), M3(Q4, f4, e4), M3(B4, e4, a4), M3(w4, o4, f4), o4 = I7 - 1 | 0, I7; ) ; + eA(I7 = i4 + 640 | 0, i4), I7 = SA(I7, 32), r3 = i4 + 2048 | 0, I7 && (bA2 = 0, u4 = E3[g6 + 172 >> 2], E3[g6 + 36 >> 2] = 0 - u4, F4 = E3[g6 + 168 >> 2], E3[g6 + 32 >> 2] = 0 - F4, m4 = E3[g6 + 164 >> 2], E3[g6 + 28 >> 2] = 0 - m4, f4 = E3[g6 + 160 >> 2], E3[g6 + 24 >> 2] = 0 - f4, l3 = E3[g6 + 156 >> 2], E3[g6 + 20 >> 2] = 0 - l3, e4 = E3[g6 + 152 >> 2], E3[g6 + 16 >> 2] = 0 - e4, z2 = E3[g6 + 148 >> 2], E3[g6 + 12 >> 2] = 0 - z2, s4 = E3[g6 + 144 >> 2], E3[g6 + 8 >> 2] = 0 - s4, j2 = E3[g6 + 140 >> 2], E3[g6 + 4 >> 2] = 0 - j2, i4 = E3[g6 + 136 >> 2], E3[g6 >> 2] = 1 - i4, iA(g6, g6), I7 = PA(S4 = E3[g6 + 4 >> 2], R4 = S4 >> 31, J4 = l3 << 1, oA2 = J4 >> 31), B4 = t3, Q4 = PA(a4 = E3[g6 >> 2], Y4 = a4 >> 31, f4, U4 = f4 >> 31), B4 = t3 + B4 | 0, B4 = (I7 = Q4 + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (o4 = PA(D4 = E3[g6 + 8 >> 2], T2 = D4 >> 31, e4, d4 = e4 >> 31)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(L4 = E3[g6 + 12 >> 2], W2 = L4 >> 31, IA2 = z2 << 1, cA2 = IA2 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(V2 = E3[g6 + 16 >> 2], gA2 = V2 >> 31, s4, b4 = s4 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, HA2 = o4 = E3[g6 + 20 >> 2], n4 = PA(o4, aA2 = o4 >> 31, CA2 = j2 << 1, yA2 = CA2 >> 31), Q4 = t3 + I7 | 0, Q4 = (B4 = n4 + B4 | 0) >>> 0 < n4 >>> 0 ? Q4 + 1 | 0 : Q4, GA2 = p4 = E3[g6 + 24 >> 2], I7 = (i4 = PA(p4, NA2 = p4 >> 31, n4 = i4 + 1 | 0, P4 = n4 >> 31)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, fA2 = E3[g6 + 28 >> 2], Q4 = (i4 = PA(K4 = c3(fA2, 19), $2 = K4 >> 31, BA2 = u4 << 1, wA2 = BA2 >> 31)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, vA2 = E3[g6 + 32 >> 2], Q4 = PA(w4 = c3(vA2, 19), Z2 = w4 >> 31, F4, v4 = F4 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, RA2 = E3[g6 + 36 >> 2], Q4 = PA(k4 = c3(RA2, 19), x4 = k4 >> 31, QA2 = m4 << 1, rA2 = QA2 >> 31), I7 = t3 + I7 | 0, h4 = B4 = Q4 + B4 | 0, i4 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(e4, d4, S4, R4), B4 = t3, y4 = PA(a4, Y4, l3, tA2 = l3 >> 31), Q4 = t3 + B4 | 0, Q4 = (I7 = y4 + I7 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, y4 = PA(D4, T2, z2, hA2 = z2 >> 31), B4 = t3 + Q4 | 0, B4 = (I7 = y4 + I7 | 0) >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (y4 = PA(s4, b4, L4, W2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(V2, gA2, j2, kA2 = j2 >> 31), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(n4, P4, o4, aA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, y4 = PA(p4 = c3(p4, 19), EA2 = p4 >> 31, u4, nA2 = u4 >> 31), Q4 = t3 + I7 | 0, Q4 = (B4 = y4 + B4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (y4 = PA(F4, v4, K4, $2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (y4 = PA(w4, Z2, m4, sA2 = m4 >> 31)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(f4, U4, k4, x4), I7 = t3 + I7 | 0, JA2 = B4 = B4 + Q4 | 0, AA2 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(S4, R4, IA2, cA2), Q4 = t3, B4 = (y4 = PA(a4, Y4, e4, d4)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, y4 = PA(s4, b4, D4, T2), Q4 = t3 + I7 | 0, Q4 = (B4 = y4 + B4 | 0) >>> 0 < y4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (y4 = PA(L4, W2, CA2, yA2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < y4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (y4 = PA(n4, P4, V2, gA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < y4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(y4 = c3(o4, 19), FA2 = y4 >> 31, BA2, wA2), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(F4, v4, p4, EA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, o4 = PA(K4, $2, QA2, rA2), Q4 = t3 + I7 | 0, Q4 = (B4 = o4 + B4 | 0) >>> 0 < o4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (o4 = PA(f4, U4, w4, Z2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (o4 = PA(k4, x4, J4, oA2)) + I7 | 0, I7 = t3 + B4 | 0, LA2 = Q4, xA2 = I7 = Q4 >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, uA2 = Q4 = Q4 + 33554432 | 0, mA2 = I7 = Q4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, Q4 = (67108863 & I7) << 6 | Q4 >>> 26, I7 = (I7 >> 26) + AA2 | 0, JA2 = o4 = Q4 + JA2 | 0, I7 = Q4 >>> 0 > o4 >>> 0 ? I7 + 1 | 0 : I7, qA2 = o4 = o4 + 16777216 | 0, I7 = (B4 = (Q4 = o4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7) >> 25) + i4 | 0, I7 = (Q4 = (o4 = (33554431 & Q4) << 7 | o4 >>> 25) + h4 | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, G4 = B4 = Q4 + 33554432 | 0, o4 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[g6 + 72 >> 2] = Q4 - (-67108864 & B4), I7 = PA(S4, R4, CA2, yA2), B4 = t3, i4 = PA(a4, Y4, s4, b4), Q4 = t3 + B4 | 0, Q4 = (I7 = i4 + I7 | 0) >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, B4 = (i4 = PA(n4, P4, D4, T2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(i4 = c3(L4, 19), MA2 = i4 >> 31, BA2, wA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (h4 = PA(AA2 = c3(V2, 19), _A2 = AA2 >> 31, F4, v4)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, h4 = PA(QA2, rA2, y4, FA2), I7 = t3 + B4 | 0, I7 = (Q4 = h4 + Q4 | 0) >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (h4 = PA(f4, U4, p4, EA2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < h4 >>> 0 ? Q4 + 1 | 0 : Q4, h4 = PA(K4, $2, J4, oA2), I7 = t3 + Q4 | 0, I7 = (B4 = h4 + B4 | 0) >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(e4, d4, w4, Z2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (h4 = PA(k4, x4, IA2, cA2)) + B4 | 0, B4 = t3 + I7 | 0, H4 = Q4, YA2 = Q4 >>> 0 < h4 >>> 0 ? B4 + 1 | 0 : B4, I7 = PA(n4, P4, S4, R4), B4 = t3, Q4 = (h4 = PA(a4, Y4, j2, kA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7, h4 = B4 = c3(D4, 19), B4 = (N4 = PA(B4, pA2 = B4 >> 31, u4, nA2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < N4 >>> 0 ? Q4 + 1 | 0 : Q4, N4 = PA(i4, MA2, F4, v4), I7 = t3 + Q4 | 0, I7 = (B4 = N4 + B4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(AA2, _A2, m4, sA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (N4 = PA(f4, U4, y4, FA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < N4 >>> 0 ? B4 + 1 | 0 : B4, N4 = PA(p4, EA2, l3, tA2), I7 = t3 + B4 | 0, I7 = (Q4 = N4 + Q4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (N4 = PA(e4, d4, K4, $2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < N4 >>> 0 ? Q4 + 1 | 0 : Q4, N4 = PA(w4, Z2, z2, hA2), I7 = t3 + Q4 | 0, I7 = (B4 = N4 + B4 | 0) >>> 0 < N4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(s4, b4, k4, x4), I7 = t3 + I7 | 0, UA2 = B4 = Q4 + B4 | 0, N4 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, I7 = PA(I7 = c3(S4, 19), I7 >> 31, BA2, wA2), B4 = t3, Q4 = PA(a4, Y4, n4, P4), B4 = t3 + B4 | 0, B4 = (I7 = Q4 + I7 | 0) >>> 0 < Q4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (h4 = PA(h4, pA2, F4, v4)) + I7 | 0, I7 = t3 + B4 | 0, B4 = (i4 = PA(i4, MA2, QA2, rA2)) + Q4 | 0, Q4 = t3 + (Q4 >>> 0 < h4 >>> 0 ? I7 + 1 | 0 : I7) | 0, Q4 = B4 >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, i4 = PA(f4, U4, AA2, _A2), I7 = t3 + Q4 | 0, I7 = (B4 = i4 + B4 | 0) >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(J4, oA2, y4, FA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (i4 = PA(e4, d4, p4, EA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, i4 = PA(K4, $2, IA2, cA2), I7 = t3 + B4 | 0, I7 = (Q4 = i4 + Q4 | 0) >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (i4 = PA(s4, b4, w4, Z2)) + Q4 | 0, Q4 = t3 + I7 | 0, Q4 = B4 >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, i4 = PA(k4, x4, CA2, yA2), I7 = t3 + Q4 | 0, h4 = B4 = i4 + B4 | 0, MA2 = I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, pA2 = B4 = B4 + 33554432 | 0, lA2 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, Q4 = I7 >> 26, I7 = (67108863 & I7) << 6 | B4 >>> 26, B4 = Q4 + N4 | 0, N4 = i4 = I7 + UA2 | 0, I7 = B4 = I7 >>> 0 > i4 >>> 0 ? B4 + 1 | 0 : B4, UA2 = i4 = i4 + 16777216 | 0, i4 = (33554431 & (I7 = i4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7)) << 7 | i4 >>> 25, I7 = (I7 >> 25) + YA2 | 0, I7 = (B4 = i4 + H4 | 0) >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = B4, YA2 = B4 = B4 + 33554432 | 0, i4 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[g6 + 56 >> 2] = Q4 - (-67108864 & B4), I7 = PA(f4, U4, S4, R4), Q4 = t3, B4 = (H4 = PA(a4, Y4, m4, sA2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(D4, T2, l3, tA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(e4, d4, L4, W2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, H4 = PA(V2, gA2, z2, hA2), Q4 = t3 + I7 | 0, Q4 = (B4 = H4 + B4 | 0) >>> 0 < H4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (H4 = PA(s4, b4, HA2, aA2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < H4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (H4 = PA(j2, kA2, GA2, NA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < H4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(fA2, dA2 = fA2 >> 31, n4, P4), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(w4, Z2, u4, nA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, H4 = (Q4 = B4) + (B4 = PA(F4, v4, k4, x4)) | 0, Q4 = t3 + I7 | 0, B4 = (I7 = o4 >> 26) + (B4 = B4 >>> 0 > H4 >>> 0 ? Q4 + 1 | 0 : Q4) | 0, G4 = Q4 = (o4 = (67108863 & o4) << 6 | G4 >>> 26) + H4 | 0, I7 = B4 = Q4 >>> 0 < o4 >>> 0 ? B4 + 1 | 0 : B4, H4 = Q4 = Q4 + 16777216 | 0, o4 = I7 = Q4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[g6 + 76 >> 2] = G4 - (-33554432 & Q4), I7 = PA(s4, b4, S4, R4), B4 = t3, G4 = PA(a4, Y4, z2, hA2), Q4 = t3 + B4 | 0, Q4 = (I7 = G4 + I7 | 0) >>> 0 < G4 >>> 0 ? Q4 + 1 | 0 : Q4, G4 = PA(D4, T2, j2, kA2), B4 = t3 + Q4 | 0, B4 = (I7 = G4 + I7 | 0) >>> 0 < G4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (G4 = PA(n4, P4, L4, W2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < G4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(AA2, _A2, u4, nA2), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(F4, v4, y4, FA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, B4 = (p4 = PA(p4, EA2, m4, sA2)) + B4 | 0, Q4 = t3 + I7 | 0, I7 = (K4 = PA(f4, U4, K4, $2)) + B4 | 0, B4 = t3 + (B4 >>> 0 < p4 >>> 0 ? Q4 + 1 | 0 : Q4) | 0, Q4 = (w4 = PA(w4, Z2, l3, tA2)) + I7 | 0, I7 = t3 + (I7 >>> 0 < K4 >>> 0 ? B4 + 1 | 0 : B4) | 0, I7 = Q4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(e4, d4, k4, x4), I7 = t3 + I7 | 0, G4 = B4 = B4 + Q4 | 0, I7 = (I7 = B4 >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7) + (B4 = i4 >> 26) | 0, w4 = i4 = G4 + (Q4 = (67108863 & i4) << 6 | YA2 >>> 26) | 0, I7 = Q4 >>> 0 > i4 >>> 0 ? I7 + 1 | 0 : I7, K4 = B4 = i4 + 16777216 | 0, i4 = Q4 = B4 >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[g6 + 60 >> 2] = w4 - (-33554432 & B4), I7 = PA(S4, R4, QA2, rA2), Q4 = t3, B4 = (w4 = PA(a4, Y4, F4, v4)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(f4, U4, D4, T2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, w4 = PA(L4, W2, J4, oA2), Q4 = t3 + I7 | 0, Q4 = (B4 = w4 + B4 | 0) >>> 0 < w4 >>> 0 ? Q4 + 1 | 0 : Q4, I7 = (w4 = PA(e4, d4, V2, gA2)) + B4 | 0, B4 = t3 + Q4 | 0, B4 = I7 >>> 0 < w4 >>> 0 ? B4 + 1 | 0 : B4, Q4 = (w4 = PA(IA2, cA2, HA2, aA2)) + I7 | 0, I7 = t3 + B4 | 0, I7 = Q4 >>> 0 < w4 >>> 0 ? I7 + 1 | 0 : I7, B4 = Q4, Q4 = PA(s4, b4, GA2, NA2), I7 = t3 + I7 | 0, I7 = (B4 = B4 + Q4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = B4, B4 = PA(CA2, yA2, fA2, dA2), I7 = t3 + I7 | 0, I7 = B4 >>> 0 > (Q4 = Q4 + B4 | 0) >>> 0 ? I7 + 1 | 0 : I7, w4 = B4 = vA2, B4 = (J4 = PA(B4, p4 = B4 >> 31, n4, P4)) + Q4 | 0, Q4 = t3 + I7 | 0, I7 = (k4 = PA(k4, x4, BA2, wA2)) + B4 | 0, B4 = t3 + (B4 >>> 0 < J4 >>> 0 ? Q4 + 1 | 0 : Q4) | 0, Q4 = I7 >>> 0 < k4 >>> 0 ? B4 + 1 | 0 : B4, B4 = I7, I7 = (I7 = o4 >> 25) + Q4 | 0, I7 = (B4 = B4 + (o4 = (33554431 & o4) << 7 | H4 >>> 25) | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = B4, k4 = B4 = B4 + 33554432 | 0, o4 = I7 = B4 >>> 0 < 33554432 ? I7 + 1 | 0 : I7, E3[g6 + 80 >> 2] = Q4 - (-67108864 & B4), B4 = i4 >> 25, Q4 = (i4 = (33554431 & i4) << 7 | K4 >>> 25) + (LA2 - (I7 = -67108864 & uA2) | 0) | 0, I7 = B4 + (xA2 - ((I7 >>> 0 > LA2 >>> 0) + mA2 | 0) | 0) | 0, I7 = Q4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, I7 = ((67108863 & (I7 = (B4 = Q4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | B4 >>> 26) + (J4 = JA2 - (-33554432 & qA2) | 0) | 0, E3[g6 + 68 >> 2] = I7, E3[g6 + 64 >> 2] = Q4 - (-67108864 & B4), I7 = PA(F4, v4, S4, R4), Q4 = t3, B4 = (i4 = PA(a4, Y4, u4, nA2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (i4 = PA(D4, T2, m4, sA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, I7 = (i4 = PA(f4, U4, L4, W2)) + Q4 | 0, Q4 = t3 + B4 | 0, Q4 = I7 >>> 0 < i4 >>> 0 ? Q4 + 1 | 0 : Q4, B4 = (i4 = PA(V2, gA2, l3, tA2)) + I7 | 0, I7 = t3 + Q4 | 0, I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(e4, d4, HA2, aA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = PA(z2, hA2, GA2, NA2), I7 = t3 + I7 | 0, I7 = (B4 = Q4 + B4 | 0) >>> 0 < Q4 >>> 0 ? I7 + 1 | 0 : I7, Q4 = (i4 = PA(s4, b4, fA2, dA2)) + B4 | 0, B4 = t3 + I7 | 0, B4 = Q4 >>> 0 < i4 >>> 0 ? B4 + 1 | 0 : B4, i4 = (I7 = PA(w4, p4, j2, kA2)) + Q4 | 0, Q4 = t3 + B4 | 0, Q4 = I7 >>> 0 > i4 >>> 0 ? Q4 + 1 | 0 : Q4, B4 = i4, i4 = PA(I7 = RA2, I7 >> 31, n4, P4), I7 = t3 + Q4 | 0, Q4 = B4 = B4 + i4 | 0, I7 = (I7 = B4 >>> 0 < i4 >>> 0 ? I7 + 1 | 0 : I7) + (B4 = o4 >> 26) | 0, I7 = (Q4 = Q4 + (o4 = (67108863 & o4) << 6 | k4 >>> 26) | 0) >>> 0 < o4 >>> 0 ? I7 + 1 | 0 : I7, I7 = (B4 = Q4 + 16777216 | 0) >>> 0 < 16777216 ? I7 + 1 | 0 : I7, E3[g6 + 84 >> 2] = Q4 - (-33554432 & B4), o4 = N4 - (-33554432 & UA2) | 0, i4 = h4 - (Q4 = -67108864 & pA2) | 0, a4 = MA2 - ((Q4 >>> 0 > h4 >>> 0) + lA2 | 0) | 0, I7 = PA((33554431 & (Q4 = I7)) << 7 | B4 >>> 25, I7 >>= 25, 19, 0), B4 = t3 + a4 | 0, I7 = I7 >>> 0 > (Q4 = I7 + i4 | 0) >>> 0 ? B4 + 1 | 0 : B4, I7 = ((67108863 & (I7 = (B4 = Q4 + 33554432 | 0) >>> 0 < 33554432 ? I7 + 1 | 0 : I7)) << 6 | B4 >>> 26) + o4 | 0, E3[g6 + 52 >> 2] = I7, E3[g6 + 48 >> 2] = Q4 - (-67108864 & B4), eA(A8, g6 + 48 | 0)); + } + return r3 = g6 + 256 | 0, 0 | bA2; + }, sc: function(A8, I7) { + A8 |= 0; + var g6, B4 = 0; + return r3 = g6 = r3 + -64 | 0, FA(g6, I7 |= 0, 32, 0), C3[0 | g6] = 248 & i3[0 | g6], C3[g6 + 31 | 0] = 63 & i3[g6 + 31 | 0] | 64, I7 = E3[g6 + 20 >> 2], B4 = E3[g6 + 16 >> 2], C3[A8 + 16 | 0] = B4, C3[A8 + 17 | 0] = B4 >>> 8, C3[A8 + 18 | 0] = B4 >>> 16, C3[A8 + 19 | 0] = B4 >>> 24, C3[A8 + 20 | 0] = I7, C3[A8 + 21 | 0] = I7 >>> 8, C3[A8 + 22 | 0] = I7 >>> 16, C3[A8 + 23 | 0] = I7 >>> 24, I7 = E3[g6 + 12 >> 2], B4 = E3[g6 + 8 >> 2], C3[A8 + 8 | 0] = B4, C3[A8 + 9 | 0] = B4 >>> 8, C3[A8 + 10 | 0] = B4 >>> 16, C3[A8 + 11 | 0] = B4 >>> 24, C3[A8 + 12 | 0] = I7, C3[A8 + 13 | 0] = I7 >>> 8, C3[A8 + 14 | 0] = I7 >>> 16, C3[A8 + 15 | 0] = I7 >>> 24, I7 = E3[g6 + 4 >> 2], B4 = E3[g6 >> 2], C3[0 | A8] = B4, C3[A8 + 1 | 0] = B4 >>> 8, C3[A8 + 2 | 0] = B4 >>> 16, C3[A8 + 3 | 0] = B4 >>> 24, C3[A8 + 4 | 0] = I7, C3[A8 + 5 | 0] = I7 >>> 8, C3[A8 + 6 | 0] = I7 >>> 16, C3[A8 + 7 | 0] = I7 >>> 24, I7 = E3[g6 + 28 >> 2], B4 = E3[g6 + 24 >> 2], C3[A8 + 24 | 0] = B4, C3[A8 + 25 | 0] = B4 >>> 8, C3[A8 + 26 | 0] = B4 >>> 16, C3[A8 + 27 | 0] = B4 >>> 24, C3[A8 + 28 | 0] = I7, C3[A8 + 29 | 0] = I7 >>> 8, C3[A8 + 30 | 0] = I7 >>> 16, C3[A8 + 31 | 0] = I7 >>> 24, MI(g6, 64), r3 = g6 - -64 | 0, 0; + }, tc: function() { + var A8, I7; + return r3 = A8 = r3 - 16 | 0, C3[A8 + 15 | 0] = 0, I7 = 0 | y3(36304, A8 + 15 | 0, 0), r3 = A8 + 16 | 0, 0 | I7; + }, uc: QI, vc: function(A8) { + var I7, g6 = 0, B4 = 0; + if (r3 = I7 = r3 - 16 | 0, (A8 |= 0) >>> 0 >= 2) { + for (g6 = (0 - A8 >>> 0) % (A8 >>> 0) | 0; C3[I7 + 15 | 0] = 0, g6 >>> 0 > (B4 = 0 | y3(36304, I7 + 15 | 0, 0)) >>> 0; ) ; + g6 = (B4 >>> 0) % (A8 >>> 0) | 0; + } + return r3 = I7 + 16 | 0, 0 | g6; + }, wc: LA, xc: function(A8, I7, g6) { + eI(A8 |= 0, I7 |= 0, 33888, g6 |= 0); + }, yc: _I, zc: function() { + var A8 = 0, I7 = 0; + return (A8 = E3[9414]) && (A8 = E3[A8 + 20 >> 2]) && (I7 = 0 | vI[0 | A8]()), 0 | I7; + }, Ac: function(A8, I7, g6) { + A8 |= 0, I7 |= 0; + var B4, E4 = 0, i4 = 0, o4 = 0; + if (r3 = B4 = r3 - 16 | 0, g6 |= 0) f3(1228, 1088, 198, 1024), Q3(); + else { + if (I7 | g6) for (; C3[B4 + 15 | 0] = 0, i4 = A8 + E4 | 0, o4 = 0 | y3(36304, B4 + 15 | 0, 0), C3[0 | i4] = o4, (0 | I7) != (0 | (E4 = E4 + 1 | 0)); ) ; + r3 = B4 + 16 | 0; + } + }, Bc: function(A8, I7, g6, B4) { + A8 |= 0, g6 |= 0; + var E4 = 0, o4 = 0, c4 = 0; + if (!((B4 |= 0) >>> 0 > 2147483646 | B4 << 1 >>> 0 >= (I7 |= 0) >>> 0)) { + if (I7 = 0, B4) { + for (; E4 = (I7 << 1) + A8 | 0, o4 = 15 & (c4 = i3[I7 + g6 | 0]), C3[E4 + 1 | 0] = 22272 + ((o4 << 8) + (o4 + 65526 & 55552) | 0) >>> 8, o4 = E4, E4 = c4 >>> 4 | 0, C3[0 | o4] = 87 + ((E4 + 65526 >>> 8 & 217) + E4 | 0), (0 | B4) != (0 | (I7 = I7 + 1 | 0)); ) ; + I7 = B4 << 1; + } else I7 = 0; + return C3[I7 + A8 | 0] = 0, 0 | A8; + } + iI(), Q3(); + }, Cc: function(A8, I7, g6, B4, Q4, o4, c4) { + A8 |= 0, I7 |= 0, g6 |= 0, Q4 |= 0, o4 |= 0, c4 |= 0; + var D4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0; + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + i: { + o: { + if (B4 |= 0) { + if (Q4) break o; + for (a4 = 1, Q4 = 0; ; ) { + if (!(255 & ((r4 = (65526 + (y4 = (223 & (e4 = i3[g6 + D4 | 0])) - 55 & 255) ^ y4 + 65520) >>> 8 | 0) | (t4 = 65526 + (e4 ^= 48) >>> 8 | 0)))) break E; + if (I7 >>> 0 <= w4 >>> 0) break i; + if (y4 = y4 & r4 | e4 & t4, 255 & f4 ? (C3[A8 + w4 | 0] = Q4 | y4, w4 = w4 + 1 | 0) : Q4 = y4 << 4, f4 = ~f4, (0 | (D4 = D4 + 1 | 0)) == (0 | B4)) break; + } + D4 = B4; + break E; + } + if (A8 = 0, !c4) break A; + break g; + } + for (; ; ) { + o: { + c: { + D: { + a: { + y: { + if (!(255 & ((e4 = (65526 + (a4 = (223 & (y4 = i3[g6 + D4 | 0])) - 55 & 255) ^ a4 + 65520) >>> 8 | 0) | (t4 = 65526 + (r4 = 48 ^ y4) >>> 8 | 0)))) { + if (255 & f4) break Q; + if (a4 = 0, !hA(Q4, y4)) break C; + if ((D4 = f4 = D4 + 1 | 0) >>> 0 < B4 >>> 0) break y; + break C; + } + if (I7 >>> 0 <= w4 >>> 0) break i; + if (a4 = a4 & e4 | r4 & t4, !(255 & f4)) break a; + C3[A8 + w4 | 0] = a4 | h4, w4 = w4 + 1 | 0; + break o; + } + for (; ; ) { + if (!(255 & ((r4 = (65526 + (e4 = (223 & (y4 = i3[g6 + D4 | 0])) - 55 & 255) ^ e4 + 65520) >>> 8 | 0) | (h4 = 65526 + (t4 = 48 ^ y4) >>> 8 | 0)))) { + if (!hA(Q4, y4)) break C; + if ((D4 = D4 + 1 | 0) >>> 0 < B4 >>> 0) continue; + break D; + } + break; + } + if (I7 >>> 0 <= w4 >>> 0) break c; + a4 = e4 & r4 | t4 & h4; + } + h4 = a4 << 4, f4 = 0; + break o; + } + D4 = B4 >>> 0 > f4 >>> 0 ? B4 : f4; + break C; + } + f4 = 0; + break i; + } + if (f4 = ~f4, a4 = 1, !((D4 = D4 + 1 | 0) >>> 0 < B4 >>> 0)) break; + } + break E; + } + E3[9280] = 68, a4 = 0; + } + if (!(255 & f4)) break B; + } + E3[9280] = 28, a4 = -1, D4 = D4 - 1 | 0, w4 = 0; + break C; + } + w4 = a4 ? w4 : 0, a4 = a4 - 1 | 0; + } + if (!c4) { + if ((0 | B4) != (0 | D4)) break I; + A8 = a4; + break A; + } + } + E3[c4 >> 2] = g6 + D4, A8 = a4; + break A; + } + E3[9280] = 28, A8 = -1; + } + return o4 && (E3[o4 >> 2] = w4), 0 | A8; + }, Dc: function(A8, I7) { + A8 |= 0; + var g6 = 0; + return 1 != (-7 & (I7 |= 0)) && (iI(), Q3()), 1 + ((3 & (g6 = (g6 = A8) + c3(A8 = (A8 >>> 0) / 3 | 0, -3) | 0) ? 2 & I7 ? g6 + 1 | 0 : 4 : 0) + (A8 << 2) | 0) | 0; + }, Ec: function(A8, I7, g6, B4, E4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0; + var o4 = 0, D4 = 0, a4 = 0, y4 = 0, e4 = 0, w4 = 0, r4 = 0; + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + if (1 == (-7 & (E4 |= 0)) && (a4 = (o4 = (B4 >>> 0) / 3 | 0) << 2, (o4 = c3(o4, -3) + B4 | 0) && (a4 = 2 & E4 ? 2 + ((o4 >>> 1 | 0) + a4 | 0) | 0 : a4 + 4 | 0), !(I7 >>> 0 <= a4 >>> 0))) { + if (!(E4 >>> 0 >= 4)) { + if (!B4) { + E4 = 0; + break C; + } + o4 = 0, E4 = 0; + break E; + } + if (!B4) { + E4 = 0; + break C; + } + for (o4 = 0, E4 = 0; ; ) { + for (e4 = i3[g6 + y4 | 0] | e4 << 8, o4 |= 8; w4 = 65510 + (D4 = e4 >>> (o4 = o4 - 6 | 0) & 63) >>> 8 | 0, r4 = D4 + 65484 >>> 8 | 0, C3[A8 + E4 | 0] = ~(1 + (16321 ^ D4)) >>> 8 & 45 | D4 + 252 & D4 + 65474 >>> 8 & ~r4 | ~(D4 + 32705) >>> 8 & 95 | w4 & D4 + 65 | r4 & D4 + 71 & ~w4, E4 = E4 + 1 | 0, o4 >>> 0 > 5; ) ; + if ((0 | (y4 = y4 + 1 | 0)) == (0 | B4)) break; + } + if (!o4) break B; + y4 = 45, D4 = 32705, B4 = 95; + break Q; + } + iI(), Q3(); + } + for (; ; ) { + for (e4 = i3[g6 + y4 | 0] | e4 << 8, o4 |= 8; w4 = 65510 + (D4 = e4 >>> (o4 = o4 - 6 | 0) & 63) >>> 8 | 0, r4 = D4 + 65484 >>> 8 | 0, C3[A8 + E4 | 0] = ~(1 + (16321 ^ D4)) >>> 8 & 43 | D4 + 252 & D4 + 65474 >>> 8 & ~r4 | ~(D4 + 16321) >>> 8 & 47 | w4 & D4 + 65 | r4 & D4 + 71 & ~w4, E4 = E4 + 1 | 0, o4 >>> 0 > 5; ) ; + if ((0 | (y4 = y4 + 1 | 0)) == (0 | B4)) break; + } + if (!o4) break B; + y4 = 43, D4 = 16321, B4 = 47; + } + D4 = ~((g6 = e4 << 6 - o4 & 63) + D4) >>> 8 & B4 | (o4 = g6 + 65510 >>> 8 | 0) & g6 + 65, B4 = g6 + 65484 >>> 8 | 0, C3[A8 + E4 | 0] = ~(1 + (16321 ^ g6)) >>> 8 & y4 | D4 | g6 + 252 & g6 + 65474 >>> 8 & ~B4 | B4 & g6 + 71 & ~o4, E4 = E4 + 1 | 0; + } + if (E4 >>> 0 > a4 >>> 0) break g; + } + if (E4 >>> 0 < a4 >>> 0) break I; + a4 = E4; + break A; + } + f3(1036, 1114, 231, 1300), Q3(); + } + VA(A8 + E4 | 0, 61, a4 - E4 | 0); + } + return VA(A8 + a4 | 0, 0, (I7 >>> 0 > (g6 = a4 + 1 | 0) >>> 0 ? I7 : g6) - a4 | 0), 0 | A8; + }, Fc: function(A8, I7, g6, B4, o4, c4, D4, a4) { + A8 |= 0, I7 |= 0, g6 |= 0, B4 |= 0, o4 |= 0, c4 |= 0, D4 |= 0; + var y4 = 0, f4 = 0, e4 = 0, w4 = 0, r4 = 0, t4 = 0, h4 = 0, k4 = 0; + if (1 == (-7 & (a4 |= 0))) { + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + if (B4) { + i: { + o: { + if (a4 >>> 0 <= 3) { + for (; ; ) { + w4 = f4; + c: { + D: { + a: { + y: { + for (; ; ) { + if (y4 = (y4 = (e4 = C3[g6 + w4 | 0]) - 65 | 0) & (~(90 - e4) & ~y4) >>> 8 & 255 | e4 + 4 & (~(e4 + 65488) & ~(57 - e4)) >>> 8 & 255 | e4 + 185 & (~(e4 + 65439) & ~(122 - e4)) >>> 8 & 255 | ~(1 + (16336 ^ e4)) >>> 8 & 63 | ~(1 + (16340 ^ e4)) >>> 8 & 62, 255 != (0 | (y4 |= (y4 - 1 & 1 + (65470 ^ e4)) >>> 8 & 255))) break y; + if (y4 = 0, !o4) break i; + if (!hA(o4, e4)) break; + if ((w4 = w4 + 1 | 0) >>> 0 >= B4 >>> 0) break a; + } + f4 = w4; + break i; + } + if (h4 = y4 + (h4 << 6) | 0, r4 >>> 0 > 1) break D; + r4 = r4 + 6 | 0; + break c; + } + f4 = (A8 = f4 + 1 | 0) >>> 0 < B4 >>> 0 ? B4 : A8; + break i; + } + if (r4 = r4 - 2 | 0, I7 >>> 0 <= t4 >>> 0) break o; + C3[A8 + t4 | 0] = h4 >>> r4, t4 = t4 + 1 | 0; + } + if (y4 = 0, !((f4 = w4 + 1 | 0) >>> 0 < B4 >>> 0)) break; + } + break i; + } + for (; ; ) { + c: { + if (y4 = (y4 = (e4 = C3[g6 + w4 | 0]) - 65 | 0) & (~(90 - e4) & ~y4) >>> 8 & 255 | e4 + 4 & (~(e4 + 65488) & ~(57 - e4)) >>> 8 & 255 | e4 + 185 & (~(e4 + 65439) & ~(122 - e4)) >>> 8 & 255 | ~(1 + (16288 ^ e4)) >>> 8 & 63 | ~(1 + (16338 ^ e4)) >>> 8 & 62, 255 == (0 | (y4 |= (y4 - 1 & 1 + (65470 ^ e4)) >>> 8 & 255))) { + if (y4 = 0, !o4) break i; + if (hA(o4, e4)) { + if ((w4 = w4 + 1 | 0) >>> 0 >= B4 >>> 0) break c; + continue; + } + f4 = w4; + break i; + } + if (h4 = y4 + (h4 << 6) | 0, r4 >>> 0 < 2) r4 = r4 + 6 | 0; + else { + if (r4 = r4 - 2 | 0, I7 >>> 0 <= t4 >>> 0) break o; + C3[A8 + t4 | 0] = h4 >>> r4, t4 = t4 + 1 | 0; + } + if (y4 = 0, (f4 = w4 + 1 | 0) >>> 0 >= B4 >>> 0) break i; + w4 = f4; + continue; + } + break; + } + f4 = (A8 = f4 + 1 | 0) >>> 0 < B4 >>> 0 ? B4 : A8; + break i; + } + f4 = w4, E3[9280] = 68, y4 = 1; + } + if (r4 >>> 0 > 4) break E; + A8 = f4; + } else A8 = 0; + if (I7 = -1, y4) { + f4 = A8; + break A; + } + if (~(-1 << r4) & h4) { + f4 = A8; + break A; + } + if (2 & a4) { + a4 = A8; + break B; + } + if (r4 >>> 0 < 2) { + a4 = A8; + break B; + } + if (f4 = A8 >>> 0 > B4 >>> 0 ? A8 : B4, w4 = r4 >>> 1 | 0, !o4) break Q; + for (a4 = A8; ; ) { + if ((0 | a4) == (0 | f4)) { + y4 = 68; + break C; + } + if (61 != (0 | (A8 = C3[g6 + a4 | 0]))) { + if (!hA(o4, A8)) { + y4 = 28, f4 = a4; + break C; + } + } else w4 = w4 - 1 | 0; + if (a4 = a4 + 1 | 0, !w4) break; + } + break B; + } + I7 = -1; + break A; + } + if (y4 = 68, A8 >>> 0 >= B4 >>> 0) break C; + if (61 != i3[A8 + g6 | 0]) { + f4 = A8, y4 = 28; + break C; + } + if (a4 = A8 + w4 | 0, 1 != (0 | w4)) { + if ((0 | (r4 = A8 + 1 | 0)) == (0 | f4)) break C; + if (61 != i3[g6 + r4 | 0]) { + f4 = r4, y4 = 28; + break C; + } + if (2 != (0 | w4)) { + if ((0 | (A8 = A8 + 2 | 0)) == (0 | f4)) break C; + if (y4 = 28, f4 = A8, 61 != i3[A8 + g6 | 0]) break C; + } + } + } + if (I7 = 0, o4) break g; + break I; + } + E3[9280] = y4; + break A; + } + if (!(B4 >>> 0 <= a4 >>> 0)) { + for (; ; ) { + if (!hA(o4, C3[g6 + a4 | 0])) break I; + if ((0 | (a4 = a4 + 1 | 0)) == (0 | B4)) break; + } + a4 = B4; + } + } + f4 = a4, k4 = t4; + } + return D4 ? E3[D4 >> 2] = g6 + f4 : (0 | B4) != (0 | f4) && (E3[9280] = 28, I7 = -1), c4 && (E3[c4 >> 2] = k4), 0 | I7; + } + iI(), Q3(); + }, Gc: function() { + var A8 = 0; + return E3[9412] ? A8 = 1 : (QI(), LA(37632, 16), E3[9412] = 1, A8 = 0), 0 | A8; + }, Hc: function(A8, I7, g6, B4, o4) { + A8 |= 0, I7 |= 0, g6 |= 0, o4 |= 0; + var c4, D4 = 0, a4 = 0, y4 = 0; + r3 = c4 = r3 - 16 | 0; + A: { + if (B4 |= 0) { + if ((D4 = B4 - 1 | 0) & B4 ? (a4 = ~g6, D4 = D4 - ((g6 >>> 0) % (B4 >>> 0) | 0) | 0) : D4 &= a4 = ~g6, D4 >>> 0 >= a4 >>> 0) break A; + if ((g6 = g6 + D4 | 0) >>> 0 >= o4 >>> 0) I7 = -1; + else for (A8 && (E3[A8 >> 2] = g6 + 1), A8 = I7 + g6 | 0, I7 = 0, C3[c4 + 15 | 0] = 0, g6 = 0; a4 = o4 = A8 - g6 | 0, y4 = i3[0 | o4] & i3[c4 + 15 | 0], o4 = (g6 ^ D4) - 1 >>> 24 | 0, C3[0 | a4] = y4 | 128 & o4, C3[c4 + 15 | 0] = o4 | i3[c4 + 15 | 0], (0 | B4) != (0 | (g6 = g6 + 1 | 0)); ) ; + } else I7 = -1; + return r3 = c4 + 16 | 0, 0 | I7; + } + iI(), Q3(); + }, Ic: function(A8, I7, g6, C4) { + A8 |= 0, I7 |= 0, g6 |= 0, C4 |= 0; + var B4, Q4 = 0, o4 = 0, c4 = 0, D4 = 0, a4 = 0; + if (E3[12 + (B4 = r3 - 16 | 0) >> 2] = 0, C4 - 1 >>> 0 < g6 >>> 0) { + for (a4 = (Q4 = g6 - 1 | 0) + I7 | 0, g6 = 0, I7 = 0; D4 = ((128 ^ (o4 = i3[a4 - g6 | 0])) - 1 & E3[B4 + 12 >> 2] - 1 & c4 - 1) >>> 8 & 1, E3[B4 + 12 >> 2] = E3[B4 + 12 >> 2] | 0 - D4 & g6, I7 |= D4, c4 |= o4, (0 | C4) != (0 | (g6 = g6 + 1 | 0)); ) ; + E3[A8 >> 2] = Q4 - E3[B4 + 12 >> 2], A8 = (255 & I7) - 1 | 0; + } else A8 = -1; + return 0 | A8; + }, Jc: function() { + return 1318; + }, Kc: function() { + return 26; + }, Lc: bI, Mc: dI, Nc: function(A8) { + var I7, g6 = 0, C4 = 0, B4 = 0, Q4 = 0, c4 = 0, a4 = 0, y4 = 0, f4 = 0, e4 = 0, w4 = 0, t4 = 0, h4 = 0; + r3 = I7 = r3 - 16 | 0; + A: { + I: { + g: { + C: { + B: { + Q: { + E: { + i: { + o: { + c: { + if ((A8 |= 0) >>> 0 <= 244) { + if (3 & (g6 = (Q4 = E3[9281]) >>> (A8 = (y4 = A8 >>> 0 < 11 ? 16 : A8 + 11 & 504) >>> 3 | 0) | 0)) { + A8 = 37164 + (g6 = (C4 = A8 + (1 & ~g6) | 0) << 3) | 0, g6 = E3[g6 + 37172 >> 2], (0 | A8) != (0 | (B4 = E3[g6 + 8 >> 2])) ? (E3[B4 + 12 >> 2] = A8, E3[A8 + 8 >> 2] = B4) : (t4 = 37124, h4 = gI(-2, C4) & Q4, E3[t4 >> 2] = h4), A8 = g6 + 8 | 0, C4 <<= 3, E3[g6 + 4 >> 2] = 3 | C4, E3[4 + (g6 = g6 + C4 | 0) >> 2] = 1 | E3[g6 + 4 >> 2]; + break A; + } + if ((f4 = E3[9283]) >>> 0 >= y4 >>> 0) break c; + if (g6) { + g6 = 37164 + (C4 = (A8 = aI((0 - (C4 = 2 << A8) | C4) & g6 << A8)) << 3) | 0, C4 = E3[C4 + 37172 >> 2], (0 | g6) != (0 | (B4 = E3[C4 + 8 >> 2])) ? (E3[B4 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = B4) : (Q4 = gI(-2, A8) & Q4, E3[9281] = Q4), E3[C4 + 4 >> 2] = 3 | y4, c4 = (A8 <<= 3) - y4 | 0, E3[4 + (a4 = C4 + y4 | 0) >> 2] = 1 | c4, E3[A8 + C4 >> 2] = c4, f4 && (A8 = 37164 + (-8 & f4) | 0, B4 = E3[9286], (g6 = 1 << (f4 >>> 3)) & Q4 ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | Q4, g6 = A8), E3[A8 + 8 >> 2] = B4, E3[g6 + 12 >> 2] = B4, E3[B4 + 12 >> 2] = A8, E3[B4 + 8 >> 2] = g6), A8 = C4 + 8 | 0, E3[9286] = a4, E3[9283] = c4; + break A; + } + if (!(w4 = E3[9282])) break c; + for (C4 = E3[37428 + (aI(w4) << 2) >> 2], c4 = (-8 & E3[C4 + 4 >> 2]) - y4 | 0, g6 = C4; (A8 = E3[g6 + 16 >> 2]) || (A8 = E3[g6 + 20 >> 2]); ) c4 = (g6 = (B4 = (-8 & E3[A8 + 4 >> 2]) - y4 | 0) >>> 0 < c4 >>> 0) ? B4 : c4, C4 = g6 ? A8 : C4, g6 = A8; + if (e4 = E3[C4 + 24 >> 2], (0 | C4) != (0 | (A8 = E3[C4 + 12 >> 2]))) { + g6 = E3[C4 + 8 >> 2], E3[g6 + 12 >> 2] = A8, E3[A8 + 8 >> 2] = g6; + break I; + } + if (g6 = E3[C4 + 20 >> 2]) B4 = C4 + 20 | 0; + else { + if (!(g6 = E3[C4 + 16 >> 2])) break o; + B4 = C4 + 16 | 0; + } + for (; a4 = B4, B4 = (A8 = g6) + 20 | 0, (g6 = E3[A8 + 20 >> 2]) || (B4 = A8 + 16 | 0, g6 = E3[A8 + 16 >> 2]); ) ; + E3[a4 >> 2] = 0; + break I; + } + if (y4 = -1, !(A8 >>> 0 > 4294967231) && (y4 = -8 & (g6 = A8 + 11 | 0), a4 = E3[9282])) { + f4 = 31, c4 = 0 - y4 | 0, A8 >>> 0 <= 16777204 && (f4 = 62 + ((y4 >>> 38 - (A8 = D3(g6 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0); + D: { + a: { + if (g6 = E3[37428 + (f4 << 2) >> 2]) for (A8 = 0, C4 = y4 << (31 != (0 | f4) ? 25 - (f4 >>> 1 | 0) : 0); ; ) { + if (!((Q4 = (-8 & E3[g6 + 4 >> 2]) - y4 | 0) >>> 0 >= c4 >>> 0 || (B4 = g6, c4 = Q4))) { + c4 = 0, A8 = g6; + break a; + } + if (Q4 = E3[g6 + 20 >> 2], g6 = E3[16 + ((C4 >>> 29 & 4) + g6 | 0) >> 2], A8 = Q4 ? (0 | Q4) == (0 | g6) ? A8 : Q4 : A8, C4 <<= 1, !g6) break; + } + else A8 = 0; + if (!(A8 | B4)) { + if (B4 = 0, !(A8 = (0 - (A8 = 2 << f4) | A8) & a4)) break c; + A8 = E3[37428 + (aI(A8) << 2) >> 2]; + } + if (!A8) break D; + } + for (; c4 = (g6 = (C4 = (-8 & E3[A8 + 4 >> 2]) - y4 | 0) >>> 0 < c4 >>> 0) ? C4 : c4, B4 = g6 ? A8 : B4, A8 = (g6 = E3[A8 + 16 >> 2]) || E3[A8 + 20 >> 2]; ) ; + } + if (!(!B4 | E3[9283] - y4 >>> 0 <= c4 >>> 0)) { + if (f4 = E3[B4 + 24 >> 2], (0 | B4) != (0 | (A8 = E3[B4 + 12 >> 2]))) { + g6 = E3[B4 + 8 >> 2], E3[g6 + 12 >> 2] = A8, E3[A8 + 8 >> 2] = g6; + break g; + } + if (g6 = E3[B4 + 20 >> 2]) C4 = B4 + 20 | 0; + else { + if (!(g6 = E3[B4 + 16 >> 2])) break i; + C4 = B4 + 16 | 0; + } + for (; Q4 = C4, C4 = (A8 = g6) + 20 | 0, (g6 = E3[A8 + 20 >> 2]) || (C4 = A8 + 16 | 0, g6 = E3[A8 + 16 >> 2]); ) ; + E3[Q4 >> 2] = 0; + break g; + } + } + } + if ((B4 = E3[9283]) >>> 0 >= y4 >>> 0) { + A8 = E3[9286], (g6 = B4 - y4 | 0) >>> 0 >= 16 ? (E3[4 + (C4 = A8 + y4 | 0) >> 2] = 1 | g6, E3[A8 + B4 >> 2] = g6, E3[A8 + 4 >> 2] = 3 | y4) : (E3[A8 + 4 >> 2] = 3 | B4, E3[4 + (g6 = A8 + B4 | 0) >> 2] = 1 | E3[g6 + 4 >> 2], C4 = 0, g6 = 0), E3[9283] = g6, E3[9286] = C4, A8 = A8 + 8 | 0; + break A; + } + if ((C4 = E3[9284]) >>> 0 > y4 >>> 0) { + g6 = C4 - y4 | 0, E3[9284] = g6, C4 = (A8 = E3[9287]) + y4 | 0, E3[9287] = C4, E3[C4 + 4 >> 2] = 1 | g6, E3[A8 + 4 >> 2] = 3 | y4, A8 = A8 + 8 | 0; + break A; + } + if (A8 = 0, c4 = y4 + 47 | 0, E3[9399] ? g6 = E3[9401] : (E3[9402] = -1, E3[9403] = -1, E3[9400] = 4096, E3[9401] = 4096, E3[9399] = I7 + 12 & -16 ^ 1431655768, E3[9404] = 0, E3[9392] = 0, g6 = 4096), (g6 = (Q4 = c4 + g6 | 0) & (a4 = 0 - g6 | 0)) >>> 0 <= y4 >>> 0) break A; + if ((f4 = E3[9391]) && (B4 = (e4 = E3[9389]) + g6 | 0) >>> 0 <= e4 >>> 0 | B4 >>> 0 > f4 >>> 0) break A; + c: { + if (!(4 & i3[37568])) { + D: { + a: { + y: { + f: { + if (B4 = E3[9287]) for (A8 = 37572; ; ) { + if ((f4 = E3[A8 >> 2]) >>> 0 <= B4 >>> 0 & B4 >>> 0 < f4 + E3[A8 + 4 >> 2] >>> 0) break f; + if (!(A8 = E3[A8 + 8 >> 2])) break; + } + if (-1 == (0 | (C4 = uA(0)))) break D; + if (Q4 = g6, (B4 = (A8 = E3[9400]) - 1 | 0) & C4 && (Q4 = (g6 - C4 | 0) + (C4 + B4 & 0 - A8) | 0), Q4 >>> 0 <= y4 >>> 0) break D; + if ((B4 = E3[9391]) && (A8 = (a4 = E3[9389]) + Q4 | 0) >>> 0 <= a4 >>> 0 | A8 >>> 0 > B4 >>> 0) break D; + if ((0 | C4) != (0 | (A8 = uA(Q4)))) break y; + break c; + } + if ((0 | (C4 = uA(Q4 = a4 & Q4 - C4))) == (E3[A8 >> 2] + E3[A8 + 4 >> 2] | 0)) break a; + A8 = C4; + } + if (-1 == (0 | A8)) break D; + if (y4 + 48 >>> 0 <= Q4 >>> 0) { + C4 = A8; + break c; + } + if (-1 == (0 | uA(C4 = (C4 = E3[9401]) + (c4 - Q4 | 0) & 0 - C4))) break D; + Q4 = C4 + Q4 | 0, C4 = A8; + break c; + } + if (-1 != (0 | C4)) break c; + } + E3[9392] = 4 | E3[9392]; + } + if (-1 == (0 | (C4 = uA(g6))) | -1 == (0 | (A8 = uA(0))) | A8 >>> 0 <= C4 >>> 0) break B; + if ((Q4 = A8 - C4 | 0) >>> 0 <= y4 + 40 >>> 0) break B; + } + A8 = E3[9389] + Q4 | 0, E3[9389] = A8, A8 >>> 0 > o3[9390] && (E3[9390] = A8); + c: { + if (c4 = E3[9287]) { + for (A8 = 37572; ; ) { + if (((g6 = E3[A8 >> 2]) + (B4 = E3[A8 + 4 >> 2]) | 0) == (0 | C4)) break c; + if (!(A8 = E3[A8 + 8 >> 2])) break; + } + break E; + } + for ((A8 = E3[9285]) >>> 0 <= C4 >>> 0 && A8 || (E3[9285] = C4), A8 = 0, E3[9394] = Q4, E3[9393] = C4, E3[9289] = -1, E3[9290] = E3[9399], E3[9396] = 0; B4 = 37164 + (g6 = A8 << 3) | 0, E3[g6 + 37172 >> 2] = B4, E3[g6 + 37176 >> 2] = B4, 32 != (0 | (A8 = A8 + 1 | 0)); ) ; + B4 = (A8 = Q4 - 40 | 0) - (g6 = -8 - C4 & 7) | 0, E3[9284] = B4, g6 = g6 + C4 | 0, E3[9287] = g6, E3[g6 + 4 >> 2] = 1 | B4, E3[4 + (A8 + C4 | 0) >> 2] = 40, E3[9288] = E3[9403]; + break Q; + } + if (8 & E3[A8 + 12 >> 2] | C4 >>> 0 <= c4 >>> 0 | g6 >>> 0 > c4 >>> 0) break E; + E3[A8 + 4 >> 2] = B4 + Q4, g6 = (A8 = -8 - c4 & 7) + c4 | 0, E3[9287] = g6, A8 = (C4 = E3[9284] + Q4 | 0) - A8 | 0, E3[9284] = A8, E3[g6 + 4 >> 2] = 1 | A8, E3[4 + (C4 + c4 | 0) >> 2] = 40, E3[9288] = E3[9403]; + break Q; + } + A8 = 0; + break I; + } + A8 = 0; + break g; + } + o3[9285] > C4 >>> 0 && (E3[9285] = C4), B4 = C4 + Q4 | 0, A8 = 37572; + E: { + for (; ; ) { + if ((0 | (g6 = E3[A8 >> 2])) != (0 | B4)) { + if (A8 = E3[A8 + 8 >> 2]) continue; + break E; + } + break; + } + if (!(8 & i3[A8 + 12 | 0])) break C; + } + for (A8 = 37572; !((g6 = E3[A8 >> 2]) >>> 0 <= c4 >>> 0 && (B4 = g6 + E3[A8 + 4 >> 2] | 0) >>> 0 > c4 >>> 0); ) A8 = E3[A8 + 8 >> 2]; + for (a4 = (A8 = Q4 - 40 | 0) - (g6 = -8 - C4 & 7) | 0, E3[9284] = a4, g6 = g6 + C4 | 0, E3[9287] = g6, E3[g6 + 4 >> 2] = 1 | a4, E3[4 + (A8 + C4 | 0) >> 2] = 40, E3[9288] = E3[9403], E3[(g6 = (A8 = (B4 + (39 - B4 & 7) | 0) - 47 | 0) >>> 0 < c4 + 16 >>> 0 ? c4 : A8) + 4 >> 2] = 27, A8 = E3[9396], E3[g6 + 16 >> 2] = E3[9395], E3[g6 + 20 >> 2] = A8, A8 = E3[9394], E3[g6 + 8 >> 2] = E3[9393], E3[g6 + 12 >> 2] = A8, E3[9395] = g6 + 8, E3[9394] = Q4, E3[9393] = C4, E3[9396] = 0, A8 = g6 + 24 | 0; E3[A8 + 4 >> 2] = 7, C4 = A8 + 8 | 0, A8 = A8 + 4 | 0, C4 >>> 0 < B4 >>> 0; ) ; + if ((0 | g6) != (0 | c4)) { + E3[g6 + 4 >> 2] = -2 & E3[g6 + 4 >> 2], C4 = g6 - c4 | 0, E3[c4 + 4 >> 2] = 1 | C4, E3[g6 >> 2] = C4; + E: if (C4 >>> 0 <= 255) A8 = 37164 + (-8 & C4) | 0, (g6 = E3[9281]) & (C4 = 1 << (C4 >>> 3)) ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | C4, g6 = A8), E3[A8 + 8 >> 2] = c4, E3[g6 + 12 >> 2] = c4, B4 = 8, C4 = 12; + else { + A8 = 31, C4 >>> 0 <= 16777215 && (A8 = 62 + ((C4 >>> 38 - (A8 = D3(C4 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0), E3[c4 + 28 >> 2] = A8, E3[c4 + 16 >> 2] = 0, E3[c4 + 20 >> 2] = 0, g6 = 37428 + (A8 << 2) | 0; + i: { + if ((B4 = E3[9282]) & (Q4 = 1 << A8)) { + for (A8 = C4 << (31 != (0 | A8) ? 25 - (A8 >>> 1 | 0) : 0), B4 = E3[g6 >> 2]; ; ) { + if ((0 | C4) == (-8 & E3[(g6 = B4) + 4 >> 2])) break i; + if (B4 = A8 >>> 29 | 0, A8 <<= 1, !(B4 = E3[16 + (Q4 = (4 & B4) + g6 | 0) >> 2])) break; + } + E3[Q4 + 16 >> 2] = c4; + } else E3[9282] = B4 | Q4, E3[g6 >> 2] = c4; + E3[c4 + 24 >> 2] = g6, A8 = g6 = c4, B4 = 12, C4 = 8; + break E; + } + A8 = E3[g6 + 8 >> 2], E3[A8 + 12 >> 2] = c4, E3[g6 + 8 >> 2] = c4, E3[c4 + 8 >> 2] = A8, A8 = 0, B4 = 12, C4 = 24; + } + E3[B4 + c4 >> 2] = g6, E3[C4 + c4 >> 2] = A8; + } + } + if (!((A8 = E3[9284]) >>> 0 <= y4 >>> 0)) { + g6 = A8 - y4 | 0, E3[9284] = g6, C4 = (A8 = E3[9287]) + y4 | 0, E3[9287] = C4, E3[C4 + 4 >> 2] = 1 | g6, E3[A8 + 4 >> 2] = 3 | y4, A8 = A8 + 8 | 0; + break A; + } + } + E3[9280] = 48, A8 = 0; + break A; + } + E3[A8 >> 2] = C4, E3[A8 + 4 >> 2] = E3[A8 + 4 >> 2] + Q4, E3[4 + (f4 = (-8 - C4 & 7) + C4 | 0) >> 2] = 3 | y4, a4 = (Q4 = g6 + (-8 - g6 & 7) | 0) - (c4 = y4 + f4 | 0) | 0; + C: if (E3[9287] != (0 | Q4)) if (E3[9286] != (0 | Q4)) { + if (1 == (3 & (A8 = E3[Q4 + 4 >> 2]))) { + e4 = -8 & A8, C4 = E3[Q4 + 12 >> 2]; + B: if (A8 >>> 0 <= 255) { + if ((0 | (g6 = E3[Q4 + 8 >> 2])) == (0 | C4)) { + t4 = 37124, h4 = E3[9281] & gI(-2, A8 >>> 3 | 0), E3[t4 >> 2] = h4; + break B; + } + E3[g6 + 12 >> 2] = C4, E3[C4 + 8 >> 2] = g6; + } else { + y4 = E3[Q4 + 24 >> 2]; + Q: if ((0 | C4) == (0 | Q4)) { + E: { + if (A8 = E3[Q4 + 20 >> 2]) g6 = Q4 + 20 | 0; + else { + if (!(A8 = E3[Q4 + 16 >> 2])) break E; + g6 = Q4 + 16 | 0; + } + for (; B4 = g6, C4 = A8, g6 = A8 + 20 | 0, (A8 = E3[A8 + 20 >> 2]) || (g6 = C4 + 16 | 0, A8 = E3[C4 + 16 >> 2]); ) ; + E3[B4 >> 2] = 0; + break Q; + } + C4 = 0; + } else A8 = E3[Q4 + 8 >> 2], E3[A8 + 12 >> 2] = C4, E3[C4 + 8 >> 2] = A8; + if (y4) { + A8 = E3[Q4 + 28 >> 2]; + Q: { + if (E3[(g6 = 37428 + (A8 << 2) | 0) >> 2] == (0 | Q4)) { + if (E3[g6 >> 2] = C4, C4) break Q; + t4 = 37128, h4 = E3[9282] & gI(-2, A8), E3[t4 >> 2] = h4; + break B; + } + if (E3[y4 + (E3[y4 + 16 >> 2] == (0 | Q4) ? 16 : 20) >> 2] = C4, !C4) break B; + } + E3[C4 + 24 >> 2] = y4, (A8 = E3[Q4 + 16 >> 2]) && (E3[C4 + 16 >> 2] = A8, E3[A8 + 24 >> 2] = C4), (A8 = E3[Q4 + 20 >> 2]) && (E3[C4 + 20 >> 2] = A8, E3[A8 + 24 >> 2] = C4); + } + } + a4 = a4 + e4 | 0, A8 = E3[4 + (Q4 = Q4 + e4 | 0) >> 2]; + } + if (E3[Q4 + 4 >> 2] = -2 & A8, E3[c4 + 4 >> 2] = 1 | a4, E3[c4 + a4 >> 2] = a4, a4 >>> 0 <= 255) A8 = 37164 + (-8 & a4) | 0, (g6 = E3[9281]) & (C4 = 1 << (a4 >>> 3)) ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | C4, g6 = A8), E3[A8 + 8 >> 2] = c4, E3[g6 + 12 >> 2] = c4, E3[c4 + 12 >> 2] = A8, E3[c4 + 8 >> 2] = g6; + else { + C4 = 31, a4 >>> 0 <= 16777215 && (C4 = 62 + ((a4 >>> 38 - (A8 = D3(a4 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0), E3[c4 + 28 >> 2] = C4, E3[c4 + 16 >> 2] = 0, E3[c4 + 20 >> 2] = 0, A8 = 37428 + (C4 << 2) | 0; + B: { + if ((g6 = E3[9282]) & (B4 = 1 << C4)) { + for (C4 = a4 << (31 != (0 | C4) ? 25 - (C4 >>> 1 | 0) : 0), g6 = E3[A8 >> 2]; ; ) { + if ((-8 & E3[(A8 = g6) + 4 >> 2]) == (0 | a4)) break B; + if (g6 = C4 >>> 29 | 0, C4 <<= 1, !(g6 = E3[16 + (B4 = (4 & g6) + A8 | 0) >> 2])) break; + } + E3[B4 + 16 >> 2] = c4; + } else E3[9282] = g6 | B4, E3[A8 >> 2] = c4; + E3[c4 + 24 >> 2] = A8, E3[c4 + 12 >> 2] = c4, E3[c4 + 8 >> 2] = c4; + break C; + } + g6 = E3[A8 + 8 >> 2], E3[g6 + 12 >> 2] = c4, E3[A8 + 8 >> 2] = c4, E3[c4 + 24 >> 2] = 0, E3[c4 + 12 >> 2] = A8, E3[c4 + 8 >> 2] = g6; + } + } else E3[9286] = c4, A8 = E3[9283] + a4 | 0, E3[9283] = A8, E3[c4 + 4 >> 2] = 1 | A8, E3[A8 + c4 >> 2] = A8; + else E3[9287] = c4, A8 = E3[9284] + a4 | 0, E3[9284] = A8, E3[c4 + 4 >> 2] = 1 | A8; + A8 = f4 + 8 | 0; + break A; + } + g: if (f4) { + g6 = E3[B4 + 28 >> 2]; + C: { + if (E3[(C4 = 37428 + (g6 << 2) | 0) >> 2] == (0 | B4)) { + if (E3[C4 >> 2] = A8, A8) break C; + a4 = gI(-2, g6) & a4, E3[9282] = a4; + break g; + } + if (E3[f4 + (E3[f4 + 16 >> 2] == (0 | B4) ? 16 : 20) >> 2] = A8, !A8) break g; + } + E3[A8 + 24 >> 2] = f4, (g6 = E3[B4 + 16 >> 2]) && (E3[A8 + 16 >> 2] = g6, E3[g6 + 24 >> 2] = A8), (g6 = E3[B4 + 20 >> 2]) && (E3[A8 + 20 >> 2] = g6, E3[g6 + 24 >> 2] = A8); + } + g: if (c4 >>> 0 <= 15) A8 = c4 + y4 | 0, E3[B4 + 4 >> 2] = 3 | A8, E3[4 + (A8 = A8 + B4 | 0) >> 2] = 1 | E3[A8 + 4 >> 2]; + else if (E3[B4 + 4 >> 2] = 3 | y4, E3[4 + (Q4 = B4 + y4 | 0) >> 2] = 1 | c4, E3[c4 + Q4 >> 2] = c4, c4 >>> 0 <= 255) A8 = 37164 + (-8 & c4) | 0, (g6 = E3[9281]) & (C4 = 1 << (c4 >>> 3)) ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | C4, g6 = A8), E3[A8 + 8 >> 2] = Q4, E3[g6 + 12 >> 2] = Q4, E3[Q4 + 12 >> 2] = A8, E3[Q4 + 8 >> 2] = g6; + else { + A8 = 31, c4 >>> 0 <= 16777215 && (A8 = 62 + ((c4 >>> 38 - (A8 = D3(c4 >>> 8 | 0)) & 1) - (A8 << 1) | 0) | 0), E3[Q4 + 28 >> 2] = A8, E3[Q4 + 16 >> 2] = 0, E3[Q4 + 20 >> 2] = 0, g6 = 37428 + (A8 << 2) | 0; + C: { + if ((C4 = 1 << A8) & a4) { + for (A8 = c4 << (31 != (0 | A8) ? 25 - (A8 >>> 1 | 0) : 0), g6 = E3[g6 >> 2]; ; ) { + if (C4 = g6, (-8 & E3[g6 + 4 >> 2]) == (0 | c4)) break C; + if (a4 = A8 >>> 29 | 0, A8 <<= 1, !(g6 = E3[16 + (a4 = g6 + (4 & a4) | 0) >> 2])) break; + } + E3[a4 + 16 >> 2] = Q4, E3[Q4 + 24 >> 2] = C4; + } else E3[9282] = C4 | a4, E3[g6 >> 2] = Q4, E3[Q4 + 24 >> 2] = g6; + E3[Q4 + 12 >> 2] = Q4, E3[Q4 + 8 >> 2] = Q4; + break g; + } + A8 = E3[C4 + 8 >> 2], E3[A8 + 12 >> 2] = Q4, E3[C4 + 8 >> 2] = Q4, E3[Q4 + 24 >> 2] = 0, E3[Q4 + 12 >> 2] = C4, E3[Q4 + 8 >> 2] = A8; + } + A8 = B4 + 8 | 0; + break A; + } + I: if (e4) { + g6 = E3[C4 + 28 >> 2]; + g: { + if (E3[(B4 = 37428 + (g6 << 2) | 0) >> 2] == (0 | C4)) { + if (E3[B4 >> 2] = A8, A8) break g; + t4 = 37128, h4 = gI(-2, g6) & w4, E3[t4 >> 2] = h4; + break I; + } + if (E3[e4 + (E3[e4 + 16 >> 2] == (0 | C4) ? 16 : 20) >> 2] = A8, !A8) break I; + } + E3[A8 + 24 >> 2] = e4, (g6 = E3[C4 + 16 >> 2]) && (E3[A8 + 16 >> 2] = g6, E3[g6 + 24 >> 2] = A8), (g6 = E3[C4 + 20 >> 2]) && (E3[A8 + 20 >> 2] = g6, E3[g6 + 24 >> 2] = A8); + } + c4 >>> 0 <= 15 ? (A8 = c4 + y4 | 0, E3[C4 + 4 >> 2] = 3 | A8, E3[4 + (A8 = A8 + C4 | 0) >> 2] = 1 | E3[A8 + 4 >> 2]) : (E3[C4 + 4 >> 2] = 3 | y4, E3[4 + (a4 = C4 + y4 | 0) >> 2] = 1 | c4, E3[c4 + a4 >> 2] = c4, f4 && (A8 = 37164 + (-8 & f4) | 0, B4 = E3[9286], (g6 = 1 << (f4 >>> 3)) & Q4 ? g6 = E3[A8 + 8 >> 2] : (E3[9281] = g6 | Q4, g6 = A8), E3[A8 + 8 >> 2] = B4, E3[g6 + 12 >> 2] = B4, E3[B4 + 12 >> 2] = A8, E3[B4 + 8 >> 2] = g6), E3[9286] = a4, E3[9283] = c4), A8 = C4 + 8 | 0; + } + return r3 = I7 + 16 | 0, 0 | A8; + }, Oc: function(A8) { + var I7 = 0, g6 = 0, C4 = 0, B4 = 0, Q4 = 0, i4 = 0, c4 = 0, a4 = 0, y4 = 0; + A: if (A8 |= 0) { + Q4 = (C4 = A8 - 8 | 0) + (A8 = -8 & (I7 = E3[A8 - 4 >> 2])) | 0; + I: if (!(1 & I7)) { + if (!(2 & I7)) break A; + if ((C4 = C4 - (I7 = E3[C4 >> 2]) | 0) >>> 0 < o3[9285]) break A; + A8 = A8 + I7 | 0; + g: { + C: { + B: { + if (E3[9286] != (0 | C4)) { + if (g6 = E3[C4 + 12 >> 2], I7 >>> 0 <= 255) { + if ((0 | (B4 = E3[C4 + 8 >> 2])) != (0 | g6)) break B; + a4 = 37124, y4 = E3[9281] & gI(-2, I7 >>> 3 | 0), E3[a4 >> 2] = y4; + break I; + } + if (c4 = E3[C4 + 24 >> 2], (0 | g6) != (0 | C4)) { + I7 = E3[C4 + 8 >> 2], E3[I7 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = I7; + break g; + } + if (B4 = E3[C4 + 20 >> 2]) I7 = C4 + 20 | 0; + else { + if (!(B4 = E3[C4 + 16 >> 2])) break C; + I7 = C4 + 16 | 0; + } + for (; i4 = I7, I7 = (g6 = B4) + 20 | 0, (B4 = E3[g6 + 20 >> 2]) || (I7 = g6 + 16 | 0, B4 = E3[g6 + 16 >> 2]); ) ; + E3[i4 >> 2] = 0; + break g; + } + if (3 & ~(I7 = E3[Q4 + 4 >> 2])) break I; + return E3[9283] = A8, E3[Q4 + 4 >> 2] = -2 & I7, E3[C4 + 4 >> 2] = 1 | A8, void (E3[Q4 >> 2] = A8); + } + E3[B4 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = B4; + break I; + } + g6 = 0; + } + if (c4) { + I7 = E3[C4 + 28 >> 2]; + g: { + if (E3[(B4 = 37428 + (I7 << 2) | 0) >> 2] == (0 | C4)) { + if (E3[B4 >> 2] = g6, g6) break g; + a4 = 37128, y4 = E3[9282] & gI(-2, I7), E3[a4 >> 2] = y4; + break I; + } + if (E3[c4 + (E3[c4 + 16 >> 2] == (0 | C4) ? 16 : 20) >> 2] = g6, !g6) break I; + } + E3[g6 + 24 >> 2] = c4, (I7 = E3[C4 + 16 >> 2]) && (E3[g6 + 16 >> 2] = I7, E3[I7 + 24 >> 2] = g6), (I7 = E3[C4 + 20 >> 2]) && (E3[g6 + 20 >> 2] = I7, E3[I7 + 24 >> 2] = g6); + } + } + if (!(C4 >>> 0 >= Q4 >>> 0) && 1 & (I7 = E3[Q4 + 4 >> 2])) { + I: { + g: { + C: { + B: { + if (!(2 & I7)) { + if ((0 | Q4) == E3[9287]) { + if (E3[9287] = C4, A8 = E3[9284] + A8 | 0, E3[9284] = A8, E3[C4 + 4 >> 2] = 1 | A8, E3[9286] != (0 | C4)) break A; + return E3[9283] = 0, void (E3[9286] = 0); + } + if ((0 | Q4) == E3[9286]) return E3[9286] = C4, A8 = E3[9283] + A8 | 0, E3[9283] = A8, E3[C4 + 4 >> 2] = 1 | A8, void (E3[A8 + C4 >> 2] = A8); + if (A8 = (-8 & I7) + A8 | 0, g6 = E3[Q4 + 12 >> 2], I7 >>> 0 <= 255) { + if ((0 | (B4 = E3[Q4 + 8 >> 2])) == (0 | g6)) { + a4 = 37124, y4 = E3[9281] & gI(-2, I7 >>> 3 | 0), E3[a4 >> 2] = y4; + break g; + } + E3[B4 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = B4; + break g; + } + if (c4 = E3[Q4 + 24 >> 2], (0 | g6) != (0 | Q4)) { + I7 = E3[Q4 + 8 >> 2], E3[I7 + 12 >> 2] = g6, E3[g6 + 8 >> 2] = I7; + break C; + } + if (B4 = E3[Q4 + 20 >> 2]) I7 = Q4 + 20 | 0; + else { + if (!(B4 = E3[Q4 + 16 >> 2])) break B; + I7 = Q4 + 16 | 0; + } + for (; i4 = I7, I7 = (g6 = B4) + 20 | 0, (B4 = E3[g6 + 20 >> 2]) || (I7 = g6 + 16 | 0, B4 = E3[g6 + 16 >> 2]); ) ; + E3[i4 >> 2] = 0; + break C; + } + E3[Q4 + 4 >> 2] = -2 & I7, E3[C4 + 4 >> 2] = 1 | A8, E3[A8 + C4 >> 2] = A8; + break I; + } + g6 = 0; + } + if (c4) { + I7 = E3[Q4 + 28 >> 2]; + C: { + if ((0 | Q4) == E3[(B4 = 37428 + (I7 << 2) | 0) >> 2]) { + if (E3[B4 >> 2] = g6, g6) break C; + a4 = 37128, y4 = E3[9282] & gI(-2, I7), E3[a4 >> 2] = y4; + break g; + } + if (E3[c4 + ((0 | Q4) == E3[c4 + 16 >> 2] ? 16 : 20) >> 2] = g6, !g6) break g; + } + E3[g6 + 24 >> 2] = c4, (I7 = E3[Q4 + 16 >> 2]) && (E3[g6 + 16 >> 2] = I7, E3[I7 + 24 >> 2] = g6), (I7 = E3[Q4 + 20 >> 2]) && (E3[g6 + 20 >> 2] = I7, E3[I7 + 24 >> 2] = g6); + } + } + if (E3[C4 + 4 >> 2] = 1 | A8, E3[A8 + C4 >> 2] = A8, E3[9286] == (0 | C4)) return void (E3[9283] = A8); + } + if (A8 >>> 0 <= 255) return I7 = 37164 + (-8 & A8) | 0, (B4 = E3[9281]) & (A8 = 1 << (A8 >>> 3)) ? A8 = E3[I7 + 8 >> 2] : (E3[9281] = A8 | B4, A8 = I7), E3[I7 + 8 >> 2] = C4, E3[A8 + 12 >> 2] = C4, E3[C4 + 12 >> 2] = I7, void (E3[C4 + 8 >> 2] = A8); + g6 = 31, A8 >>> 0 <= 16777215 && (g6 = 62 + ((A8 >>> 38 - (I7 = D3(A8 >>> 8 | 0)) & 1) - (I7 << 1) | 0) | 0), E3[C4 + 28 >> 2] = g6, E3[C4 + 16 >> 2] = 0, E3[C4 + 20 >> 2] = 0, i4 = 37428 + (g6 << 2) | 0; + I: { + g: { + if ((I7 = E3[9282]) & (B4 = 1 << g6)) { + for (g6 = A8 << (31 != (0 | g6) ? 25 - (g6 >>> 1 | 0) : 0), I7 = E3[i4 >> 2]; ; ) { + if (B4 = I7, (-8 & E3[I7 + 4 >> 2]) == (0 | A8)) break g; + if (I7 = g6 >>> 29 | 0, g6 <<= 1, !(I7 = E3[(i4 = 16 + ((4 & I7) + B4 | 0) | 0) >> 2])) break; + } + g6 = 24, I7 = B4; + } else E3[9282] = I7 | B4, g6 = 24, I7 = i4; + B4 = C4, Q4 = C4, A8 = 8; + break I; + } + I7 = E3[B4 + 8 >> 2], E3[I7 + 12 >> 2] = C4, g6 = 8, i4 = B4 + 8 | 0, Q4 = 0, A8 = 24; + } + E3[i4 >> 2] = C4, E3[g6 + C4 >> 2] = I7, E3[C4 + 12 >> 2] = B4, E3[A8 + C4 >> 2] = Q4, A8 = E3[9289] - 1 | 0, E3[9289] = A8 || -1; + } + } + }, Pc: vI }; + }(A6); + }(I5); + }, instantiate: function(A5, I5) { + return { then: function(g4) { + var C2 = new w2.Module(A5); + g4({ instance: new w2.Instance(C2, I5) }); + } }; + }, RuntimeError: Error }; + y2 = []; + var r2, t2, h2, k2, n2, s2, F2, S2 = false; + function M2() { + var A5 = e2.buffer; + B2.HEAP8 = r2 = new Int8Array(A5), B2.HEAP16 = h2 = new Int16Array(A5), B2.HEAPU8 = t2 = new Uint8Array(A5), B2.HEAPU16 = new Uint16Array(A5), B2.HEAP32 = k2 = new Int32Array(A5), B2.HEAPU32 = n2 = new Uint32Array(A5), B2.HEAPF32 = s2 = new Float32Array(A5), B2.HEAPF64 = F2 = new Float64Array(A5); + } + var N2 = [], K2 = [], _2 = [], p2 = 0, H2 = null, G2 = null; + function J2(A5) { + throw B2.onAbort?.(A5), f2(A5 = "Aborted(" + A5 + ")"), S2 = true, A5 += ". Build with -sASSERTIONS for more info.", new w2.RuntimeError(A5); + } + var Y2, U2 = (A5) => A5.startsWith("file://"); + var d2 = { 36304: () => B2.getRandomValue(), 36340: () => { + if (void 0 === B2.getRandomValue) try { + var A5 = "object" == typeof window ? window : self, I5 = void 0 !== A5.crypto ? A5.crypto : A5.msCrypto; + I5 = void 0 === I5 ? C2 : I5; + var g4 = function() { + var A6 = new Uint32Array(1); + return I5.getRandomValues(A6), A6[0] >>> 0; + }; + g4(), B2.getRandomValue = g4; + } catch (A6) { + try { + var C2 = require("crypto"), Q3 = function() { + var A7 = C2.randomBytes(4); + return (A7[0] << 24 | A7[1] << 16 | A7[2] << 8 | A7[3]) >>> 0; + }; + Q3(), B2.getRandomValue = Q3; + } catch (A7) { + throw "No secure random number generator found"; + } + } + } }, b2 = (A5) => { + for (; A5.length > 0; ) A5.shift()(B2); + }; + B2.noExitRuntime; + var P2, v2 = "undefined" != typeof TextDecoder ? new TextDecoder() : void 0, R2 = (A5, I5) => A5 ? ((A6, I6, g4) => { + for (var C2 = I6 + g4, B3 = I6; A6[B3] && !(B3 >= C2); ) ++B3; + if (B3 - I6 > 16 && A6.buffer && v2) return v2.decode(A6.subarray(I6, B3)); + for (var Q3 = ""; I6 < B3; ) { + var E3 = A6[I6++]; + if (128 & E3) { + var i3 = 63 & A6[I6++]; + if (192 != (224 & E3)) { + var o3 = 63 & A6[I6++]; + if ((E3 = 224 == (240 & E3) ? (15 & E3) << 12 | i3 << 6 | o3 : (7 & E3) << 18 | i3 << 12 | o3 << 6 | 63 & A6[I6++]) < 65536) Q3 += String.fromCharCode(E3); + else { + var c3 = E3 - 65536; + Q3 += String.fromCharCode(55296 | c3 >> 10, 56320 | 1023 & c3); + } + } else Q3 += String.fromCharCode((31 & E3) << 6 | i3); + } else Q3 += String.fromCharCode(E3); + } + return Q3; + })(t2, A5, I5) : "", L2 = [], x2 = (A5) => { + var I5 = (A5 - e2.buffer.byteLength + 65535) / 65536; + try { + return e2.grow(I5), M2(), 1; + } catch (A6) { + } + }, u2 = { b: (A5, I5, g4, C2) => { + J2(`Assertion failed: ${R2(A5)}, at: ` + [I5 ? R2(I5) : "unknown filename", g4, C2 ? R2(C2) : "unknown function"]); + }, c: () => { + J2(""); + }, a: (A5, I5, g4) => ((A6, I6, g5) => { + var C2 = ((A7, I7) => { + var g6; + for (L2.length = 0; g6 = t2[A7++]; ) { + var C3 = 105 != g6; + I7 += (C3 &= 112 != g6) && I7 % 8 ? 4 : 0, L2.push(112 == g6 ? n2[I7 >> 2] : 105 == g6 ? k2[I7 >> 2] : F2[I7 >> 3]), I7 += C3 ? 8 : 4; + } + return L2; + })(I6, g5); + return d2[A6](...C2); + })(A5, I5, g4), d: (A5) => { + var I5 = t2.length, g4 = 2147483648; + if ((A5 >>>= 0) > g4) return false; + for (var C2, B3 = 1; B3 <= 4; B3 *= 2) { + var Q3 = I5 * (1 + 0.2 / B3); + Q3 = Math.min(Q3, A5 + 100663296); + var E3 = Math.min(g4, (C2 = Math.max(A5, Q3)) + (65536 - C2 % 65536) % 65536); + if (x2(E3)) return true; + } + return false; + } }, m2 = function() { + var A5 = { a: u2 }; + function I5(A6, I6) { + var g4; + return m2 = A6.exports, e2 = m2.e, M2(), g4 = m2.f, K2.unshift(g4), function(A7) { + if (p2--, B2.monitorRunDependencies?.(p2), 0 == p2 && (null !== H2 && (clearInterval(H2), H2 = null), G2)) { + var I7 = G2; + G2 = null, I7(); + } + }(), m2; + } + if (p2++, B2.monitorRunDependencies?.(p2), B2.instantiateWasm) try { + return B2.instantiateWasm(A5, I5); + } catch (A6) { + return f2(`Module.instantiateWasm callback failed with error: ${A6}`), false; + } + return Y2 || (Y2 = "<<< WASM_BINARY_FILE >>>"), function(A6, I6, C2) { + (function(A7) { + return Promise.resolve().then(() => function(A8) { + if (A8 == Y2 && y2) return new Uint8Array(y2); + if (g3) return g3(A8); + throw "both async and sync fetching of the wasm failed"; + }(A7)); + })(A6).then((A7) => w2.instantiate(A7, I6)).then(C2, (A7) => { + f2(`failed to asynchronously prepare wasm: ${A7}`), J2(A7); + }); + }(Y2, A5, function(A6) { + I5(A6.instance); + }), {}; + }(); + function q2() { + function A5() { + P2 || (P2 = true, B2.calledRun = true, S2 || (b2(K2), B2.onRuntimeInitialized?.(), function() { + if (B2.postRun) for ("function" == typeof B2.postRun && (B2.postRun = [B2.postRun]); B2.postRun.length; ) A6 = B2.postRun.shift(), _2.unshift(A6); + var A6; + b2(_2); + }())); + } + p2 > 0 || (function() { + if (B2.preRun) for ("function" == typeof B2.preRun && (B2.preRun = [B2.preRun]); B2.preRun.length; ) A6 = B2.preRun.shift(), N2.unshift(A6); + var A6; + b2(N2); + }(), p2 > 0 || (B2.setStatus ? (B2.setStatus("Running..."), setTimeout(function() { + setTimeout(function() { + B2.setStatus(""); + }, 1), A5(); + }, 1)) : A5())); + } + if (B2._crypto_aead_aegis128l_keybytes = () => (B2._crypto_aead_aegis128l_keybytes = m2.g)(), B2._crypto_aead_aegis128l_nsecbytes = () => (B2._crypto_aead_aegis128l_nsecbytes = m2.h)(), B2._crypto_aead_aegis128l_npubbytes = () => (B2._crypto_aead_aegis128l_npubbytes = m2.i)(), B2._crypto_aead_aegis128l_abytes = () => (B2._crypto_aead_aegis128l_abytes = m2.j)(), B2._crypto_aead_aegis128l_messagebytes_max = () => (B2._crypto_aead_aegis128l_messagebytes_max = m2.k)(), B2._crypto_aead_aegis128l_keygen = (A5) => (B2._crypto_aead_aegis128l_keygen = m2.l)(A5), B2._crypto_aead_aegis128l_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis128l_encrypt = m2.m)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis128l_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_aegis128l_encrypt_detached = m2.n)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_aegis128l_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis128l_decrypt = m2.o)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis128l_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis128l_decrypt_detached = m2.p)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis256_keybytes = () => (B2._crypto_aead_aegis256_keybytes = m2.q)(), B2._crypto_aead_aegis256_nsecbytes = () => (B2._crypto_aead_aegis256_nsecbytes = m2.r)(), B2._crypto_aead_aegis256_npubbytes = () => (B2._crypto_aead_aegis256_npubbytes = m2.s)(), B2._crypto_aead_aegis256_abytes = () => (B2._crypto_aead_aegis256_abytes = m2.t)(), B2._crypto_aead_aegis256_messagebytes_max = () => (B2._crypto_aead_aegis256_messagebytes_max = m2.u)(), B2._crypto_aead_aegis256_keygen = (A5) => (B2._crypto_aead_aegis256_keygen = m2.v)(A5), B2._crypto_aead_aegis256_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis256_encrypt = m2.w)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis256_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_aegis256_encrypt_detached = m2.x)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_aegis256_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis256_decrypt = m2.y)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aegis256_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_aegis256_decrypt_detached = m2.z)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_aes256gcm_is_available = () => (B2._crypto_aead_aes256gcm_is_available = m2.A)(), B2._crypto_aead_chacha20poly1305_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_chacha20poly1305_encrypt_detached = m2.B)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_chacha20poly1305_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_encrypt = m2.C)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_chacha20poly1305_ietf_encrypt_detached = m2.D)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_chacha20poly1305_ietf_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_ietf_encrypt = m2.E)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_decrypt_detached = m2.F)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_decrypt = m2.G)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_ietf_decrypt_detached = m2.H)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_chacha20poly1305_ietf_decrypt = m2.I)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_chacha20poly1305_ietf_keybytes = () => (B2._crypto_aead_chacha20poly1305_ietf_keybytes = m2.J)(), B2._crypto_aead_chacha20poly1305_ietf_npubbytes = () => (B2._crypto_aead_chacha20poly1305_ietf_npubbytes = m2.K)(), B2._crypto_aead_chacha20poly1305_ietf_nsecbytes = () => (B2._crypto_aead_chacha20poly1305_ietf_nsecbytes = m2.L)(), B2._crypto_aead_chacha20poly1305_ietf_abytes = () => (B2._crypto_aead_chacha20poly1305_ietf_abytes = m2.M)(), B2._crypto_aead_chacha20poly1305_ietf_messagebytes_max = () => (B2._crypto_aead_chacha20poly1305_ietf_messagebytes_max = m2.N)(), B2._crypto_aead_chacha20poly1305_ietf_keygen = (A5) => (B2._crypto_aead_chacha20poly1305_ietf_keygen = m2.O)(A5), B2._crypto_aead_chacha20poly1305_keybytes = () => (B2._crypto_aead_chacha20poly1305_keybytes = m2.P)(), B2._crypto_aead_chacha20poly1305_npubbytes = () => (B2._crypto_aead_chacha20poly1305_npubbytes = m2.Q)(), B2._crypto_aead_chacha20poly1305_nsecbytes = () => (B2._crypto_aead_chacha20poly1305_nsecbytes = m2.R)(), B2._crypto_aead_chacha20poly1305_abytes = () => (B2._crypto_aead_chacha20poly1305_abytes = m2.S)(), B2._crypto_aead_chacha20poly1305_messagebytes_max = () => (B2._crypto_aead_chacha20poly1305_messagebytes_max = m2.T)(), B2._crypto_aead_chacha20poly1305_keygen = (A5) => (B2._crypto_aead_chacha20poly1305_keygen = m2.U)(A5), B2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3) => (B2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = m2.V)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3, y3), B2._crypto_aead_xchacha20poly1305_ietf_encrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_xchacha20poly1305_ietf_encrypt = m2.W)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = m2.X)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_xchacha20poly1305_ietf_decrypt = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3) => (B2._crypto_aead_xchacha20poly1305_ietf_decrypt = m2.Y)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3, a3), B2._crypto_aead_xchacha20poly1305_ietf_keybytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_keybytes = m2.Z)(), B2._crypto_aead_xchacha20poly1305_ietf_npubbytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_npubbytes = m2._)(), B2._crypto_aead_xchacha20poly1305_ietf_nsecbytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_nsecbytes = m2.$)(), B2._crypto_aead_xchacha20poly1305_ietf_abytes = () => (B2._crypto_aead_xchacha20poly1305_ietf_abytes = m2.aa)(), B2._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = () => (B2._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = m2.ba)(), B2._crypto_aead_xchacha20poly1305_ietf_keygen = (A5) => (B2._crypto_aead_xchacha20poly1305_ietf_keygen = m2.ca)(A5), B2._crypto_auth_bytes = () => (B2._crypto_auth_bytes = m2.da)(), B2._crypto_auth_keybytes = () => (B2._crypto_auth_keybytes = m2.ea)(), B2._crypto_auth = (A5, I5, g4, C2, Q3) => (B2._crypto_auth = m2.fa)(A5, I5, g4, C2, Q3), B2._crypto_auth_verify = (A5, I5, g4, C2, Q3) => (B2._crypto_auth_verify = m2.ga)(A5, I5, g4, C2, Q3), B2._crypto_auth_keygen = (A5) => (B2._crypto_auth_keygen = m2.ha)(A5), B2._crypto_box_seedbytes = () => (B2._crypto_box_seedbytes = m2.ia)(), B2._crypto_box_publickeybytes = () => (B2._crypto_box_publickeybytes = m2.ja)(), B2._crypto_box_secretkeybytes = () => (B2._crypto_box_secretkeybytes = m2.ka)(), B2._crypto_box_beforenmbytes = () => (B2._crypto_box_beforenmbytes = m2.la)(), B2._crypto_box_noncebytes = () => (B2._crypto_box_noncebytes = m2.ma)(), B2._crypto_box_macbytes = () => (B2._crypto_box_macbytes = m2.na)(), B2._crypto_box_messagebytes_max = () => (B2._crypto_box_messagebytes_max = m2.oa)(), B2._crypto_box_seed_keypair = (A5, I5, g4) => (B2._crypto_box_seed_keypair = m2.pa)(A5, I5, g4), B2._crypto_box_keypair = (A5, I5) => (B2._crypto_box_keypair = m2.qa)(A5, I5), B2._crypto_box_beforenm = (A5, I5, g4) => (B2._crypto_box_beforenm = m2.ra)(A5, I5, g4), B2._crypto_box_detached_afternm = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_detached_afternm = m2.sa)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_detached = (A5, I5, g4, C2, Q3, E3, i3, o3) => (B2._crypto_box_detached = m2.ta)(A5, I5, g4, C2, Q3, E3, i3, o3), B2._crypto_box_easy_afternm = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_box_easy_afternm = m2.ua)(A5, I5, g4, C2, Q3, E3), B2._crypto_box_easy = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_easy = m2.va)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_open_detached_afternm = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_open_detached_afternm = m2.wa)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_open_detached = (A5, I5, g4, C2, Q3, E3, i3, o3) => (B2._crypto_box_open_detached = m2.xa)(A5, I5, g4, C2, Q3, E3, i3, o3), B2._crypto_box_open_easy_afternm = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_box_open_easy_afternm = m2.ya)(A5, I5, g4, C2, Q3, E3), B2._crypto_box_open_easy = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_box_open_easy = m2.za)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_box_seal = (A5, I5, g4, C2, Q3) => (B2._crypto_box_seal = m2.Aa)(A5, I5, g4, C2, Q3), B2._crypto_box_seal_open = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_box_seal_open = m2.Ba)(A5, I5, g4, C2, Q3, E3), B2._crypto_box_sealbytes = () => (B2._crypto_box_sealbytes = m2.Ca)(), B2._crypto_generichash_bytes_min = () => (B2._crypto_generichash_bytes_min = m2.Da)(), B2._crypto_generichash_bytes_max = () => (B2._crypto_generichash_bytes_max = m2.Ea)(), B2._crypto_generichash_bytes = () => (B2._crypto_generichash_bytes = m2.Fa)(), B2._crypto_generichash_keybytes_min = () => (B2._crypto_generichash_keybytes_min = m2.Ga)(), B2._crypto_generichash_keybytes_max = () => (B2._crypto_generichash_keybytes_max = m2.Ha)(), B2._crypto_generichash_keybytes = () => (B2._crypto_generichash_keybytes = m2.Ia)(), B2._crypto_generichash_statebytes = () => (B2._crypto_generichash_statebytes = m2.Ja)(), B2._crypto_generichash = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_generichash = m2.Ka)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_generichash_init = (A5, I5, g4, C2) => (B2._crypto_generichash_init = m2.La)(A5, I5, g4, C2), B2._crypto_generichash_update = (A5, I5, g4, C2) => (B2._crypto_generichash_update = m2.Ma)(A5, I5, g4, C2), B2._crypto_generichash_final = (A5, I5, g4) => (B2._crypto_generichash_final = m2.Na)(A5, I5, g4), B2._crypto_generichash_keygen = (A5) => (B2._crypto_generichash_keygen = m2.Oa)(A5), B2._crypto_hash_bytes = () => (B2._crypto_hash_bytes = m2.Pa)(), B2._crypto_hash = (A5, I5, g4, C2) => (B2._crypto_hash = m2.Qa)(A5, I5, g4, C2), B2._crypto_kdf_bytes_min = () => (B2._crypto_kdf_bytes_min = m2.Ra)(), B2._crypto_kdf_bytes_max = () => (B2._crypto_kdf_bytes_max = m2.Sa)(), B2._crypto_kdf_contextbytes = () => (B2._crypto_kdf_contextbytes = m2.Ta)(), B2._crypto_kdf_keybytes = () => (B2._crypto_kdf_keybytes = m2.Ua)(), B2._crypto_kdf_derive_from_key = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_kdf_derive_from_key = m2.Va)(A5, I5, g4, C2, Q3, E3), B2._crypto_kdf_keygen = (A5) => (B2._crypto_kdf_keygen = m2.Wa)(A5), B2._crypto_kdf_hkdf_sha256_extract_init = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha256_extract_init = m2.Xa)(A5, I5, g4), B2._crypto_kdf_hkdf_sha256_extract_update = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha256_extract_update = m2.Ya)(A5, I5, g4), B2._crypto_kdf_hkdf_sha256_extract_final = (A5, I5) => (B2._crypto_kdf_hkdf_sha256_extract_final = m2.Za)(A5, I5), B2._crypto_kdf_hkdf_sha256_extract = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha256_extract = m2._a)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha256_keygen = (A5) => (B2._crypto_kdf_hkdf_sha256_keygen = m2.$a)(A5), B2._crypto_kdf_hkdf_sha256_expand = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha256_expand = m2.ab)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha256_keybytes = () => (B2._crypto_kdf_hkdf_sha256_keybytes = m2.bb)(), B2._crypto_kdf_hkdf_sha256_bytes_min = () => (B2._crypto_kdf_hkdf_sha256_bytes_min = m2.cb)(), B2._crypto_kdf_hkdf_sha256_bytes_max = () => (B2._crypto_kdf_hkdf_sha256_bytes_max = m2.db)(), B2._crypto_kdf_hkdf_sha256_statebytes = () => (B2._crypto_kdf_hkdf_sha256_statebytes = m2.eb)(), B2._crypto_kdf_hkdf_sha512_extract_init = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha512_extract_init = m2.fb)(A5, I5, g4), B2._crypto_kdf_hkdf_sha512_extract_update = (A5, I5, g4) => (B2._crypto_kdf_hkdf_sha512_extract_update = m2.gb)(A5, I5, g4), B2._crypto_kdf_hkdf_sha512_extract_final = (A5, I5) => (B2._crypto_kdf_hkdf_sha512_extract_final = m2.hb)(A5, I5), B2._crypto_kdf_hkdf_sha512_extract = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha512_extract = m2.ib)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha512_keygen = (A5) => (B2._crypto_kdf_hkdf_sha512_keygen = m2.jb)(A5), B2._crypto_kdf_hkdf_sha512_expand = (A5, I5, g4, C2, Q3) => (B2._crypto_kdf_hkdf_sha512_expand = m2.kb)(A5, I5, g4, C2, Q3), B2._crypto_kdf_hkdf_sha512_keybytes = () => (B2._crypto_kdf_hkdf_sha512_keybytes = m2.lb)(), B2._crypto_kdf_hkdf_sha512_bytes_min = () => (B2._crypto_kdf_hkdf_sha512_bytes_min = m2.mb)(), B2._crypto_kdf_hkdf_sha512_bytes_max = () => (B2._crypto_kdf_hkdf_sha512_bytes_max = m2.nb)(), B2._crypto_kdf_hkdf_sha512_statebytes = () => (B2._crypto_kdf_hkdf_sha512_statebytes = m2.ob)(), B2._crypto_kx_seed_keypair = (A5, I5, g4) => (B2._crypto_kx_seed_keypair = m2.pb)(A5, I5, g4), B2._crypto_kx_keypair = (A5, I5) => (B2._crypto_kx_keypair = m2.qb)(A5, I5), B2._crypto_kx_client_session_keys = (A5, I5, g4, C2, Q3) => (B2._crypto_kx_client_session_keys = m2.rb)(A5, I5, g4, C2, Q3), B2._crypto_kx_server_session_keys = (A5, I5, g4, C2, Q3) => (B2._crypto_kx_server_session_keys = m2.sb)(A5, I5, g4, C2, Q3), B2._crypto_kx_publickeybytes = () => (B2._crypto_kx_publickeybytes = m2.tb)(), B2._crypto_kx_secretkeybytes = () => (B2._crypto_kx_secretkeybytes = m2.ub)(), B2._crypto_kx_seedbytes = () => (B2._crypto_kx_seedbytes = m2.vb)(), B2._crypto_kx_sessionkeybytes = () => (B2._crypto_kx_sessionkeybytes = m2.wb)(), B2._crypto_scalarmult_base = (A5, I5) => (B2._crypto_scalarmult_base = m2.xb)(A5, I5), B2._crypto_scalarmult = (A5, I5, g4) => (B2._crypto_scalarmult = m2.yb)(A5, I5, g4), B2._crypto_scalarmult_bytes = () => (B2._crypto_scalarmult_bytes = m2.zb)(), B2._crypto_scalarmult_scalarbytes = () => (B2._crypto_scalarmult_scalarbytes = m2.Ab)(), B2._crypto_secretbox_keybytes = () => (B2._crypto_secretbox_keybytes = m2.Bb)(), B2._crypto_secretbox_noncebytes = () => (B2._crypto_secretbox_noncebytes = m2.Cb)(), B2._crypto_secretbox_macbytes = () => (B2._crypto_secretbox_macbytes = m2.Db)(), B2._crypto_secretbox_messagebytes_max = () => (B2._crypto_secretbox_messagebytes_max = m2.Eb)(), B2._crypto_secretbox_keygen = (A5) => (B2._crypto_secretbox_keygen = m2.Fb)(A5), B2._crypto_secretbox_detached = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_secretbox_detached = m2.Gb)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_secretbox_easy = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_secretbox_easy = m2.Hb)(A5, I5, g4, C2, Q3, E3), B2._crypto_secretbox_open_detached = (A5, I5, g4, C2, Q3, E3, i3) => (B2._crypto_secretbox_open_detached = m2.Ib)(A5, I5, g4, C2, Q3, E3, i3), B2._crypto_secretbox_open_easy = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_secretbox_open_easy = m2.Jb)(A5, I5, g4, C2, Q3, E3), B2._crypto_secretstream_xchacha20poly1305_keygen = (A5) => (B2._crypto_secretstream_xchacha20poly1305_keygen = m2.Kb)(A5), B2._crypto_secretstream_xchacha20poly1305_init_push = (A5, I5, g4) => (B2._crypto_secretstream_xchacha20poly1305_init_push = m2.Lb)(A5, I5, g4), B2._crypto_secretstream_xchacha20poly1305_init_pull = (A5, I5, g4) => (B2._crypto_secretstream_xchacha20poly1305_init_pull = m2.Mb)(A5, I5, g4), B2._crypto_secretstream_xchacha20poly1305_rekey = (A5) => (B2._crypto_secretstream_xchacha20poly1305_rekey = m2.Nb)(A5), B2._crypto_secretstream_xchacha20poly1305_push = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3) => (B2._crypto_secretstream_xchacha20poly1305_push = m2.Ob)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3), B2._crypto_secretstream_xchacha20poly1305_pull = (A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3) => (B2._crypto_secretstream_xchacha20poly1305_pull = m2.Pb)(A5, I5, g4, C2, Q3, E3, i3, o3, c3, D3), B2._crypto_secretstream_xchacha20poly1305_statebytes = () => (B2._crypto_secretstream_xchacha20poly1305_statebytes = m2.Qb)(), B2._crypto_secretstream_xchacha20poly1305_abytes = () => (B2._crypto_secretstream_xchacha20poly1305_abytes = m2.Rb)(), B2._crypto_secretstream_xchacha20poly1305_headerbytes = () => (B2._crypto_secretstream_xchacha20poly1305_headerbytes = m2.Sb)(), B2._crypto_secretstream_xchacha20poly1305_keybytes = () => (B2._crypto_secretstream_xchacha20poly1305_keybytes = m2.Tb)(), B2._crypto_secretstream_xchacha20poly1305_messagebytes_max = () => (B2._crypto_secretstream_xchacha20poly1305_messagebytes_max = m2.Ub)(), B2._crypto_secretstream_xchacha20poly1305_tag_message = () => (B2._crypto_secretstream_xchacha20poly1305_tag_message = m2.Vb)(), B2._crypto_secretstream_xchacha20poly1305_tag_push = () => (B2._crypto_secretstream_xchacha20poly1305_tag_push = m2.Wb)(), B2._crypto_secretstream_xchacha20poly1305_tag_rekey = () => (B2._crypto_secretstream_xchacha20poly1305_tag_rekey = m2.Xb)(), B2._crypto_secretstream_xchacha20poly1305_tag_final = () => (B2._crypto_secretstream_xchacha20poly1305_tag_final = m2.Yb)(), B2._crypto_shorthash_bytes = () => (B2._crypto_shorthash_bytes = m2.Zb)(), B2._crypto_shorthash_keybytes = () => (B2._crypto_shorthash_keybytes = m2._b)(), B2._crypto_shorthash = (A5, I5, g4, C2, Q3) => (B2._crypto_shorthash = m2.$b)(A5, I5, g4, C2, Q3), B2._crypto_shorthash_keygen = (A5) => (B2._crypto_shorthash_keygen = m2.ac)(A5), B2._crypto_sign_statebytes = () => (B2._crypto_sign_statebytes = m2.bc)(), B2._crypto_sign_bytes = () => (B2._crypto_sign_bytes = m2.cc)(), B2._crypto_sign_seedbytes = () => (B2._crypto_sign_seedbytes = m2.dc)(), B2._crypto_sign_publickeybytes = () => (B2._crypto_sign_publickeybytes = m2.ec)(), B2._crypto_sign_secretkeybytes = () => (B2._crypto_sign_secretkeybytes = m2.fc)(), B2._crypto_sign_messagebytes_max = () => (B2._crypto_sign_messagebytes_max = m2.gc)(), B2._crypto_sign_seed_keypair = (A5, I5, g4) => (B2._crypto_sign_seed_keypair = m2.hc)(A5, I5, g4), B2._crypto_sign_keypair = (A5, I5) => (B2._crypto_sign_keypair = m2.ic)(A5, I5), B2._crypto_sign = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_sign = m2.jc)(A5, I5, g4, C2, Q3, E3), B2._crypto_sign_open = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_sign_open = m2.kc)(A5, I5, g4, C2, Q3, E3), B2._crypto_sign_detached = (A5, I5, g4, C2, Q3, E3) => (B2._crypto_sign_detached = m2.lc)(A5, I5, g4, C2, Q3, E3), B2._crypto_sign_verify_detached = (A5, I5, g4, C2, Q3) => (B2._crypto_sign_verify_detached = m2.mc)(A5, I5, g4, C2, Q3), B2._crypto_sign_init = (A5) => (B2._crypto_sign_init = m2.nc)(A5), B2._crypto_sign_update = (A5, I5, g4, C2) => (B2._crypto_sign_update = m2.oc)(A5, I5, g4, C2), B2._crypto_sign_final_create = (A5, I5, g4, C2) => (B2._crypto_sign_final_create = m2.pc)(A5, I5, g4, C2), B2._crypto_sign_final_verify = (A5, I5, g4) => (B2._crypto_sign_final_verify = m2.qc)(A5, I5, g4), B2._crypto_sign_ed25519_pk_to_curve25519 = (A5, I5) => (B2._crypto_sign_ed25519_pk_to_curve25519 = m2.rc)(A5, I5), B2._crypto_sign_ed25519_sk_to_curve25519 = (A5, I5) => (B2._crypto_sign_ed25519_sk_to_curve25519 = m2.sc)(A5, I5), B2._randombytes_random = () => (B2._randombytes_random = m2.tc)(), B2._randombytes_stir = () => (B2._randombytes_stir = m2.uc)(), B2._randombytes_uniform = (A5) => (B2._randombytes_uniform = m2.vc)(A5), B2._randombytes_buf = (A5, I5) => (B2._randombytes_buf = m2.wc)(A5, I5), B2._randombytes_buf_deterministic = (A5, I5, g4) => (B2._randombytes_buf_deterministic = m2.xc)(A5, I5, g4), B2._randombytes_seedbytes = () => (B2._randombytes_seedbytes = m2.yc)(), B2._randombytes_close = () => (B2._randombytes_close = m2.zc)(), B2._randombytes = (A5, I5, g4) => (B2._randombytes = m2.Ac)(A5, I5, g4), B2._sodium_bin2hex = (A5, I5, g4, C2) => (B2._sodium_bin2hex = m2.Bc)(A5, I5, g4, C2), B2._sodium_hex2bin = (A5, I5, g4, C2, Q3, E3, i3) => (B2._sodium_hex2bin = m2.Cc)(A5, I5, g4, C2, Q3, E3, i3), B2._sodium_base64_encoded_len = (A5, I5) => (B2._sodium_base64_encoded_len = m2.Dc)(A5, I5), B2._sodium_bin2base64 = (A5, I5, g4, C2, Q3) => (B2._sodium_bin2base64 = m2.Ec)(A5, I5, g4, C2, Q3), B2._sodium_base642bin = (A5, I5, g4, C2, Q3, E3, i3, o3) => (B2._sodium_base642bin = m2.Fc)(A5, I5, g4, C2, Q3, E3, i3, o3), B2._sodium_init = () => (B2._sodium_init = m2.Gc)(), B2._sodium_pad = (A5, I5, g4, C2, Q3) => (B2._sodium_pad = m2.Hc)(A5, I5, g4, C2, Q3), B2._sodium_unpad = (A5, I5, g4, C2) => (B2._sodium_unpad = m2.Ic)(A5, I5, g4, C2), B2._sodium_version_string = () => (B2._sodium_version_string = m2.Jc)(), B2._sodium_library_version_major = () => (B2._sodium_library_version_major = m2.Kc)(), B2._sodium_library_version_minor = () => (B2._sodium_library_version_minor = m2.Lc)(), B2._sodium_library_minimal = () => (B2._sodium_library_minimal = m2.Mc)(), B2._malloc = (A5) => (B2._malloc = m2.Nc)(A5), B2._free = (A5) => (B2._free = m2.Oc)(A5), B2.setValue = function(A5, I5, g4 = "i8") { + switch (g4.endsWith("*") && (g4 = "*"), g4) { + case "i1": + case "i8": + r2[A5] = I5; + break; + case "i16": + h2[A5 >> 1] = I5; + break; + case "i32": + k2[A5 >> 2] = I5; + break; + case "i64": + J2("to do setValue(i64) use WASM_BIGINT"); + case "float": + s2[A5 >> 2] = I5; + break; + case "double": + F2[A5 >> 3] = I5; + break; + case "*": + n2[A5 >> 2] = I5; + break; + default: + J2(`invalid type for setValue: ${g4}`); + } + }, B2.getValue = function(A5, I5 = "i8") { + switch (I5.endsWith("*") && (I5 = "*"), I5) { + case "i1": + case "i8": + return r2[A5]; + case "i16": + return h2[A5 >> 1]; + case "i32": + return k2[A5 >> 2]; + case "i64": + J2("to do getValue(i64) use WASM_BIGINT"); + case "float": + return s2[A5 >> 2]; + case "double": + return F2[A5 >> 3]; + case "*": + return n2[A5 >> 2]; + default: + J2(`invalid type for getValue: ${I5}`); + } + }, B2.UTF8ToString = R2, G2 = function A5() { + P2 || q2(), P2 || (G2 = A5); + }, B2.preInit) for ("function" == typeof B2.preInit && (B2.preInit = [B2.preInit]); B2.preInit.length > 0; ) B2.preInit.pop()(); + q2(); + }); + }; + var g2, B = void 0 !== B ? B : {}, Q = "object" == typeof window, E = "function" == typeof importScripts, i = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, o = Object.assign({}, B), c = ""; + if (i) { + var D = require("fs"), a = require("path"); + c = __dirname + "/", g2 = (A4) => (A4 = U(A4) ? new URL(A4) : a.normalize(A4), D.readFileSync(A4)), !B.thisProgram && process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2), "undefined" != typeof module2 && (module2.exports = B); + } else (Q || E) && (E ? c = self.location.href : "undefined" != typeof document && document.currentScript && (c = document.currentScript.src), c = c.startsWith("blob:") ? "" : c.substr(0, c.replace(/[?#].*/, "").lastIndexOf("/") + 1), E && (g2 = (A4) => { + var I4 = new XMLHttpRequest(); + return I4.open("GET", A4, false), I4.responseType = "arraybuffer", I4.send(null), new Uint8Array(I4.response); + })); + B.print; + var y, f, e = B.printErr || void 0; + Object.assign(B, o), o = null, B.arguments && B.arguments, B.thisProgram && B.thisProgram, B.quit && B.quit, B.wasmBinary && (y = B.wasmBinary); + var w, r, t, h, k, n, s, F = false; + function S() { + var A4 = f.buffer; + B.HEAP8 = w = new Int8Array(A4), B.HEAP16 = t = new Int16Array(A4), B.HEAPU8 = r = new Uint8Array(A4), B.HEAPU16 = new Uint16Array(A4), B.HEAP32 = h = new Int32Array(A4), B.HEAPU32 = k = new Uint32Array(A4), B.HEAPF32 = n = new Float32Array(A4), B.HEAPF64 = s = new Float64Array(A4); + } + var M = [], N = [], K = [], _ = 0, p = null, H = null; + function G(A4) { + throw B.onAbort?.(A4), e(A4 = "Aborted(" + A4 + ")"), F = true, A4 += ". Build with -sASSERTIONS for more info.", new WebAssembly.RuntimeError(A4); + } + var J, Y = "data:application/octet-stream;base64,", U = (A4) => A4.startsWith("file://"); + function d(A4) { + return Promise.resolve().then(() => function(A5) { + if (A5 == J && y) return new Uint8Array(y); + var I4 = function(A6) { + if (((A7) => A7.startsWith(Y))(A6)) return function(A7) { + if (void 0 !== i && i) { + var I5 = Buffer.from(A7, "base64"); + return new Uint8Array(I5.buffer, I5.byteOffset, I5.length); + } + for (var g3 = atob(A7), C2 = new Uint8Array(g3.length), B2 = 0; B2 < g3.length; ++B2) C2[B2] = g3.charCodeAt(B2); + return C2; + }(A6.slice(37)); + }(A5); + if (I4) return I4; + if (g2) return g2(A5); + throw "both async and sync fetching of the wasm failed"; + }(A4)); + } + var b = { 36304: () => B.getRandomValue(), 36340: () => { + if (void 0 === B.getRandomValue) try { + var A4 = "object" == typeof window ? window : self, I4 = void 0 !== A4.crypto ? A4.crypto : A4.msCrypto; + I4 = void 0 === I4 ? C2 : I4; + var g3 = function() { + var A5 = new Uint32Array(1); + return I4.getRandomValues(A5), A5[0] >>> 0; + }; + g3(), B.getRandomValue = g3; + } catch (A5) { + try { + var C2 = require("crypto"), Q2 = function() { + var A6 = C2.randomBytes(4); + return (A6[0] << 24 | A6[1] << 16 | A6[2] << 8 | A6[3]) >>> 0; + }; + Q2(), B.getRandomValue = Q2; + } catch (A6) { + throw "No secure random number generator found"; + } + } + } }, P = (A4) => { + for (; A4.length > 0; ) A4.shift()(B); + }; + B.noExitRuntime; + var v, R = "undefined" != typeof TextDecoder ? new TextDecoder() : void 0, L = (A4, I4) => A4 ? ((A5, I5, g3) => { + for (var C2 = I5 + g3, B2 = I5; A5[B2] && !(B2 >= C2); ) ++B2; + if (B2 - I5 > 16 && A5.buffer && R) return R.decode(A5.subarray(I5, B2)); + for (var Q2 = ""; I5 < B2; ) { + var E2 = A5[I5++]; + if (128 & E2) { + var i2 = 63 & A5[I5++]; + if (192 != (224 & E2)) { + var o2 = 63 & A5[I5++]; + if ((E2 = 224 == (240 & E2) ? (15 & E2) << 12 | i2 << 6 | o2 : (7 & E2) << 18 | i2 << 12 | o2 << 6 | 63 & A5[I5++]) < 65536) Q2 += String.fromCharCode(E2); + else { + var c2 = E2 - 65536; + Q2 += String.fromCharCode(55296 | c2 >> 10, 56320 | 1023 & c2); + } + } else Q2 += String.fromCharCode((31 & E2) << 6 | i2); + } else Q2 += String.fromCharCode(E2); + } + return Q2; + })(r, A4, I4) : "", x = [], u = (A4) => { + var I4 = (A4 - f.buffer.byteLength + 65535) / 65536; + try { + return f.grow(I4), S(), 1; + } catch (A5) { + } + }, m = { b: (A4, I4, g3, C2) => { + G(`Assertion failed: ${L(A4)}, at: ` + [I4 ? L(I4) : "unknown filename", g3, C2 ? L(C2) : "unknown function"]); + }, c: () => { + G(""); + }, d: (A4, I4, g3) => r.copyWithin(A4, I4, I4 + g3), a: (A4, I4, g3) => ((A5, I5, g4) => { + var C2 = ((A6, I6) => { + var g5; + for (x.length = 0; g5 = r[A6++]; ) { + var C3 = 105 != g5; + I6 += (C3 &= 112 != g5) && I6 % 8 ? 4 : 0, x.push(112 == g5 ? k[I6 >> 2] : 105 == g5 ? h[I6 >> 2] : s[I6 >> 3]), I6 += C3 ? 8 : 4; + } + return x; + })(I5, g4); + return b[A5](...C2); + })(A4, I4, g3), e: (A4) => { + var I4 = r.length, g3 = 2147483648; + if ((A4 >>>= 0) > g3) return false; + for (var C2, B2 = 1; B2 <= 4; B2 *= 2) { + var Q2 = I4 * (1 + 0.2 / B2); + Q2 = Math.min(Q2, A4 + 100663296); + var E2 = Math.min(g3, (C2 = Math.max(A4, Q2)) + (65536 - C2 % 65536) % 65536); + if (u(E2)) return true; + } + return false; + } }, q = function() { + var A4, I4 = { a: m }; + function g3(A5, I5) { + return q = A5.exports, f = q.f, S(), function(A6) { + if (_--, B.monitorRunDependencies?.(_), 0 == _ && (null !== p && (clearInterval(p), p = null), H)) { + var I6 = H; + H = null, I6(); + } + }(), q; + } + if (_++, B.monitorRunDependencies?.(_), B.instantiateWasm) try { + return B.instantiateWasm(I4, g3); + } catch (A5) { + return e(`Module.instantiateWasm callback failed with error: ${A5}`), false; + } + return J || (J = "data:application/octet-stream;base64,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"), A4 = I4, d(J).then((I5) => WebAssembly.instantiate(I5, A4)).then(function(A5) { + g3(A5.instance); + }, (A5) => { + e(`failed to asynchronously prepare wasm: ${A5}`), G(A5); + }), {}; + }(); + function l() { + function A4() { + v || (v = true, B.calledRun = true, F || (P(N), B.onRuntimeInitialized?.(), function() { + if (B.postRun) for ("function" == typeof B.postRun && (B.postRun = [B.postRun]); B.postRun.length; ) A5 = B.postRun.shift(), K.unshift(A5); + var A5; + P(K); + }())); + } + _ > 0 || (function() { + if (B.preRun) for ("function" == typeof B.preRun && (B.preRun = [B.preRun]); B.preRun.length; ) A5 = B.preRun.shift(), M.unshift(A5); + var A5; + P(M); + }(), _ > 0 || (B.setStatus ? (B.setStatus("Running..."), setTimeout(function() { + setTimeout(function() { + B.setStatus(""); + }, 1), A4(); + }, 1)) : A4())); + } + if (B._crypto_aead_aegis128l_keybytes = () => (B._crypto_aead_aegis128l_keybytes = q.g)(), B._crypto_aead_aegis128l_nsecbytes = () => (B._crypto_aead_aegis128l_nsecbytes = q.h)(), B._crypto_aead_aegis128l_npubbytes = () => (B._crypto_aead_aegis128l_npubbytes = q.i)(), B._crypto_aead_aegis128l_abytes = () => (B._crypto_aead_aegis128l_abytes = q.j)(), B._crypto_aead_aegis128l_messagebytes_max = () => (B._crypto_aead_aegis128l_messagebytes_max = q.k)(), B._crypto_aead_aegis128l_keygen = (A4) => (B._crypto_aead_aegis128l_keygen = q.l)(A4), B._crypto_aead_aegis128l_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis128l_encrypt = q.m)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis128l_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_aegis128l_encrypt_detached = q.n)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_aegis128l_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis128l_decrypt = q.o)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis128l_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis128l_decrypt_detached = q.p)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis256_keybytes = () => (B._crypto_aead_aegis256_keybytes = q.q)(), B._crypto_aead_aegis256_nsecbytes = () => (B._crypto_aead_aegis256_nsecbytes = q.r)(), B._crypto_aead_aegis256_npubbytes = () => (B._crypto_aead_aegis256_npubbytes = q.s)(), B._crypto_aead_aegis256_abytes = () => (B._crypto_aead_aegis256_abytes = q.t)(), B._crypto_aead_aegis256_messagebytes_max = () => (B._crypto_aead_aegis256_messagebytes_max = q.u)(), B._crypto_aead_aegis256_keygen = (A4) => (B._crypto_aead_aegis256_keygen = q.v)(A4), B._crypto_aead_aegis256_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis256_encrypt = q.w)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis256_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_aegis256_encrypt_detached = q.x)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_aegis256_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis256_decrypt = q.y)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aegis256_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_aegis256_decrypt_detached = q.z)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_aes256gcm_is_available = () => (B._crypto_aead_aes256gcm_is_available = q.A)(), B._crypto_aead_chacha20poly1305_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_chacha20poly1305_encrypt_detached = q.B)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_chacha20poly1305_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_encrypt = q.C)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_chacha20poly1305_ietf_encrypt_detached = q.D)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_chacha20poly1305_ietf_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_ietf_encrypt = q.E)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_decrypt_detached = q.F)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_decrypt = q.G)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_ietf_decrypt_detached = q.H)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_chacha20poly1305_ietf_decrypt = q.I)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_chacha20poly1305_ietf_keybytes = () => (B._crypto_aead_chacha20poly1305_ietf_keybytes = q.J)(), B._crypto_aead_chacha20poly1305_ietf_npubbytes = () => (B._crypto_aead_chacha20poly1305_ietf_npubbytes = q.K)(), B._crypto_aead_chacha20poly1305_ietf_nsecbytes = () => (B._crypto_aead_chacha20poly1305_ietf_nsecbytes = q.L)(), B._crypto_aead_chacha20poly1305_ietf_abytes = () => (B._crypto_aead_chacha20poly1305_ietf_abytes = q.M)(), B._crypto_aead_chacha20poly1305_ietf_messagebytes_max = () => (B._crypto_aead_chacha20poly1305_ietf_messagebytes_max = q.N)(), B._crypto_aead_chacha20poly1305_ietf_keygen = (A4) => (B._crypto_aead_chacha20poly1305_ietf_keygen = q.O)(A4), B._crypto_aead_chacha20poly1305_keybytes = () => (B._crypto_aead_chacha20poly1305_keybytes = q.P)(), B._crypto_aead_chacha20poly1305_npubbytes = () => (B._crypto_aead_chacha20poly1305_npubbytes = q.Q)(), B._crypto_aead_chacha20poly1305_nsecbytes = () => (B._crypto_aead_chacha20poly1305_nsecbytes = q.R)(), B._crypto_aead_chacha20poly1305_abytes = () => (B._crypto_aead_chacha20poly1305_abytes = q.S)(), B._crypto_aead_chacha20poly1305_messagebytes_max = () => (B._crypto_aead_chacha20poly1305_messagebytes_max = q.T)(), B._crypto_aead_chacha20poly1305_keygen = (A4) => (B._crypto_aead_chacha20poly1305_keygen = q.U)(A4), B._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2) => (B._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = q.V)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2, y2), B._crypto_aead_xchacha20poly1305_ietf_encrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_xchacha20poly1305_ietf_encrypt = q.W)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = q.X)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_xchacha20poly1305_ietf_decrypt = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2) => (B._crypto_aead_xchacha20poly1305_ietf_decrypt = q.Y)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2, a2), B._crypto_aead_xchacha20poly1305_ietf_keybytes = () => (B._crypto_aead_xchacha20poly1305_ietf_keybytes = q.Z)(), B._crypto_aead_xchacha20poly1305_ietf_npubbytes = () => (B._crypto_aead_xchacha20poly1305_ietf_npubbytes = q._)(), B._crypto_aead_xchacha20poly1305_ietf_nsecbytes = () => (B._crypto_aead_xchacha20poly1305_ietf_nsecbytes = q.$)(), B._crypto_aead_xchacha20poly1305_ietf_abytes = () => (B._crypto_aead_xchacha20poly1305_ietf_abytes = q.aa)(), B._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = () => (B._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = q.ba)(), B._crypto_aead_xchacha20poly1305_ietf_keygen = (A4) => (B._crypto_aead_xchacha20poly1305_ietf_keygen = q.ca)(A4), B._crypto_auth_bytes = () => (B._crypto_auth_bytes = q.da)(), B._crypto_auth_keybytes = () => (B._crypto_auth_keybytes = q.ea)(), B._crypto_auth = (A4, I4, g3, C2, Q2) => (B._crypto_auth = q.fa)(A4, I4, g3, C2, Q2), B._crypto_auth_verify = (A4, I4, g3, C2, Q2) => (B._crypto_auth_verify = q.ga)(A4, I4, g3, C2, Q2), B._crypto_auth_keygen = (A4) => (B._crypto_auth_keygen = q.ha)(A4), B._crypto_box_seedbytes = () => (B._crypto_box_seedbytes = q.ia)(), B._crypto_box_publickeybytes = () => (B._crypto_box_publickeybytes = q.ja)(), B._crypto_box_secretkeybytes = () => (B._crypto_box_secretkeybytes = q.ka)(), B._crypto_box_beforenmbytes = () => (B._crypto_box_beforenmbytes = q.la)(), B._crypto_box_noncebytes = () => (B._crypto_box_noncebytes = q.ma)(), B._crypto_box_macbytes = () => (B._crypto_box_macbytes = q.na)(), B._crypto_box_messagebytes_max = () => (B._crypto_box_messagebytes_max = q.oa)(), B._crypto_box_seed_keypair = (A4, I4, g3) => (B._crypto_box_seed_keypair = q.pa)(A4, I4, g3), B._crypto_box_keypair = (A4, I4) => (B._crypto_box_keypair = q.qa)(A4, I4), B._crypto_box_beforenm = (A4, I4, g3) => (B._crypto_box_beforenm = q.ra)(A4, I4, g3), B._crypto_box_detached_afternm = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_detached_afternm = q.sa)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_detached = (A4, I4, g3, C2, Q2, E2, i2, o2) => (B._crypto_box_detached = q.ta)(A4, I4, g3, C2, Q2, E2, i2, o2), B._crypto_box_easy_afternm = (A4, I4, g3, C2, Q2, E2) => (B._crypto_box_easy_afternm = q.ua)(A4, I4, g3, C2, Q2, E2), B._crypto_box_easy = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_easy = q.va)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_open_detached_afternm = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_open_detached_afternm = q.wa)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_open_detached = (A4, I4, g3, C2, Q2, E2, i2, o2) => (B._crypto_box_open_detached = q.xa)(A4, I4, g3, C2, Q2, E2, i2, o2), B._crypto_box_open_easy_afternm = (A4, I4, g3, C2, Q2, E2) => (B._crypto_box_open_easy_afternm = q.ya)(A4, I4, g3, C2, Q2, E2), B._crypto_box_open_easy = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_box_open_easy = q.za)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_box_seal = (A4, I4, g3, C2, Q2) => (B._crypto_box_seal = q.Aa)(A4, I4, g3, C2, Q2), B._crypto_box_seal_open = (A4, I4, g3, C2, Q2, E2) => (B._crypto_box_seal_open = q.Ba)(A4, I4, g3, C2, Q2, E2), B._crypto_box_sealbytes = () => (B._crypto_box_sealbytes = q.Ca)(), B._crypto_generichash_bytes_min = () => (B._crypto_generichash_bytes_min = q.Da)(), B._crypto_generichash_bytes_max = () => (B._crypto_generichash_bytes_max = q.Ea)(), B._crypto_generichash_bytes = () => (B._crypto_generichash_bytes = q.Fa)(), B._crypto_generichash_keybytes_min = () => (B._crypto_generichash_keybytes_min = q.Ga)(), B._crypto_generichash_keybytes_max = () => (B._crypto_generichash_keybytes_max = q.Ha)(), B._crypto_generichash_keybytes = () => (B._crypto_generichash_keybytes = q.Ia)(), B._crypto_generichash_statebytes = () => (B._crypto_generichash_statebytes = q.Ja)(), B._crypto_generichash = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_generichash = q.Ka)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_generichash_init = (A4, I4, g3, C2) => (B._crypto_generichash_init = q.La)(A4, I4, g3, C2), B._crypto_generichash_update = (A4, I4, g3, C2) => (B._crypto_generichash_update = q.Ma)(A4, I4, g3, C2), B._crypto_generichash_final = (A4, I4, g3) => (B._crypto_generichash_final = q.Na)(A4, I4, g3), B._crypto_generichash_keygen = (A4) => (B._crypto_generichash_keygen = q.Oa)(A4), B._crypto_hash_bytes = () => (B._crypto_hash_bytes = q.Pa)(), B._crypto_hash = (A4, I4, g3, C2) => (B._crypto_hash = q.Qa)(A4, I4, g3, C2), B._crypto_kdf_bytes_min = () => (B._crypto_kdf_bytes_min = q.Ra)(), B._crypto_kdf_bytes_max = () => (B._crypto_kdf_bytes_max = q.Sa)(), B._crypto_kdf_contextbytes = () => (B._crypto_kdf_contextbytes = q.Ta)(), B._crypto_kdf_keybytes = () => (B._crypto_kdf_keybytes = q.Ua)(), B._crypto_kdf_derive_from_key = (A4, I4, g3, C2, Q2, E2) => (B._crypto_kdf_derive_from_key = q.Va)(A4, I4, g3, C2, Q2, E2), B._crypto_kdf_keygen = (A4) => (B._crypto_kdf_keygen = q.Wa)(A4), B._crypto_kdf_hkdf_sha256_extract_init = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha256_extract_init = q.Xa)(A4, I4, g3), B._crypto_kdf_hkdf_sha256_extract_update = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha256_extract_update = q.Ya)(A4, I4, g3), B._crypto_kdf_hkdf_sha256_extract_final = (A4, I4) => (B._crypto_kdf_hkdf_sha256_extract_final = q.Za)(A4, I4), B._crypto_kdf_hkdf_sha256_extract = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha256_extract = q._a)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha256_keygen = (A4) => (B._crypto_kdf_hkdf_sha256_keygen = q.$a)(A4), B._crypto_kdf_hkdf_sha256_expand = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha256_expand = q.ab)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha256_keybytes = () => (B._crypto_kdf_hkdf_sha256_keybytes = q.bb)(), B._crypto_kdf_hkdf_sha256_bytes_min = () => (B._crypto_kdf_hkdf_sha256_bytes_min = q.cb)(), B._crypto_kdf_hkdf_sha256_bytes_max = () => (B._crypto_kdf_hkdf_sha256_bytes_max = q.db)(), B._crypto_kdf_hkdf_sha256_statebytes = () => (B._crypto_kdf_hkdf_sha256_statebytes = q.eb)(), B._crypto_kdf_hkdf_sha512_extract_init = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha512_extract_init = q.fb)(A4, I4, g3), B._crypto_kdf_hkdf_sha512_extract_update = (A4, I4, g3) => (B._crypto_kdf_hkdf_sha512_extract_update = q.gb)(A4, I4, g3), B._crypto_kdf_hkdf_sha512_extract_final = (A4, I4) => (B._crypto_kdf_hkdf_sha512_extract_final = q.hb)(A4, I4), B._crypto_kdf_hkdf_sha512_extract = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha512_extract = q.ib)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha512_keygen = (A4) => (B._crypto_kdf_hkdf_sha512_keygen = q.jb)(A4), B._crypto_kdf_hkdf_sha512_expand = (A4, I4, g3, C2, Q2) => (B._crypto_kdf_hkdf_sha512_expand = q.kb)(A4, I4, g3, C2, Q2), B._crypto_kdf_hkdf_sha512_keybytes = () => (B._crypto_kdf_hkdf_sha512_keybytes = q.lb)(), B._crypto_kdf_hkdf_sha512_bytes_min = () => (B._crypto_kdf_hkdf_sha512_bytes_min = q.mb)(), B._crypto_kdf_hkdf_sha512_bytes_max = () => (B._crypto_kdf_hkdf_sha512_bytes_max = q.nb)(), B._crypto_kdf_hkdf_sha512_statebytes = () => (B._crypto_kdf_hkdf_sha512_statebytes = q.ob)(), B._crypto_kx_seed_keypair = (A4, I4, g3) => (B._crypto_kx_seed_keypair = q.pb)(A4, I4, g3), B._crypto_kx_keypair = (A4, I4) => (B._crypto_kx_keypair = q.qb)(A4, I4), B._crypto_kx_client_session_keys = (A4, I4, g3, C2, Q2) => (B._crypto_kx_client_session_keys = q.rb)(A4, I4, g3, C2, Q2), B._crypto_kx_server_session_keys = (A4, I4, g3, C2, Q2) => (B._crypto_kx_server_session_keys = q.sb)(A4, I4, g3, C2, Q2), B._crypto_kx_publickeybytes = () => (B._crypto_kx_publickeybytes = q.tb)(), B._crypto_kx_secretkeybytes = () => (B._crypto_kx_secretkeybytes = q.ub)(), B._crypto_kx_seedbytes = () => (B._crypto_kx_seedbytes = q.vb)(), B._crypto_kx_sessionkeybytes = () => (B._crypto_kx_sessionkeybytes = q.wb)(), B._crypto_scalarmult_base = (A4, I4) => (B._crypto_scalarmult_base = q.xb)(A4, I4), B._crypto_scalarmult = (A4, I4, g3) => (B._crypto_scalarmult = q.yb)(A4, I4, g3), B._crypto_scalarmult_bytes = () => (B._crypto_scalarmult_bytes = q.zb)(), B._crypto_scalarmult_scalarbytes = () => (B._crypto_scalarmult_scalarbytes = q.Ab)(), B._crypto_secretbox_keybytes = () => (B._crypto_secretbox_keybytes = q.Bb)(), B._crypto_secretbox_noncebytes = () => (B._crypto_secretbox_noncebytes = q.Cb)(), B._crypto_secretbox_macbytes = () => (B._crypto_secretbox_macbytes = q.Db)(), B._crypto_secretbox_messagebytes_max = () => (B._crypto_secretbox_messagebytes_max = q.Eb)(), B._crypto_secretbox_keygen = (A4) => (B._crypto_secretbox_keygen = q.Fb)(A4), B._crypto_secretbox_detached = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_secretbox_detached = q.Gb)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_secretbox_easy = (A4, I4, g3, C2, Q2, E2) => (B._crypto_secretbox_easy = q.Hb)(A4, I4, g3, C2, Q2, E2), B._crypto_secretbox_open_detached = (A4, I4, g3, C2, Q2, E2, i2) => (B._crypto_secretbox_open_detached = q.Ib)(A4, I4, g3, C2, Q2, E2, i2), B._crypto_secretbox_open_easy = (A4, I4, g3, C2, Q2, E2) => (B._crypto_secretbox_open_easy = q.Jb)(A4, I4, g3, C2, Q2, E2), B._crypto_secretstream_xchacha20poly1305_keygen = (A4) => (B._crypto_secretstream_xchacha20poly1305_keygen = q.Kb)(A4), B._crypto_secretstream_xchacha20poly1305_init_push = (A4, I4, g3) => (B._crypto_secretstream_xchacha20poly1305_init_push = q.Lb)(A4, I4, g3), B._crypto_secretstream_xchacha20poly1305_init_pull = (A4, I4, g3) => (B._crypto_secretstream_xchacha20poly1305_init_pull = q.Mb)(A4, I4, g3), B._crypto_secretstream_xchacha20poly1305_rekey = (A4) => (B._crypto_secretstream_xchacha20poly1305_rekey = q.Nb)(A4), B._crypto_secretstream_xchacha20poly1305_push = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2) => (B._crypto_secretstream_xchacha20poly1305_push = q.Ob)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2), B._crypto_secretstream_xchacha20poly1305_pull = (A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2) => (B._crypto_secretstream_xchacha20poly1305_pull = q.Pb)(A4, I4, g3, C2, Q2, E2, i2, o2, c2, D2), B._crypto_secretstream_xchacha20poly1305_statebytes = () => (B._crypto_secretstream_xchacha20poly1305_statebytes = q.Qb)(), B._crypto_secretstream_xchacha20poly1305_abytes = () => (B._crypto_secretstream_xchacha20poly1305_abytes = q.Rb)(), B._crypto_secretstream_xchacha20poly1305_headerbytes = () => (B._crypto_secretstream_xchacha20poly1305_headerbytes = q.Sb)(), B._crypto_secretstream_xchacha20poly1305_keybytes = () => (B._crypto_secretstream_xchacha20poly1305_keybytes = q.Tb)(), B._crypto_secretstream_xchacha20poly1305_messagebytes_max = () => (B._crypto_secretstream_xchacha20poly1305_messagebytes_max = q.Ub)(), B._crypto_secretstream_xchacha20poly1305_tag_message = () => (B._crypto_secretstream_xchacha20poly1305_tag_message = q.Vb)(), B._crypto_secretstream_xchacha20poly1305_tag_push = () => (B._crypto_secretstream_xchacha20poly1305_tag_push = q.Wb)(), B._crypto_secretstream_xchacha20poly1305_tag_rekey = () => (B._crypto_secretstream_xchacha20poly1305_tag_rekey = q.Xb)(), B._crypto_secretstream_xchacha20poly1305_tag_final = () => (B._crypto_secretstream_xchacha20poly1305_tag_final = q.Yb)(), B._crypto_shorthash_bytes = () => (B._crypto_shorthash_bytes = q.Zb)(), B._crypto_shorthash_keybytes = () => (B._crypto_shorthash_keybytes = q._b)(), B._crypto_shorthash = (A4, I4, g3, C2, Q2) => (B._crypto_shorthash = q.$b)(A4, I4, g3, C2, Q2), B._crypto_shorthash_keygen = (A4) => (B._crypto_shorthash_keygen = q.ac)(A4), B._crypto_sign_statebytes = () => (B._crypto_sign_statebytes = q.bc)(), B._crypto_sign_bytes = () => (B._crypto_sign_bytes = q.cc)(), B._crypto_sign_seedbytes = () => (B._crypto_sign_seedbytes = q.dc)(), B._crypto_sign_publickeybytes = () => (B._crypto_sign_publickeybytes = q.ec)(), B._crypto_sign_secretkeybytes = () => (B._crypto_sign_secretkeybytes = q.fc)(), B._crypto_sign_messagebytes_max = () => (B._crypto_sign_messagebytes_max = q.gc)(), B._crypto_sign_seed_keypair = (A4, I4, g3) => (B._crypto_sign_seed_keypair = q.hc)(A4, I4, g3), B._crypto_sign_keypair = (A4, I4) => (B._crypto_sign_keypair = q.ic)(A4, I4), B._crypto_sign = (A4, I4, g3, C2, Q2, E2) => (B._crypto_sign = q.jc)(A4, I4, g3, C2, Q2, E2), B._crypto_sign_open = (A4, I4, g3, C2, Q2, E2) => (B._crypto_sign_open = q.kc)(A4, I4, g3, C2, Q2, E2), B._crypto_sign_detached = (A4, I4, g3, C2, Q2, E2) => (B._crypto_sign_detached = q.lc)(A4, I4, g3, C2, Q2, E2), B._crypto_sign_verify_detached = (A4, I4, g3, C2, Q2) => (B._crypto_sign_verify_detached = q.mc)(A4, I4, g3, C2, Q2), B._crypto_sign_init = (A4) => (B._crypto_sign_init = q.nc)(A4), B._crypto_sign_update = (A4, I4, g3, C2) => (B._crypto_sign_update = q.oc)(A4, I4, g3, C2), B._crypto_sign_final_create = (A4, I4, g3, C2) => (B._crypto_sign_final_create = q.pc)(A4, I4, g3, C2), B._crypto_sign_final_verify = (A4, I4, g3) => (B._crypto_sign_final_verify = q.qc)(A4, I4, g3), B._crypto_sign_ed25519_pk_to_curve25519 = (A4, I4) => (B._crypto_sign_ed25519_pk_to_curve25519 = q.rc)(A4, I4), B._crypto_sign_ed25519_sk_to_curve25519 = (A4, I4) => (B._crypto_sign_ed25519_sk_to_curve25519 = q.sc)(A4, I4), B._randombytes_random = () => (B._randombytes_random = q.tc)(), B._randombytes_stir = () => (B._randombytes_stir = q.uc)(), B._randombytes_uniform = (A4) => (B._randombytes_uniform = q.vc)(A4), B._randombytes_buf = (A4, I4) => (B._randombytes_buf = q.wc)(A4, I4), B._randombytes_buf_deterministic = (A4, I4, g3) => (B._randombytes_buf_deterministic = q.xc)(A4, I4, g3), B._randombytes_seedbytes = () => (B._randombytes_seedbytes = q.yc)(), B._randombytes_close = () => (B._randombytes_close = q.zc)(), B._randombytes = (A4, I4, g3) => (B._randombytes = q.Ac)(A4, I4, g3), B._sodium_bin2hex = (A4, I4, g3, C2) => (B._sodium_bin2hex = q.Bc)(A4, I4, g3, C2), B._sodium_hex2bin = (A4, I4, g3, C2, Q2, E2, i2) => (B._sodium_hex2bin = q.Cc)(A4, I4, g3, C2, Q2, E2, i2), B._sodium_base64_encoded_len = (A4, I4) => (B._sodium_base64_encoded_len = q.Dc)(A4, I4), B._sodium_bin2base64 = (A4, I4, g3, C2, Q2) => (B._sodium_bin2base64 = q.Ec)(A4, I4, g3, C2, Q2), B._sodium_base642bin = (A4, I4, g3, C2, Q2, E2, i2, o2) => (B._sodium_base642bin = q.Fc)(A4, I4, g3, C2, Q2, E2, i2, o2), B._sodium_init = () => (B._sodium_init = q.Gc)(), B._sodium_pad = (A4, I4, g3, C2, Q2) => (B._sodium_pad = q.Hc)(A4, I4, g3, C2, Q2), B._sodium_unpad = (A4, I4, g3, C2) => (B._sodium_unpad = q.Ic)(A4, I4, g3, C2), B._sodium_version_string = () => (B._sodium_version_string = q.Jc)(), B._sodium_library_version_major = () => (B._sodium_library_version_major = q.Kc)(), B._sodium_library_version_minor = () => (B._sodium_library_version_minor = q.Lc)(), B._sodium_library_minimal = () => (B._sodium_library_minimal = q.Mc)(), B._malloc = (A4) => (B._malloc = q.Nc)(A4), B._free = (A4) => (B._free = q.Oc)(A4), B.setValue = function(A4, I4, g3 = "i8") { + switch (g3.endsWith("*") && (g3 = "*"), g3) { + case "i1": + case "i8": + w[A4] = I4; + break; + case "i16": + t[A4 >> 1] = I4; + break; + case "i32": + h[A4 >> 2] = I4; + break; + case "i64": + G("to do setValue(i64) use WASM_BIGINT"); + case "float": + n[A4 >> 2] = I4; + break; + case "double": + s[A4 >> 3] = I4; + break; + case "*": + k[A4 >> 2] = I4; + break; + default: + G(`invalid type for setValue: ${g3}`); + } + }, B.getValue = function(A4, I4 = "i8") { + switch (I4.endsWith("*") && (I4 = "*"), I4) { + case "i1": + case "i8": + return w[A4]; + case "i16": + return t[A4 >> 1]; + case "i32": + return h[A4 >> 2]; + case "i64": + G("to do getValue(i64) use WASM_BIGINT"); + case "float": + return n[A4 >> 2]; + case "double": + return s[A4 >> 3]; + case "*": + return k[A4 >> 2]; + default: + G(`invalid type for getValue: ${I4}`); + } + }, B.UTF8ToString = L, H = function A4() { + v || l(), v || (H = A4); + }, B.preInit) for ("function" == typeof B.preInit && (B.preInit = [B.preInit]); B.preInit.length > 0; ) B.preInit.pop()(); + l(); + }).catch(function() { + return C.useBackupModule(); + }), I2; + } + "function" == typeof define && define.amd ? define(["exports"], I) : "object" == typeof exports2 && "string" != typeof exports2.nodeName ? I(exports2) : A.libsodium = I(A.libsodium_mod || (A.commonJsStrict = {})); + }(exports2); + } +}); + +// node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js +var require_libsodium_wrappers = __commonJS({ + "node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js"(exports2) { + !function(e) { + function a(e2, a2) { + "use strict"; + var r2, t = "uint8array", _ = a2.ready.then(function() { + function t2() { + if (0 !== r2._sodium_init()) throw new Error("libsodium was not correctly initialized."); + for (var a3 = ["crypto_aead_aegis128l_decrypt", "crypto_aead_aegis128l_decrypt_detached", "crypto_aead_aegis128l_encrypt", "crypto_aead_aegis128l_encrypt_detached", "crypto_aead_aegis128l_keygen", "crypto_aead_aegis256_decrypt", "crypto_aead_aegis256_decrypt_detached", "crypto_aead_aegis256_encrypt", "crypto_aead_aegis256_encrypt_detached", "crypto_aead_aegis256_keygen", "crypto_aead_chacha20poly1305_decrypt", "crypto_aead_chacha20poly1305_decrypt_detached", "crypto_aead_chacha20poly1305_encrypt", "crypto_aead_chacha20poly1305_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_decrypt", "crypto_aead_chacha20poly1305_ietf_decrypt_detached", "crypto_aead_chacha20poly1305_ietf_encrypt", "crypto_aead_chacha20poly1305_ietf_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_keygen", "crypto_aead_chacha20poly1305_keygen", "crypto_aead_xchacha20poly1305_ietf_decrypt", "crypto_aead_xchacha20poly1305_ietf_decrypt_detached", "crypto_aead_xchacha20poly1305_ietf_encrypt", "crypto_aead_xchacha20poly1305_ietf_encrypt_detached", "crypto_aead_xchacha20poly1305_ietf_keygen", "crypto_auth", "crypto_auth_hmacsha256", "crypto_auth_hmacsha256_final", "crypto_auth_hmacsha256_init", "crypto_auth_hmacsha256_keygen", "crypto_auth_hmacsha256_update", "crypto_auth_hmacsha256_verify", "crypto_auth_hmacsha512", "crypto_auth_hmacsha512256", "crypto_auth_hmacsha512256_final", "crypto_auth_hmacsha512256_init", "crypto_auth_hmacsha512256_keygen", "crypto_auth_hmacsha512256_update", "crypto_auth_hmacsha512256_verify", "crypto_auth_hmacsha512_final", "crypto_auth_hmacsha512_init", "crypto_auth_hmacsha512_keygen", "crypto_auth_hmacsha512_update", "crypto_auth_hmacsha512_verify", "crypto_auth_keygen", "crypto_auth_verify", "crypto_box_beforenm", "crypto_box_curve25519xchacha20poly1305_beforenm", "crypto_box_curve25519xchacha20poly1305_detached", "crypto_box_curve25519xchacha20poly1305_detached_afternm", "crypto_box_curve25519xchacha20poly1305_easy", "crypto_box_curve25519xchacha20poly1305_easy_afternm", "crypto_box_curve25519xchacha20poly1305_keypair", "crypto_box_curve25519xchacha20poly1305_open_detached", "crypto_box_curve25519xchacha20poly1305_open_detached_afternm", "crypto_box_curve25519xchacha20poly1305_open_easy", "crypto_box_curve25519xchacha20poly1305_open_easy_afternm", "crypto_box_curve25519xchacha20poly1305_seal", "crypto_box_curve25519xchacha20poly1305_seal_open", "crypto_box_curve25519xchacha20poly1305_seed_keypair", "crypto_box_detached", "crypto_box_easy", "crypto_box_easy_afternm", "crypto_box_keypair", "crypto_box_open_detached", "crypto_box_open_easy", "crypto_box_open_easy_afternm", "crypto_box_seal", "crypto_box_seal_open", "crypto_box_seed_keypair", "crypto_core_ed25519_add", "crypto_core_ed25519_from_hash", "crypto_core_ed25519_from_uniform", "crypto_core_ed25519_is_valid_point", "crypto_core_ed25519_random", "crypto_core_ed25519_scalar_add", "crypto_core_ed25519_scalar_complement", "crypto_core_ed25519_scalar_invert", "crypto_core_ed25519_scalar_mul", "crypto_core_ed25519_scalar_negate", "crypto_core_ed25519_scalar_random", "crypto_core_ed25519_scalar_reduce", "crypto_core_ed25519_scalar_sub", "crypto_core_ed25519_sub", "crypto_core_hchacha20", "crypto_core_hsalsa20", "crypto_core_ristretto255_add", "crypto_core_ristretto255_from_hash", "crypto_core_ristretto255_is_valid_point", "crypto_core_ristretto255_random", "crypto_core_ristretto255_scalar_add", "crypto_core_ristretto255_scalar_complement", "crypto_core_ristretto255_scalar_invert", "crypto_core_ristretto255_scalar_mul", "crypto_core_ristretto255_scalar_negate", "crypto_core_ristretto255_scalar_random", "crypto_core_ristretto255_scalar_reduce", "crypto_core_ristretto255_scalar_sub", "crypto_core_ristretto255_sub", "crypto_generichash", "crypto_generichash_blake2b_salt_personal", "crypto_generichash_final", "crypto_generichash_init", "crypto_generichash_keygen", "crypto_generichash_update", "crypto_hash", "crypto_hash_sha256", "crypto_hash_sha256_final", "crypto_hash_sha256_init", "crypto_hash_sha256_update", "crypto_hash_sha512", "crypto_hash_sha512_final", "crypto_hash_sha512_init", "crypto_hash_sha512_update", "crypto_kdf_derive_from_key", "crypto_kdf_keygen", "crypto_kx_client_session_keys", "crypto_kx_keypair", "crypto_kx_seed_keypair", "crypto_kx_server_session_keys", "crypto_onetimeauth", "crypto_onetimeauth_final", "crypto_onetimeauth_init", "crypto_onetimeauth_keygen", "crypto_onetimeauth_update", "crypto_onetimeauth_verify", "crypto_pwhash", "crypto_pwhash_scryptsalsa208sha256", "crypto_pwhash_scryptsalsa208sha256_ll", "crypto_pwhash_scryptsalsa208sha256_str", "crypto_pwhash_scryptsalsa208sha256_str_verify", "crypto_pwhash_str", "crypto_pwhash_str_needs_rehash", "crypto_pwhash_str_verify", "crypto_scalarmult", "crypto_scalarmult_base", "crypto_scalarmult_ed25519", "crypto_scalarmult_ed25519_base", "crypto_scalarmult_ed25519_base_noclamp", "crypto_scalarmult_ed25519_noclamp", "crypto_scalarmult_ristretto255", "crypto_scalarmult_ristretto255_base", "crypto_secretbox_detached", "crypto_secretbox_easy", "crypto_secretbox_keygen", "crypto_secretbox_open_detached", "crypto_secretbox_open_easy", "crypto_secretstream_xchacha20poly1305_init_pull", "crypto_secretstream_xchacha20poly1305_init_push", "crypto_secretstream_xchacha20poly1305_keygen", "crypto_secretstream_xchacha20poly1305_pull", "crypto_secretstream_xchacha20poly1305_push", "crypto_secretstream_xchacha20poly1305_rekey", "crypto_shorthash", "crypto_shorthash_keygen", "crypto_shorthash_siphashx24", "crypto_sign", "crypto_sign_detached", "crypto_sign_ed25519_pk_to_curve25519", "crypto_sign_ed25519_sk_to_curve25519", "crypto_sign_ed25519_sk_to_pk", "crypto_sign_ed25519_sk_to_seed", "crypto_sign_final_create", "crypto_sign_final_verify", "crypto_sign_init", "crypto_sign_keypair", "crypto_sign_open", "crypto_sign_seed_keypair", "crypto_sign_update", "crypto_sign_verify_detached", "crypto_stream_chacha20", "crypto_stream_chacha20_ietf_xor", "crypto_stream_chacha20_ietf_xor_ic", "crypto_stream_chacha20_keygen", "crypto_stream_chacha20_xor", "crypto_stream_chacha20_xor_ic", "crypto_stream_keygen", "crypto_stream_xchacha20_keygen", "crypto_stream_xchacha20_xor", "crypto_stream_xchacha20_xor_ic", "randombytes_buf", "randombytes_buf_deterministic", "randombytes_close", "randombytes_random", "randombytes_set_implementation", "randombytes_stir", "randombytes_uniform", "sodium_version_string"], t3 = [x, k, S, T, w, Y, B, A, M, I, K, N, L, O, U, C, P, R, X, G, D, F, V, H, W, q, j, z, J, Q, Z, $, ee, ae, re, te, _e, ne, se, ce, he, oe, pe, ye, ie, le, ue, de, ve, ge, be, fe, me, Ee, xe, ke, Se, Te, we, Ye, Be, Ae, Me, Ie, Ke, Ne, Le, Oe, Ue, Ce, Pe, Re, Xe, Ge, De, Fe, Ve, He, We, qe, je, ze, Je, Qe, Ze, $e, ea, aa, ra, ta, _a2, na, sa, ca, ha, oa, pa, ya, ia, la, ua, da, va, ga, ba, fa, ma, Ea, xa, ka, Sa, Ta, wa, Ya, Ba, Aa, Ma, Ia, Ka, Na, La, Oa, Ua, Ca, Pa, Ra, Xa, Ga, Da, Fa, Va, Ha, Wa, qa, ja, za, Ja, Qa, Za, $a, er, ar, rr, tr, _r, nr, sr, cr, hr, or, pr, yr, ir, lr, ur, dr, vr, gr, br, fr, mr, Er, xr, kr, Sr, Tr, wr, Yr, Br, Ar, Mr, Ir, Kr, Nr, Lr, Or, Ur, Cr, Pr, Rr, Xr, Gr, Dr, Fr, Vr, Hr, Wr, qr], _3 = 0; _3 < t3.length; _3++) "function" == typeof r2["_" + a3[_3]] && (e2[a3[_3]] = t3[_3]); + var n3 = ["SODIUM_LIBRARY_VERSION_MAJOR", "SODIUM_LIBRARY_VERSION_MINOR", "crypto_aead_aegis128l_ABYTES", "crypto_aead_aegis128l_KEYBYTES", "crypto_aead_aegis128l_MESSAGEBYTES_MAX", "crypto_aead_aegis128l_NPUBBYTES", "crypto_aead_aegis128l_NSECBYTES", "crypto_aead_aegis256_ABYTES", "crypto_aead_aegis256_KEYBYTES", "crypto_aead_aegis256_MESSAGEBYTES_MAX", "crypto_aead_aegis256_NPUBBYTES", "crypto_aead_aegis256_NSECBYTES", "crypto_aead_aes256gcm_ABYTES", "crypto_aead_aes256gcm_KEYBYTES", "crypto_aead_aes256gcm_MESSAGEBYTES_MAX", "crypto_aead_aes256gcm_NPUBBYTES", "crypto_aead_aes256gcm_NSECBYTES", "crypto_aead_chacha20poly1305_ABYTES", "crypto_aead_chacha20poly1305_IETF_ABYTES", "crypto_aead_chacha20poly1305_IETF_KEYBYTES", "crypto_aead_chacha20poly1305_IETF_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_IETF_NPUBBYTES", "crypto_aead_chacha20poly1305_IETF_NSECBYTES", "crypto_aead_chacha20poly1305_KEYBYTES", "crypto_aead_chacha20poly1305_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_NPUBBYTES", "crypto_aead_chacha20poly1305_NSECBYTES", "crypto_aead_chacha20poly1305_ietf_ABYTES", "crypto_aead_chacha20poly1305_ietf_KEYBYTES", "crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_ietf_NPUBBYTES", "crypto_aead_chacha20poly1305_ietf_NSECBYTES", "crypto_aead_xchacha20poly1305_IETF_ABYTES", "crypto_aead_xchacha20poly1305_IETF_KEYBYTES", "crypto_aead_xchacha20poly1305_IETF_MESSAGEBYTES_MAX", "crypto_aead_xchacha20poly1305_IETF_NPUBBYTES", "crypto_aead_xchacha20poly1305_IETF_NSECBYTES", "crypto_aead_xchacha20poly1305_ietf_ABYTES", "crypto_aead_xchacha20poly1305_ietf_KEYBYTES", "crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_xchacha20poly1305_ietf_NPUBBYTES", "crypto_aead_xchacha20poly1305_ietf_NSECBYTES", "crypto_auth_BYTES", "crypto_auth_KEYBYTES", "crypto_auth_hmacsha256_BYTES", "crypto_auth_hmacsha256_KEYBYTES", "crypto_auth_hmacsha512256_BYTES", "crypto_auth_hmacsha512256_KEYBYTES", "crypto_auth_hmacsha512_BYTES", "crypto_auth_hmacsha512_KEYBYTES", "crypto_box_BEFORENMBYTES", "crypto_box_MACBYTES", "crypto_box_MESSAGEBYTES_MAX", "crypto_box_NONCEBYTES", "crypto_box_PUBLICKEYBYTES", "crypto_box_SEALBYTES", "crypto_box_SECRETKEYBYTES", "crypto_box_SEEDBYTES", "crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES", "crypto_box_curve25519xchacha20poly1305_MACBYTES", "crypto_box_curve25519xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_box_curve25519xchacha20poly1305_NONCEBYTES", "crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES", "crypto_box_curve25519xchacha20poly1305_SEALBYTES", "crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES", "crypto_box_curve25519xchacha20poly1305_SEEDBYTES", "crypto_box_curve25519xsalsa20poly1305_BEFORENMBYTES", "crypto_box_curve25519xsalsa20poly1305_MACBYTES", "crypto_box_curve25519xsalsa20poly1305_MESSAGEBYTES_MAX", "crypto_box_curve25519xsalsa20poly1305_NONCEBYTES", "crypto_box_curve25519xsalsa20poly1305_PUBLICKEYBYTES", "crypto_box_curve25519xsalsa20poly1305_SECRETKEYBYTES", "crypto_box_curve25519xsalsa20poly1305_SEEDBYTES", "crypto_core_ed25519_BYTES", "crypto_core_ed25519_HASHBYTES", "crypto_core_ed25519_NONREDUCEDSCALARBYTES", "crypto_core_ed25519_SCALARBYTES", "crypto_core_ed25519_UNIFORMBYTES", "crypto_core_hchacha20_CONSTBYTES", "crypto_core_hchacha20_INPUTBYTES", "crypto_core_hchacha20_KEYBYTES", "crypto_core_hchacha20_OUTPUTBYTES", "crypto_core_hsalsa20_CONSTBYTES", "crypto_core_hsalsa20_INPUTBYTES", "crypto_core_hsalsa20_KEYBYTES", "crypto_core_hsalsa20_OUTPUTBYTES", "crypto_core_ristretto255_BYTES", "crypto_core_ristretto255_HASHBYTES", "crypto_core_ristretto255_NONREDUCEDSCALARBYTES", "crypto_core_ristretto255_SCALARBYTES", "crypto_core_salsa2012_CONSTBYTES", "crypto_core_salsa2012_INPUTBYTES", "crypto_core_salsa2012_KEYBYTES", "crypto_core_salsa2012_OUTPUTBYTES", "crypto_core_salsa208_CONSTBYTES", "crypto_core_salsa208_INPUTBYTES", "crypto_core_salsa208_KEYBYTES", "crypto_core_salsa208_OUTPUTBYTES", "crypto_core_salsa20_CONSTBYTES", "crypto_core_salsa20_INPUTBYTES", "crypto_core_salsa20_KEYBYTES", "crypto_core_salsa20_OUTPUTBYTES", "crypto_generichash_BYTES", "crypto_generichash_BYTES_MAX", "crypto_generichash_BYTES_MIN", "crypto_generichash_KEYBYTES", "crypto_generichash_KEYBYTES_MAX", "crypto_generichash_KEYBYTES_MIN", "crypto_generichash_blake2b_BYTES", "crypto_generichash_blake2b_BYTES_MAX", "crypto_generichash_blake2b_BYTES_MIN", "crypto_generichash_blake2b_KEYBYTES", "crypto_generichash_blake2b_KEYBYTES_MAX", "crypto_generichash_blake2b_KEYBYTES_MIN", "crypto_generichash_blake2b_PERSONALBYTES", "crypto_generichash_blake2b_SALTBYTES", "crypto_hash_BYTES", "crypto_hash_sha256_BYTES", "crypto_hash_sha512_BYTES", "crypto_kdf_BYTES_MAX", "crypto_kdf_BYTES_MIN", "crypto_kdf_CONTEXTBYTES", "crypto_kdf_KEYBYTES", "crypto_kdf_blake2b_BYTES_MAX", "crypto_kdf_blake2b_BYTES_MIN", "crypto_kdf_blake2b_CONTEXTBYTES", "crypto_kdf_blake2b_KEYBYTES", "crypto_kdf_hkdf_sha256_BYTES_MAX", "crypto_kdf_hkdf_sha256_BYTES_MIN", "crypto_kdf_hkdf_sha256_KEYBYTES", "crypto_kdf_hkdf_sha512_BYTES_MAX", "crypto_kdf_hkdf_sha512_BYTES_MIN", "crypto_kdf_hkdf_sha512_KEYBYTES", "crypto_kx_PUBLICKEYBYTES", "crypto_kx_SECRETKEYBYTES", "crypto_kx_SEEDBYTES", "crypto_kx_SESSIONKEYBYTES", "crypto_onetimeauth_BYTES", "crypto_onetimeauth_KEYBYTES", "crypto_onetimeauth_poly1305_BYTES", "crypto_onetimeauth_poly1305_KEYBYTES", "crypto_pwhash_ALG_ARGON2I13", "crypto_pwhash_ALG_ARGON2ID13", "crypto_pwhash_ALG_DEFAULT", "crypto_pwhash_BYTES_MAX", "crypto_pwhash_BYTES_MIN", "crypto_pwhash_MEMLIMIT_INTERACTIVE", "crypto_pwhash_MEMLIMIT_MAX", "crypto_pwhash_MEMLIMIT_MIN", "crypto_pwhash_MEMLIMIT_MODERATE", "crypto_pwhash_MEMLIMIT_SENSITIVE", "crypto_pwhash_OPSLIMIT_INTERACTIVE", "crypto_pwhash_OPSLIMIT_MAX", "crypto_pwhash_OPSLIMIT_MIN", "crypto_pwhash_OPSLIMIT_MODERATE", "crypto_pwhash_OPSLIMIT_SENSITIVE", "crypto_pwhash_PASSWD_MAX", "crypto_pwhash_PASSWD_MIN", "crypto_pwhash_SALTBYTES", "crypto_pwhash_STRBYTES", "crypto_pwhash_argon2i_BYTES_MAX", "crypto_pwhash_argon2i_BYTES_MIN", "crypto_pwhash_argon2i_MEMLIMIT_INTERACTIVE", "crypto_pwhash_argon2i_MEMLIMIT_MAX", "crypto_pwhash_argon2i_MEMLIMIT_MIN", "crypto_pwhash_argon2i_MEMLIMIT_MODERATE", "crypto_pwhash_argon2i_MEMLIMIT_SENSITIVE", "crypto_pwhash_argon2i_OPSLIMIT_INTERACTIVE", "crypto_pwhash_argon2i_OPSLIMIT_MAX", "crypto_pwhash_argon2i_OPSLIMIT_MIN", "crypto_pwhash_argon2i_OPSLIMIT_MODERATE", "crypto_pwhash_argon2i_OPSLIMIT_SENSITIVE", "crypto_pwhash_argon2i_PASSWD_MAX", "crypto_pwhash_argon2i_PASSWD_MIN", "crypto_pwhash_argon2i_SALTBYTES", "crypto_pwhash_argon2i_STRBYTES", "crypto_pwhash_argon2id_BYTES_MAX", "crypto_pwhash_argon2id_BYTES_MIN", "crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE", "crypto_pwhash_argon2id_MEMLIMIT_MAX", "crypto_pwhash_argon2id_MEMLIMIT_MIN", "crypto_pwhash_argon2id_MEMLIMIT_MODERATE", "crypto_pwhash_argon2id_MEMLIMIT_SENSITIVE", "crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE", "crypto_pwhash_argon2id_OPSLIMIT_MAX", "crypto_pwhash_argon2id_OPSLIMIT_MIN", "crypto_pwhash_argon2id_OPSLIMIT_MODERATE", "crypto_pwhash_argon2id_OPSLIMIT_SENSITIVE", "crypto_pwhash_argon2id_PASSWD_MAX", "crypto_pwhash_argon2id_PASSWD_MIN", "crypto_pwhash_argon2id_SALTBYTES", "crypto_pwhash_argon2id_STRBYTES", "crypto_pwhash_scryptsalsa208sha256_BYTES_MAX", "crypto_pwhash_scryptsalsa208sha256_BYTES_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX", "crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN", "crypto_pwhash_scryptsalsa208sha256_SALTBYTES", "crypto_pwhash_scryptsalsa208sha256_STRBYTES", "crypto_scalarmult_BYTES", "crypto_scalarmult_SCALARBYTES", "crypto_scalarmult_curve25519_BYTES", "crypto_scalarmult_curve25519_SCALARBYTES", "crypto_scalarmult_ed25519_BYTES", "crypto_scalarmult_ed25519_SCALARBYTES", "crypto_scalarmult_ristretto255_BYTES", "crypto_scalarmult_ristretto255_SCALARBYTES", "crypto_secretbox_KEYBYTES", "crypto_secretbox_MACBYTES", "crypto_secretbox_MESSAGEBYTES_MAX", "crypto_secretbox_NONCEBYTES", "crypto_secretbox_xchacha20poly1305_KEYBYTES", "crypto_secretbox_xchacha20poly1305_MACBYTES", "crypto_secretbox_xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_secretbox_xchacha20poly1305_NONCEBYTES", "crypto_secretbox_xsalsa20poly1305_KEYBYTES", "crypto_secretbox_xsalsa20poly1305_MACBYTES", "crypto_secretbox_xsalsa20poly1305_MESSAGEBYTES_MAX", "crypto_secretbox_xsalsa20poly1305_NONCEBYTES", "crypto_secretstream_xchacha20poly1305_ABYTES", "crypto_secretstream_xchacha20poly1305_HEADERBYTES", "crypto_secretstream_xchacha20poly1305_KEYBYTES", "crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_secretstream_xchacha20poly1305_TAG_FINAL", "crypto_secretstream_xchacha20poly1305_TAG_MESSAGE", "crypto_secretstream_xchacha20poly1305_TAG_PUSH", "crypto_secretstream_xchacha20poly1305_TAG_REKEY", "crypto_shorthash_BYTES", "crypto_shorthash_KEYBYTES", "crypto_shorthash_siphash24_BYTES", "crypto_shorthash_siphash24_KEYBYTES", "crypto_shorthash_siphashx24_BYTES", "crypto_shorthash_siphashx24_KEYBYTES", "crypto_sign_BYTES", "crypto_sign_MESSAGEBYTES_MAX", "crypto_sign_PUBLICKEYBYTES", "crypto_sign_SECRETKEYBYTES", "crypto_sign_SEEDBYTES", "crypto_sign_ed25519_BYTES", "crypto_sign_ed25519_MESSAGEBYTES_MAX", "crypto_sign_ed25519_PUBLICKEYBYTES", "crypto_sign_ed25519_SECRETKEYBYTES", "crypto_sign_ed25519_SEEDBYTES", "crypto_stream_KEYBYTES", "crypto_stream_MESSAGEBYTES_MAX", "crypto_stream_NONCEBYTES", "crypto_stream_chacha20_IETF_KEYBYTES", "crypto_stream_chacha20_IETF_MESSAGEBYTES_MAX", "crypto_stream_chacha20_IETF_NONCEBYTES", "crypto_stream_chacha20_KEYBYTES", "crypto_stream_chacha20_MESSAGEBYTES_MAX", "crypto_stream_chacha20_NONCEBYTES", "crypto_stream_chacha20_ietf_KEYBYTES", "crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX", "crypto_stream_chacha20_ietf_NONCEBYTES", "crypto_stream_salsa2012_KEYBYTES", "crypto_stream_salsa2012_MESSAGEBYTES_MAX", "crypto_stream_salsa2012_NONCEBYTES", "crypto_stream_salsa208_KEYBYTES", "crypto_stream_salsa208_MESSAGEBYTES_MAX", "crypto_stream_salsa208_NONCEBYTES", "crypto_stream_salsa20_KEYBYTES", "crypto_stream_salsa20_MESSAGEBYTES_MAX", "crypto_stream_salsa20_NONCEBYTES", "crypto_stream_xchacha20_KEYBYTES", "crypto_stream_xchacha20_MESSAGEBYTES_MAX", "crypto_stream_xchacha20_NONCEBYTES", "crypto_stream_xsalsa20_KEYBYTES", "crypto_stream_xsalsa20_MESSAGEBYTES_MAX", "crypto_stream_xsalsa20_NONCEBYTES", "crypto_verify_16_BYTES", "crypto_verify_32_BYTES", "crypto_verify_64_BYTES"]; + for (_3 = 0; _3 < n3.length; _3++) "function" == typeof (c3 = r2["_" + n3[_3].toLowerCase()]) && (e2[n3[_3]] = c3()); + var s3 = ["SODIUM_VERSION_STRING", "crypto_pwhash_STRPREFIX", "crypto_pwhash_argon2i_STRPREFIX", "crypto_pwhash_argon2id_STRPREFIX", "crypto_pwhash_scryptsalsa208sha256_STRPREFIX"]; + for (_3 = 0; _3 < s3.length; _3++) { + var c3; + "function" == typeof (c3 = r2["_" + s3[_3].toLowerCase()]) && (e2[s3[_3]] = r2.UTF8ToString(c3())); + } + } + r2 = a2; + try { + t2(); + var _2 = new Uint8Array([98, 97, 108, 108, 115]), n2 = e2.randombytes_buf(e2.crypto_secretbox_NONCEBYTES), s2 = e2.randombytes_buf(e2.crypto_secretbox_KEYBYTES), c2 = e2.crypto_secretbox_easy(_2, n2, s2), h2 = e2.crypto_secretbox_open_easy(c2, n2, s2); + if (e2.memcmp(_2, h2)) return; + } catch (e3) { + if (null == r2.useBackupModule) throw new Error("Both wasm and asm failed to load" + e3); + } + r2.useBackupModule(), t2(); + }); + function n(e3) { + if ("function" == typeof TextEncoder) return new TextEncoder().encode(e3); + e3 = unescape(encodeURIComponent(e3)); + for (var a3 = new Uint8Array(e3.length), r3 = 0, t2 = e3.length; r3 < t2; r3++) a3[r3] = e3.charCodeAt(r3); + return a3; + } + function s(e3) { + if ("function" == typeof TextDecoder) return new TextDecoder("utf-8", { fatal: true }).decode(e3); + var a3 = 8192, r3 = Math.ceil(e3.length / a3); + if (r3 <= 1) try { + return decodeURIComponent(escape(String.fromCharCode.apply(null, e3))); + } catch (e4) { + throw new TypeError("The encoded data was not valid."); + } + for (var t2 = "", _2 = 0, n2 = 0; n2 < r3; n2++) { + var c2 = Array.prototype.slice.call(e3, n2 * a3 + _2, (n2 + 1) * a3 + _2); + if (0 != c2.length) { + var h2, o2 = c2.length, p2 = 0; + do { + var y2 = c2[--o2]; + y2 >= 240 ? (p2 = 4, h2 = true) : y2 >= 224 ? (p2 = 3, h2 = true) : y2 >= 192 ? (p2 = 2, h2 = true) : y2 < 128 && (p2 = 1, h2 = true); + } while (!h2); + for (var i2 = p2 - (c2.length - o2), l2 = 0; l2 < i2; l2++) _2--, c2.pop(); + t2 += s(c2); + } + } + return t2; + } + function c(e3) { + e3 = E(null, e3, "input"); + for (var a3, r3, t2, _2 = "", n2 = 0; n2 < e3.length; n2++) t2 = 87 + (r3 = 15 & e3[n2]) + (r3 - 10 >> 8 & -39) << 8 | 87 + (a3 = e3[n2] >>> 4) + (a3 - 10 >> 8 & -39), _2 += String.fromCharCode(255 & t2) + String.fromCharCode(t2 >>> 8); + return _2; + } + var h = { ORIGINAL: 1, ORIGINAL_NO_PADDING: 3, URLSAFE: 5, URLSAFE_NO_PADDING: 7 }; + function o(e3) { + if (null == e3) return h.URLSAFE_NO_PADDING; + if (e3 !== h.ORIGINAL && e3 !== h.ORIGINAL_NO_PADDING && e3 !== h.URLSAFE && e3 != h.URLSAFE_NO_PADDING) throw new Error("unsupported base64 variant"); + return e3; + } + function p(e3, a3) { + a3 = o(a3), e3 = E(_2, e3, "input"); + var t2, _2 = [], n2 = 0 | Math.floor(e3.length / 3), c2 = e3.length - 3 * n2, h2 = 4 * n2 + (0 !== c2 ? 2 & a3 ? 2 + (c2 >>> 1) : 4 : 0), p2 = new u(h2 + 1), y2 = d(e3); + return _2.push(y2), _2.push(p2.address), 0 === r2._sodium_bin2base64(p2.address, p2.length, y2, e3.length, a3) && b(_2, "conversion failed"), p2.length = h2, t2 = s(p2.to_Uint8Array()), g(_2), t2; + } + function y(e3, a3) { + var r3 = a3 || t; + if (!i(r3)) throw new Error(r3 + " output format is not available"); + if (e3 instanceof u) { + if ("uint8array" === r3) return e3.to_Uint8Array(); + if ("text" === r3) return s(e3.to_Uint8Array()); + if ("hex" === r3) return c(e3.to_Uint8Array()); + if ("base64" === r3) return p(e3.to_Uint8Array(), h.URLSAFE_NO_PADDING); + throw new Error('What is output format "' + r3 + '"?'); + } + if ("object" == typeof e3) { + for (var _2 = Object.keys(e3), n2 = {}, o2 = 0; o2 < _2.length; o2++) n2[_2[o2]] = y(e3[_2[o2]], r3); + return n2; + } + if ("string" == typeof e3) return e3; + throw new TypeError("Cannot format output"); + } + function i(e3) { + for (var a3 = ["uint8array", "text", "hex", "base64"], r3 = 0; r3 < a3.length; r3++) if (a3[r3] === e3) return true; + return false; + } + function l(e3) { + if (e3) { + if ("string" != typeof e3) throw new TypeError("When defined, the output format must be a string"); + if (!i(e3)) throw new Error(e3 + " is not a supported output format"); + } + } + function u(e3) { + this.length = e3, this.address = v(e3); + } + function d(e3) { + var a3 = v(e3.length); + return r2.HEAPU8.set(e3, a3), a3; + } + function v(e3) { + var a3 = r2._malloc(e3); + if (0 === a3) throw { message: "_malloc() failed", length: e3 }; + return a3; + } + function g(e3) { + if (e3) for (var a3 = 0; a3 < e3.length; a3++) t2 = e3[a3], r2._free(t2); + var t2; + } + function b(e3, a3) { + throw g(e3), new Error(a3); + } + function f(e3, a3) { + throw g(e3), new TypeError(a3); + } + function m(e3, a3, r3) { + null == a3 && f(e3, r3 + " cannot be null or undefined"); + } + function E(e3, a3, r3) { + return m(e3, a3, r3), a3 instanceof Uint8Array ? a3 : "string" == typeof a3 ? n(a3) : void f(e3, "unsupported input type for " + r3); + } + function x(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_aegis128l_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_aegis128l_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_aegis128l_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function k(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_aegis128l_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function S(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_aegis128l_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_aegis128l_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function T(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis128l_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis128l_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_aegis128l_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_aegis128l_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function w(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_aegis128l_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_aegis128l_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Y(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_aegis256_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_aegis256_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_aegis256_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_aegis256_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function B(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_aegis256_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_aegis256_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function A(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis256_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_aegis256_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_aegis256_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function M(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_aegis256_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_aegis256_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_aegis256_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_aegis256_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function I(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_aegis256_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_aegis256_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function K(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_chacha20poly1305_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_chacha20poly1305_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_chacha20poly1305_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function N(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_chacha20poly1305_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function L(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_chacha20poly1305_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_chacha20poly1305_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function O(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_chacha20poly1305_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_chacha20poly1305_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function U(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_chacha20poly1305_ietf_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_chacha20poly1305_ietf_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_chacha20poly1305_ietf_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function C(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_chacha20poly1305_ietf_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function P(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_chacha20poly1305_ietf_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_chacha20poly1305_ietf_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function R(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_chacha20poly1305_ietf_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_chacha20poly1305_ietf_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function X(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_chacha20poly1305_ietf_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_chacha20poly1305_ietf_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function G(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_chacha20poly1305_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_chacha20poly1305_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function D(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = null; + null != e3 && (h2 = d(e3 = E(c2, e3, "secret_nonce")), e3.length, c2.push(h2)), a3 = E(c2, a3, "ciphertext"); + var o2, p2 = r2._crypto_aead_xchacha20poly1305_ietf_abytes(), i2 = a3.length; + i2 < p2 && f(c2, "ciphertext is too short"), o2 = d(a3), c2.push(o2); + var v2 = null, m2 = 0; + null != t2 && (v2 = d(t2 = E(c2, t2, "additional_data")), m2 = t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var x2, k2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + _2.length !== k2 && f(c2, "invalid public_nonce length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "key"); + var S2, T2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + n2.length !== T2 && f(c2, "invalid key length"), S2 = d(n2), c2.push(S2); + var w2 = new u(i2 - r2._crypto_aead_xchacha20poly1305_ietf_abytes() | 0), Y2 = w2.address; + if (c2.push(Y2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_decrypt(Y2, null, h2, o2, i2, 0, v2, m2, 0, x2, S2)) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "ciphertext cannot be decrypted using that key"); + } + function F(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = null; + null != e3 && (o2 = d(e3 = E(h2, e3, "secret_nonce")), e3.length, h2.push(o2)); + var p2 = d(a3 = E(h2, a3, "ciphertext")), i2 = a3.length; + h2.push(p2), t2 = E(h2, t2, "mac"); + var v2, m2 = 0 | r2._crypto_box_macbytes(); + t2.length !== m2 && f(h2, "invalid mac length"), v2 = d(t2), h2.push(v2); + var x2 = null, k2 = 0; + null != _2 && (x2 = d(_2 = E(h2, _2, "additional_data")), k2 = _2.length, h2.push(x2)), n2 = E(h2, n2, "public_nonce"); + var S2, T2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + n2.length !== T2 && f(h2, "invalid public_nonce length"), S2 = d(n2), h2.push(S2), s2 = E(h2, s2, "key"); + var w2, Y2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + s2.length !== Y2 && f(h2, "invalid key length"), w2 = d(s2), h2.push(w2); + var B2 = new u(0 | i2), A2 = B2.address; + if (h2.push(A2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_decrypt_detached(A2, o2, p2, i2, 0, v2, x2, k2, 0, S2, w2)) { + var M2 = y(B2, c2); + return g(h2), M2; + } + b(h2, "ciphertext cannot be decrypted using that key"); + } + function V(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(o2 + r2._crypto_aead_xchacha20poly1305_ietf_abytes() | 0), w2 = T2.address; + if (c2.push(w2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_encrypt(w2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var Y2 = y(T2, s2); + return g(c2), Y2; + } + b(c2, "invalid usage"); + } + function H(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "message")), o2 = e3.length; + c2.push(h2); + var p2 = null, i2 = 0; + null != a3 && (p2 = d(a3 = E(c2, a3, "additional_data")), i2 = a3.length, c2.push(p2)); + var v2 = null; + null != t2 && (v2 = d(t2 = E(c2, t2, "secret_nonce")), t2.length, c2.push(v2)), _2 = E(c2, _2, "public_nonce"); + var m2, x2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_npubbytes(); + _2.length !== x2 && f(c2, "invalid public_nonce length"), m2 = d(_2), c2.push(m2), n2 = E(c2, n2, "key"); + var k2, S2 = 0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes(); + n2.length !== S2 && f(c2, "invalid key length"), k2 = d(n2), c2.push(k2); + var T2 = new u(0 | o2), w2 = T2.address; + c2.push(w2); + var Y2 = new u(0 | r2._crypto_aead_xchacha20poly1305_ietf_abytes()), B2 = Y2.address; + if (c2.push(B2), 0 === r2._crypto_aead_xchacha20poly1305_ietf_encrypt_detached(w2, B2, null, h2, o2, 0, p2, i2, 0, v2, m2, k2)) { + var A2 = y({ ciphertext: T2, mac: Y2 }, s2); + return g(c2), A2; + } + b(c2, "invalid usage"); + } + function W(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_aead_xchacha20poly1305_ietf_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_aead_xchacha20poly1305_ietf_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function q(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function j(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_hmacsha256_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_hmacsha256_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth_hmacsha256(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function z(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_auth_hmacsha256_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_auth_hmacsha256_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function J(e3, a3) { + var t2 = []; + l(a3); + var _2 = null, n2 = 0; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), n2 = e3.length, t2.push(_2)); + var s2 = new u(208).address; + if (!(0 | r2._crypto_auth_hmacsha256_init(s2, _2, n2))) { + var c2 = s2; + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function Q(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_hmacsha256_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_hmacsha256_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Z(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_auth_hmacsha256_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function $(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_hmacsha256_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_hmacsha256_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_hmacsha256_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ee(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_hmacsha512_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_hmacsha512_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth_hmacsha512(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function ae(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_auth_hmacsha512256_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_auth_hmacsha512256_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_auth_hmacsha512256(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function re(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_auth_hmacsha512256_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_auth_hmacsha512256_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function te(e3, a3) { + var t2 = []; + l(a3); + var _2 = null, n2 = 0; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), n2 = e3.length, t2.push(_2)); + var s2 = new u(416).address; + if (!(0 | r2._crypto_auth_hmacsha512256_init(s2, _2, n2))) { + var c2 = s2; + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function _e(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_hmacsha512256_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_hmacsha512256_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function ne(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_auth_hmacsha512256_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function se(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_hmacsha512256_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_hmacsha512256_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_hmacsha512256_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ce(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_auth_hmacsha512_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_auth_hmacsha512_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function he(e3, a3) { + var t2 = []; + l(a3); + var _2 = null, n2 = 0; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), n2 = e3.length, t2.push(_2)); + var s2 = new u(416).address; + if (!(0 | r2._crypto_auth_hmacsha512_init(s2, _2, n2))) { + var c2 = s2; + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function oe(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_hmacsha512_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_hmacsha512_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function pe(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_auth_hmacsha512_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function ye(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_hmacsha512_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_hmacsha512_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_hmacsha512_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ie(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_auth_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_auth_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function le(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "tag"); + var n2, s2 = 0 | r2._crypto_auth_bytes(); + e3.length !== s2 && f(_2, "invalid tag length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_auth_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_auth_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function ue(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "publicKey"); + var n2, s2 = 0 | r2._crypto_box_publickeybytes(); + e3.length !== s2 && f(_2, "invalid publicKey length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_box_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_box_beforenmbytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_box_beforenm(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function de(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "publicKey"); + var n2, s2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + e3.length !== s2 && f(_2, "invalid publicKey length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_beforenm(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function ve(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + s2.push(S2); + var T2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes()), w2 = T2.address; + if (s2.push(w2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_detached(S2, w2, c2, h2, 0, o2, i2, m2))) { + var Y2 = y({ ciphertext: k2, mac: T2 }, n2); + return g(s2), Y2; + } + b(s2, "invalid usage"); + } + function ge(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_detached_afternm(m2, k2, s2, c2, 0, h2, p2))) { + var S2 = y({ ciphertext: v2, mac: x2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function be(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(h2 + r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_easy(S2, c2, h2, 0, o2, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "invalid usage"); + } + function fe(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 + r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function me(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes()), s2 = n2.address; + a3.push(s2), r2._crypto_box_curve25519xchacha20poly1305_keypair(_2, s2); + var c2 = y({ publicKey: t2, privateKey: n2, keyType: "curve25519" }, e3); + return g(a3), c2; + } + function Ee(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "ciphertext")), o2 = e3.length; + c2.push(h2), a3 = E(c2, a3, "mac"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes(); + a3.length !== i2 && f(c2, "invalid mac length"), p2 = d(a3), c2.push(p2), t2 = E(c2, t2, "nonce"); + var v2, m2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + t2.length !== m2 && f(c2, "invalid nonce length"), v2 = d(t2), c2.push(v2), _2 = E(c2, _2, "publicKey"); + var x2, k2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + _2.length !== k2 && f(c2, "invalid publicKey length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "privateKey"); + var S2, T2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + n2.length !== T2 && f(c2, "invalid privateKey length"), S2 = d(n2), c2.push(S2); + var w2 = new u(0 | o2), Y2 = w2.address; + if (c2.push(Y2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_detached(Y2, h2, p2, o2, 0, v2, x2, S2))) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "incorrect key pair for the given ciphertext"); + } + function xe(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "ciphertext")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "mac"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_macbytes(); + a3.length !== p2 && f(s2, "invalid mac length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "nonce"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + t2.length !== v2 && f(s2, "invalid nonce length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "sharedKey"); + var m2, x2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + _2.length !== x2 && f(s2, "invalid sharedKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_detached_afternm(S2, c2, o2, h2, 0, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "incorrect secret key for the given ciphertext"); + } + function ke(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), e3 = E(s2, e3, "ciphertext"); + var c2, h2 = r2._crypto_box_curve25519xchacha20poly1305_macbytes(), o2 = e3.length; + o2 < h2 && f(s2, "ciphertext is too short"), c2 = d(e3), s2.push(c2), a3 = E(s2, a3, "nonce"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== i2 && f(s2, "invalid nonce length"), p2 = d(a3), s2.push(p2), t2 = E(s2, t2, "publicKey"); + var v2, m2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + t2.length !== m2 && f(s2, "invalid publicKey length"), v2 = d(t2), s2.push(v2), _2 = E(s2, _2, "privateKey"); + var x2, k2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + _2.length !== k2 && f(s2, "invalid privateKey length"), x2 = d(_2), s2.push(x2); + var S2 = new u(o2 - r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), T2 = S2.address; + if (s2.push(T2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_easy(T2, c2, o2, 0, p2, v2, x2))) { + var w2 = y(S2, n2); + return g(s2), w2; + } + b(s2, "incorrect key pair for the given ciphertext"); + } + function Se(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "ciphertext")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 - r2._crypto_box_curve25519xchacha20poly1305_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_open_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "incorrect secret key for the given ciphertext"); + } + function Te(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "publicKey"); + var c2, h2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + a3.length !== h2 && f(_2, "invalid publicKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(s2 + r2._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0), p2 = o2.address; + _2.push(p2), r2._crypto_box_curve25519xchacha20poly1305_seal(p2, n2, s2, 0, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function we(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "ciphertext"); + var s2, c2 = r2._crypto_box_curve25519xchacha20poly1305_sealbytes(), h2 = e3.length; + h2 < c2 && f(n2, "ciphertext is too short"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "publicKey"); + var o2, p2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes(); + a3.length !== p2 && f(n2, "invalid publicKey length"), o2 = d(a3), n2.push(o2), t2 = E(n2, t2, "secretKey"); + var i2, v2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes(); + t2.length !== v2 && f(n2, "invalid secretKey length"), i2 = d(t2), n2.push(i2); + var b2 = new u(h2 - r2._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0), m2 = b2.address; + n2.push(m2), r2._crypto_box_curve25519xchacha20poly1305_seal_open(m2, s2, h2, 0, o2, i2); + var x2 = y(b2, _2); + return g(n2), x2; + } + function Ye(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_box_curve25519xchacha20poly1305_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_box_curve25519xchacha20poly1305_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_box_curve25519xchacha20poly1305_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "x25519" }; + return g(t2), p2; + } + b(t2, "invalid usage"); + } + function Be(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + s2.push(S2); + var T2 = new u(0 | r2._crypto_box_macbytes()), w2 = T2.address; + if (s2.push(w2), !(0 | r2._crypto_box_detached(S2, w2, c2, h2, 0, o2, i2, m2))) { + var Y2 = y({ ciphertext: k2, mac: T2 }, n2); + return g(s2), Y2; + } + b(s2, "invalid usage"); + } + function Ae(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "publicKey"); + var i2, v2 = 0 | r2._crypto_box_publickeybytes(); + t2.length !== v2 && f(s2, "invalid publicKey length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "privateKey"); + var m2, x2 = 0 | r2._crypto_box_secretkeybytes(); + _2.length !== x2 && f(s2, "invalid privateKey length"), m2 = d(_2), s2.push(m2); + var k2 = new u(h2 + r2._crypto_box_macbytes() | 0), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_box_easy(S2, c2, h2, 0, o2, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "invalid usage"); + } + function Me(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 + r2._crypto_box_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Ie(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_box_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_box_secretkeybytes()), s2 = n2.address; + if (a3.push(s2), !(0 | r2._crypto_box_keypair(_2, s2))) { + var c2 = { publicKey: y(t2, e3), privateKey: y(n2, e3), keyType: "x25519" }; + return g(a3), c2; + } + b(a3, "internal error"); + } + function Ke(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2); + var h2 = d(e3 = E(c2, e3, "ciphertext")), o2 = e3.length; + c2.push(h2), a3 = E(c2, a3, "mac"); + var p2, i2 = 0 | r2._crypto_box_macbytes(); + a3.length !== i2 && f(c2, "invalid mac length"), p2 = d(a3), c2.push(p2), t2 = E(c2, t2, "nonce"); + var v2, m2 = 0 | r2._crypto_box_noncebytes(); + t2.length !== m2 && f(c2, "invalid nonce length"), v2 = d(t2), c2.push(v2), _2 = E(c2, _2, "publicKey"); + var x2, k2 = 0 | r2._crypto_box_publickeybytes(); + _2.length !== k2 && f(c2, "invalid publicKey length"), x2 = d(_2), c2.push(x2), n2 = E(c2, n2, "privateKey"); + var S2, T2 = 0 | r2._crypto_box_secretkeybytes(); + n2.length !== T2 && f(c2, "invalid privateKey length"), S2 = d(n2), c2.push(S2); + var w2 = new u(0 | o2), Y2 = w2.address; + if (c2.push(Y2), !(0 | r2._crypto_box_open_detached(Y2, h2, p2, o2, 0, v2, x2, S2))) { + var B2 = y(w2, s2); + return g(c2), B2; + } + b(c2, "incorrect key pair for the given ciphertext"); + } + function Ne(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), e3 = E(s2, e3, "ciphertext"); + var c2, h2 = r2._crypto_box_macbytes(), o2 = e3.length; + o2 < h2 && f(s2, "ciphertext is too short"), c2 = d(e3), s2.push(c2), a3 = E(s2, a3, "nonce"); + var p2, i2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== i2 && f(s2, "invalid nonce length"), p2 = d(a3), s2.push(p2), t2 = E(s2, t2, "publicKey"); + var v2, m2 = 0 | r2._crypto_box_publickeybytes(); + t2.length !== m2 && f(s2, "invalid publicKey length"), v2 = d(t2), s2.push(v2), _2 = E(s2, _2, "privateKey"); + var x2, k2 = 0 | r2._crypto_box_secretkeybytes(); + _2.length !== k2 && f(s2, "invalid privateKey length"), x2 = d(_2), s2.push(x2); + var S2 = new u(o2 - r2._crypto_box_macbytes() | 0), T2 = S2.address; + if (s2.push(T2), !(0 | r2._crypto_box_open_easy(T2, c2, o2, 0, p2, v2, x2))) { + var w2 = y(S2, n2); + return g(s2), w2; + } + b(s2, "incorrect key pair for the given ciphertext"); + } + function Le(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "ciphertext")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_box_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "sharedKey"); + var p2, i2 = 0 | r2._crypto_box_beforenmbytes(); + t2.length !== i2 && f(n2, "invalid sharedKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 - r2._crypto_box_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_box_open_easy_afternm(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "incorrect secret key for the given ciphertext"); + } + function Oe(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "publicKey"); + var c2, h2 = 0 | r2._crypto_box_publickeybytes(); + a3.length !== h2 && f(_2, "invalid publicKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(s2 + r2._crypto_box_sealbytes() | 0), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_box_seal(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function Ue(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "ciphertext"); + var s2, c2 = r2._crypto_box_sealbytes(), h2 = e3.length; + h2 < c2 && f(n2, "ciphertext is too short"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "publicKey"); + var o2, p2 = 0 | r2._crypto_box_publickeybytes(); + a3.length !== p2 && f(n2, "invalid publicKey length"), o2 = d(a3), n2.push(o2), t2 = E(n2, t2, "privateKey"); + var i2, v2 = 0 | r2._crypto_box_secretkeybytes(); + t2.length !== v2 && f(n2, "invalid privateKey length"), i2 = d(t2), n2.push(i2); + var m2 = new u(h2 - r2._crypto_box_sealbytes() | 0), x2 = m2.address; + if (n2.push(x2), !(0 | r2._crypto_box_seal_open(x2, s2, h2, 0, o2, i2))) { + var k2 = y(m2, _2); + return g(n2), k2; + } + b(n2, "incorrect key pair for the given ciphertext"); + } + function Ce(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_box_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_box_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_box_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_box_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "x25519" }; + return g(t2), p2; + } + b(t2, "invalid usage"); + } + function Pe(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ed25519_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ed25519_add(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function Re(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "r")); + e3.length, t2.push(_2); + var n2 = new u(0 | r2._crypto_core_ed25519_bytes()), s2 = n2.address; + if (t2.push(s2), !(0 | r2._crypto_core_ed25519_from_hash(s2, _2))) { + var c2 = y(n2, a3); + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function Xe(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "r")); + e3.length, t2.push(_2); + var n2 = new u(0 | r2._crypto_core_ed25519_bytes()), s2 = n2.address; + if (t2.push(s2), !(0 | r2._crypto_core_ed25519_from_uniform(s2, _2))) { + var c2 = y(n2, a3); + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function Ge(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "repr"); + var _2, n2 = 0 | r2._crypto_core_ed25519_bytes(); + e3.length !== n2 && f(t2, "invalid repr length"), _2 = d(e3), t2.push(_2); + var s2 = 1 == (0 | r2._crypto_core_ed25519_is_valid_point(_2)); + return g(t2), s2; + } + function De(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ed25519_bytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ed25519_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Fe(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ed25519_scalar_add(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function Ve(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ed25519_scalar_complement(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function He(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_core_ed25519_scalar_invert(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid reciprocate"); + } + function We(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ed25519_scalar_mul(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function qe(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ed25519_scalar_negate(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function je(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ed25519_scalar_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function ze(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "sample"); + var _2, n2 = 0 | r2._crypto_core_ed25519_nonreducedscalarbytes(); + e3.length !== n2 && f(t2, "invalid sample length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ed25519_scalar_reduce(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function Je(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ed25519_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ed25519_scalar_sub(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function Qe(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ed25519_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ed25519_sub(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function Ze(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "input"); + var s2, c2 = 0 | r2._crypto_core_hchacha20_inputbytes(); + e3.length !== c2 && f(n2, "invalid input length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "privateKey"); + var h2, o2 = 0 | r2._crypto_core_hchacha20_keybytes(); + a3.length !== o2 && f(n2, "invalid privateKey length"), h2 = d(a3), n2.push(h2); + var p2 = null; + null != t2 && (p2 = d(t2 = E(n2, t2, "constant")), t2.length, n2.push(p2)); + var i2 = new u(0 | r2._crypto_core_hchacha20_outputbytes()), v2 = i2.address; + if (n2.push(v2), !(0 | r2._crypto_core_hchacha20(v2, s2, h2, p2))) { + var m2 = y(i2, _2); + return g(n2), m2; + } + b(n2, "invalid usage"); + } + function $e(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "input"); + var s2, c2 = 0 | r2._crypto_core_hsalsa20_inputbytes(); + e3.length !== c2 && f(n2, "invalid input length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "privateKey"); + var h2, o2 = 0 | r2._crypto_core_hsalsa20_keybytes(); + a3.length !== o2 && f(n2, "invalid privateKey length"), h2 = d(a3), n2.push(h2); + var p2 = null; + null != t2 && (p2 = d(t2 = E(n2, t2, "constant")), t2.length, n2.push(p2)); + var i2 = new u(0 | r2._crypto_core_hsalsa20_outputbytes()), v2 = i2.address; + if (n2.push(v2), !(0 | r2._crypto_core_hsalsa20(v2, s2, h2, p2))) { + var m2 = y(i2, _2); + return g(n2), m2; + } + b(n2, "invalid usage"); + } + function ea(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ristretto255_add(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function aa(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "r")); + e3.length, t2.push(_2); + var n2 = new u(0 | r2._crypto_core_ristretto255_bytes()), s2 = n2.address; + if (t2.push(s2), !(0 | r2._crypto_core_ristretto255_from_hash(s2, _2))) { + var c2 = y(n2, a3); + return g(t2), c2; + } + b(t2, "invalid usage"); + } + function ra(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "repr"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_bytes(); + e3.length !== n2 && f(t2, "invalid repr length"), _2 = d(e3), t2.push(_2); + var s2 = 1 == (0 | r2._crypto_core_ristretto255_is_valid_point(_2)); + return g(t2), s2; + } + function ta(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ristretto255_bytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ristretto255_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function _a2(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ristretto255_scalar_add(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function na(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ristretto255_scalar_complement(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function sa(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_core_ristretto255_scalar_invert(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid reciprocate"); + } + function ca(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ristretto255_scalar_mul(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function ha(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "s"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid s length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ristretto255_scalar_negate(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function oa(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), _2 = t2.address; + a3.push(_2), r2._crypto_core_ristretto255_scalar_random(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function pa(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "sample"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_nonreducedscalarbytes(); + e3.length !== n2 && f(t2, "invalid sample length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), c2 = s2.address; + t2.push(c2), r2._crypto_core_ristretto255_scalar_reduce(c2, _2); + var h2 = y(s2, a3); + return g(t2), h2; + } + function ya(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "x"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid x length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "y"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + a3.length !== h2 && f(_2, "invalid y length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_scalarbytes()), p2 = o2.address; + _2.push(p2), r2._crypto_core_ristretto255_scalar_sub(p2, n2, c2); + var i2 = y(o2, t2); + return g(_2), i2; + } + function ia(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "p"); + var n2, s2 = 0 | r2._crypto_core_ristretto255_bytes(); + e3.length !== s2 && f(_2, "invalid p length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "q"); + var c2, h2 = 0 | r2._crypto_core_ristretto255_bytes(); + a3.length !== h2 && f(_2, "invalid q length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_core_ristretto255_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_core_ristretto255_sub(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "input is an invalid element"); + } + function la(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "hash_length"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(n2, "hash_length must be an unsigned integer"); + var s2 = d(a3 = E(n2, a3, "message")), c2 = a3.length; + n2.push(s2); + var h2 = null, o2 = 0; + null != t2 && (h2 = d(t2 = E(n2, t2, "key")), o2 = t2.length, n2.push(h2)); + var p2 = new u(e3 |= 0), i2 = p2.address; + if (n2.push(i2), !(0 | r2._crypto_generichash(i2, e3, s2, c2, 0, h2, o2))) { + var v2 = y(p2, _2); + return g(n2), v2; + } + b(n2, "invalid usage"); + } + function ua(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), m(s2, e3, "subkey_len"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(s2, "subkey_len must be an unsigned integer"); + var c2 = null, h2 = 0; + null != a3 && (c2 = d(a3 = E(s2, a3, "key")), h2 = a3.length, s2.push(c2)); + var o2 = null, p2 = 0; + null != t2 && (t2 = E(s2, t2, "id"), p2 = 0 | r2._crypto_generichash_blake2b_saltbytes(), t2.length !== p2 && f(s2, "invalid id length"), o2 = d(t2), s2.push(o2)); + var i2 = null, v2 = 0; + null != _2 && (_2 = E(s2, _2, "ctx"), v2 = 0 | r2._crypto_generichash_blake2b_personalbytes(), _2.length !== v2 && f(s2, "invalid ctx length"), i2 = d(_2), s2.push(i2)); + var x2 = new u(0 | e3), k2 = x2.address; + if (s2.push(k2), !(0 | r2._crypto_generichash_blake2b_salt_personal(k2, e3, null, 0, 0, c2, h2, o2, i2))) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function da(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"), m(_2, a3, "hash_length"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(_2, "hash_length must be an unsigned integer"); + var n2 = new u(a3 |= 0), s2 = n2.address; + if (_2.push(s2), !(0 | r2._crypto_generichash_final(e3, s2, a3))) { + var c2 = (r2._free(e3), y(n2, t2)); + return g(_2), c2; + } + b(_2, "invalid usage"); + } + function va(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = null, s2 = 0; + null != e3 && (n2 = d(e3 = E(_2, e3, "key")), s2 = e3.length, _2.push(n2)), m(_2, a3, "hash_length"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(_2, "hash_length must be an unsigned integer"); + var c2 = new u(357).address; + if (!(0 | r2._crypto_generichash_init(c2, n2, s2, a3))) { + var h2 = c2; + return g(_2), h2; + } + b(_2, "invalid usage"); + } + function ga(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_generichash_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_generichash_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function ba(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_generichash_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function fa(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "message")), n2 = e3.length; + t2.push(_2); + var s2 = new u(0 | r2._crypto_hash_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_hash(c2, _2, n2, 0))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid usage"); + } + function ma(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "message")), n2 = e3.length; + t2.push(_2); + var s2 = new u(0 | r2._crypto_hash_sha256_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_hash_sha256(c2, _2, n2, 0))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid usage"); + } + function Ea(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_hash_sha256_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_hash_sha256_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function xa(e3) { + var a3 = []; + l(e3); + var t2 = new u(104).address; + if (!(0 | r2._crypto_hash_sha256_init(t2))) { + var _2 = t2; + return g(a3), _2; + } + b(a3, "invalid usage"); + } + function ka(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_hash_sha256_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function Sa(e3, a3) { + var t2 = []; + l(a3); + var _2 = d(e3 = E(t2, e3, "message")), n2 = e3.length; + t2.push(_2); + var s2 = new u(0 | r2._crypto_hash_sha512_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_hash_sha512(c2, _2, n2, 0))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid usage"); + } + function Ta(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_hash_sha512_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_hash_sha512_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function wa(e3) { + var a3 = []; + l(e3); + var t2 = new u(208).address; + if (!(0 | r2._crypto_hash_sha512_init(t2))) { + var _2 = t2; + return g(a3), _2; + } + b(a3, "invalid usage"); + } + function Ya(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_hash_sha512_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function Ba(e3, a3, t2, _2, s2) { + var c2 = []; + l(s2), m(c2, e3, "subkey_len"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(c2, "subkey_len must be an unsigned integer"), m(c2, a3, "subkey_id"); + var h2, o2 = 0; + if ("bigint" == typeof a3 && a3 >= BigInt(0)) { + const e4 = a3 >> BigInt(32); + e4 > BigInt(4294967295) && f(c2, "subkey_id cannot be more than 64 bits"), o2 = Number(e4), h2 = Number(a3 & BigInt(4294967295)); + } else "number" == typeof a3 && (0 | a3) === a3 && a3 >= 0 ? h2 = a3 : f(c2, "subkey_id must be an unsigned integer or bigint"); + "string" != typeof t2 && f(c2, "ctx must be a string"), t2 = n(t2 + "\0"), null != i2 && t2.length - 1 !== i2 && f(c2, "invalid ctx length"); + var p2 = d(t2), i2 = t2.length - 1; + c2.push(p2), _2 = E(c2, _2, "key"); + var v2, b2 = 0 | r2._crypto_kdf_keybytes(); + _2.length !== b2 && f(c2, "invalid key length"), v2 = d(_2), c2.push(v2); + var x2 = new u(0 | e3), k2 = x2.address; + c2.push(k2), r2._crypto_kdf_derive_from_key(k2, e3, h2, o2, p2, v2); + var S2 = y(x2, s2); + return g(c2), S2; + } + function Aa(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_kdf_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_kdf_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Ma(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "clientPublicKey"); + var s2, c2 = 0 | r2._crypto_kx_publickeybytes(); + e3.length !== c2 && f(n2, "invalid clientPublicKey length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "clientSecretKey"); + var h2, o2 = 0 | r2._crypto_kx_secretkeybytes(); + a3.length !== o2 && f(n2, "invalid clientSecretKey length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "serverPublicKey"); + var p2, i2 = 0 | r2._crypto_kx_publickeybytes(); + t2.length !== i2 && f(n2, "invalid serverPublicKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | r2._crypto_kx_sessionkeybytes()), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_kx_sessionkeybytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_kx_client_session_keys(m2, k2, s2, h2, p2))) { + var S2 = y({ sharedRx: v2, sharedTx: x2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function Ia(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_kx_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_kx_secretkeybytes()), s2 = n2.address; + if (a3.push(s2), !(0 | r2._crypto_kx_keypair(_2, s2))) { + var c2 = { publicKey: y(t2, e3), privateKey: y(n2, e3), keyType: "x25519" }; + return g(a3), c2; + } + b(a3, "internal error"); + } + function Ka(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_kx_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_kx_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_kx_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_kx_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "x25519" }; + return g(t2), p2; + } + b(t2, "internal error"); + } + function Na(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "serverPublicKey"); + var s2, c2 = 0 | r2._crypto_kx_publickeybytes(); + e3.length !== c2 && f(n2, "invalid serverPublicKey length"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "serverSecretKey"); + var h2, o2 = 0 | r2._crypto_kx_secretkeybytes(); + a3.length !== o2 && f(n2, "invalid serverSecretKey length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "clientPublicKey"); + var p2, i2 = 0 | r2._crypto_kx_publickeybytes(); + t2.length !== i2 && f(n2, "invalid clientPublicKey length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | r2._crypto_kx_sessionkeybytes()), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_kx_sessionkeybytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_kx_server_session_keys(m2, k2, s2, h2, p2))) { + var S2 = y({ sharedRx: v2, sharedTx: x2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function La(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_onetimeauth_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_onetimeauth_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_onetimeauth(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function Oa(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "state_address"); + var _2 = new u(0 | r2._crypto_onetimeauth_bytes()), n2 = _2.address; + if (t2.push(n2), !(0 | r2._crypto_onetimeauth_final(e3, n2))) { + var s2 = (r2._free(e3), y(_2, a3)); + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function Ua(e3, a3) { + var t2 = []; + l(a3); + var _2 = null; + null != e3 && (_2 = d(e3 = E(t2, e3, "key")), e3.length, t2.push(_2)); + var n2 = new u(144).address; + if (!(0 | r2._crypto_onetimeauth_init(n2, _2))) { + var s2 = n2; + return g(t2), s2; + } + b(t2, "invalid usage"); + } + function Ca(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_onetimeauth_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_onetimeauth_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Pa(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_onetimeauth_update(e3, n2, s2) && b(_2, "invalid usage"), g(_2); + } + function Ra(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "hash"); + var n2, s2 = 0 | r2._crypto_onetimeauth_bytes(); + e3.length !== s2 && f(_2, "invalid hash length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "key"); + var o2, p2 = 0 | r2._crypto_onetimeauth_keybytes(); + t2.length !== p2 && f(_2, "invalid key length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_onetimeauth_verify(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function Xa(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2), m(h2, e3, "keyLength"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(h2, "keyLength must be an unsigned integer"); + var o2 = d(a3 = E(h2, a3, "password")), p2 = a3.length; + h2.push(o2), t2 = E(h2, t2, "salt"); + var i2, v2 = 0 | r2._crypto_pwhash_saltbytes(); + t2.length !== v2 && f(h2, "invalid salt length"), i2 = d(t2), h2.push(i2), m(h2, _2, "opsLimit"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(h2, "opsLimit must be an unsigned integer"), m(h2, n2, "memLimit"), ("number" != typeof n2 || (0 | n2) !== n2 || n2 < 0) && f(h2, "memLimit must be an unsigned integer"), m(h2, s2, "algorithm"), ("number" != typeof s2 || (0 | s2) !== s2 || s2 < 0) && f(h2, "algorithm must be an unsigned integer"); + var x2 = new u(0 | e3), k2 = x2.address; + if (h2.push(k2), !(0 | r2._crypto_pwhash(k2, e3, 0, o2, p2, 0, i2, _2, 0, n2, s2))) { + var S2 = y(x2, c2); + return g(h2), S2; + } + b(h2, "invalid usage"); + } + function Ga(e3, a3, t2, _2, n2, s2) { + var c2 = []; + l(s2), m(c2, e3, "keyLength"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(c2, "keyLength must be an unsigned integer"); + var h2 = d(a3 = E(c2, a3, "password")), o2 = a3.length; + c2.push(h2), t2 = E(c2, t2, "salt"); + var p2, i2 = 0 | r2._crypto_pwhash_scryptsalsa208sha256_saltbytes(); + t2.length !== i2 && f(c2, "invalid salt length"), p2 = d(t2), c2.push(p2), m(c2, _2, "opsLimit"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(c2, "opsLimit must be an unsigned integer"), m(c2, n2, "memLimit"), ("number" != typeof n2 || (0 | n2) !== n2 || n2 < 0) && f(c2, "memLimit must be an unsigned integer"); + var v2 = new u(0 | e3), x2 = v2.address; + if (c2.push(x2), !(0 | r2._crypto_pwhash_scryptsalsa208sha256(x2, e3, 0, h2, o2, 0, p2, _2, 0, n2))) { + var k2 = y(v2, s2); + return g(c2), k2; + } + b(c2, "invalid usage"); + } + function Da(e3, a3, t2, _2, n2, s2, c2) { + var h2 = []; + l(c2); + var o2 = d(e3 = E(h2, e3, "password")), p2 = e3.length; + h2.push(o2); + var i2 = d(a3 = E(h2, a3, "salt")), v2 = a3.length; + h2.push(i2), m(h2, t2, "opsLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(h2, "opsLimit must be an unsigned integer"), m(h2, _2, "r"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(h2, "r must be an unsigned integer"), m(h2, n2, "p"), ("number" != typeof n2 || (0 | n2) !== n2 || n2 < 0) && f(h2, "p must be an unsigned integer"), m(h2, s2, "keyLength"), ("number" != typeof s2 || (0 | s2) !== s2 || s2 < 0) && f(h2, "keyLength must be an unsigned integer"); + var x2 = new u(0 | s2), k2 = x2.address; + if (h2.push(k2), !(0 | r2._crypto_pwhash_scryptsalsa208sha256_ll(o2, p2, i2, v2, t2, 0, _2, n2, k2, s2))) { + var S2 = y(x2, c2); + return g(h2), S2; + } + b(h2, "invalid usage"); + } + function Fa(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "password")), c2 = e3.length; + n2.push(s2), m(n2, a3, "opsLimit"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(n2, "opsLimit must be an unsigned integer"), m(n2, t2, "memLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(n2, "memLimit must be an unsigned integer"); + var h2 = new u(0 | r2._crypto_pwhash_scryptsalsa208sha256_strbytes()).address; + if (n2.push(h2), !(0 | r2._crypto_pwhash_scryptsalsa208sha256_str(h2, s2, c2, 0, a3, 0, t2))) { + var o2 = r2.UTF8ToString(h2); + return g(n2), o2; + } + b(n2, "invalid usage"); + } + function Va(e3, a3, t2) { + var _2 = []; + l(t2), "string" != typeof e3 && f(_2, "hashed_password must be a string"), e3 = n(e3 + "\0"), null != c2 && e3.length - 1 !== c2 && f(_2, "invalid hashed_password length"); + var s2 = d(e3), c2 = e3.length - 1; + _2.push(s2); + var h2 = d(a3 = E(_2, a3, "password")), o2 = a3.length; + _2.push(h2); + var p2 = !(0 | r2._crypto_pwhash_scryptsalsa208sha256_str_verify(s2, h2, o2, 0)); + return g(_2), p2; + } + function Ha(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "password")), c2 = e3.length; + n2.push(s2), m(n2, a3, "opsLimit"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(n2, "opsLimit must be an unsigned integer"), m(n2, t2, "memLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(n2, "memLimit must be an unsigned integer"); + var h2 = new u(0 | r2._crypto_pwhash_strbytes()).address; + if (n2.push(h2), !(0 | r2._crypto_pwhash_str(h2, s2, c2, 0, a3, 0, t2))) { + var o2 = r2.UTF8ToString(h2); + return g(n2), o2; + } + b(n2, "invalid usage"); + } + function Wa(e3, a3, t2, _2) { + var s2 = []; + l(_2), "string" != typeof e3 && f(s2, "hashed_password must be a string"), e3 = n(e3 + "\0"), null != h2 && e3.length - 1 !== h2 && f(s2, "invalid hashed_password length"); + var c2 = d(e3), h2 = e3.length - 1; + s2.push(c2), m(s2, a3, "opsLimit"), ("number" != typeof a3 || (0 | a3) !== a3 || a3 < 0) && f(s2, "opsLimit must be an unsigned integer"), m(s2, t2, "memLimit"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "memLimit must be an unsigned integer"); + var o2 = !!(0 | r2._crypto_pwhash_str_needs_rehash(c2, a3, 0, t2)); + return g(s2), o2; + } + function qa(e3, a3, t2) { + var _2 = []; + l(t2), "string" != typeof e3 && f(_2, "hashed_password must be a string"), e3 = n(e3 + "\0"), null != c2 && e3.length - 1 !== c2 && f(_2, "invalid hashed_password length"); + var s2 = d(e3), c2 = e3.length - 1; + _2.push(s2); + var h2 = d(a3 = E(_2, a3, "password")), o2 = a3.length; + _2.push(h2); + var p2 = !(0 | r2._crypto_pwhash_str_verify(s2, h2, o2, 0)); + return g(_2), p2; + } + function ja(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "privateKey"); + var n2, s2 = 0 | r2._crypto_scalarmult_scalarbytes(); + e3.length !== s2 && f(_2, "invalid privateKey length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "publicKey"); + var c2, h2 = 0 | r2._crypto_scalarmult_bytes(); + a3.length !== h2 && f(_2, "invalid publicKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "weak public key"); + } + function za(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "privateKey"); + var _2, n2 = 0 | r2._crypto_scalarmult_scalarbytes(); + e3.length !== n2 && f(t2, "invalid privateKey length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_base(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "unknown error"); + } + function Ja(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "n"); + var n2, s2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid n length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "p"); + var c2, h2 = 0 | r2._crypto_scalarmult_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid p length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult_ed25519(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid point or scalar is 0"); + } + function Qa(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "scalar"); + var _2, n2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid scalar length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_ed25519_base(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "scalar is 0"); + } + function Za(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "scalar"); + var _2, n2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== n2 && f(t2, "invalid scalar length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_ed25519_base_noclamp(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "scalar is 0"); + } + function $a(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "n"); + var n2, s2 = 0 | r2._crypto_scalarmult_ed25519_scalarbytes(); + e3.length !== s2 && f(_2, "invalid n length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "p"); + var c2, h2 = 0 | r2._crypto_scalarmult_ed25519_bytes(); + a3.length !== h2 && f(_2, "invalid p length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_ed25519_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult_ed25519_noclamp(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid point or scalar is 0"); + } + function er(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "scalar"); + var n2, s2 = 0 | r2._crypto_scalarmult_ristretto255_scalarbytes(); + e3.length !== s2 && f(_2, "invalid scalar length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "element"); + var c2, h2 = 0 | r2._crypto_scalarmult_ristretto255_bytes(); + a3.length !== h2 && f(_2, "invalid element length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_scalarmult_ristretto255_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_scalarmult_ristretto255(p2, n2, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "result is identity element"); + } + function ar(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "scalar"); + var _2, n2 = 0 | r2._crypto_core_ristretto255_scalarbytes(); + e3.length !== n2 && f(t2, "invalid scalar length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_core_ristretto255_bytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_scalarmult_ristretto255_base(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "scalar is 0"); + } + function rr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_secretbox_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_secretbox_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + n2.push(m2); + var x2 = new u(0 | r2._crypto_secretbox_macbytes()), k2 = x2.address; + if (n2.push(k2), !(0 | r2._crypto_secretbox_detached(m2, k2, s2, c2, 0, h2, p2))) { + var S2 = y({ mac: x2, cipher: v2 }, _2); + return g(n2), S2; + } + b(n2, "invalid usage"); + } + function tr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_secretbox_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_secretbox_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(c2 + r2._crypto_secretbox_macbytes() | 0), m2 = v2.address; + if (n2.push(m2), !(0 | r2._crypto_secretbox_easy(m2, s2, c2, 0, h2, p2))) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function _r(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_secretbox_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_secretbox_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function nr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "ciphertext")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "mac"); + var o2, p2 = 0 | r2._crypto_secretbox_macbytes(); + a3.length !== p2 && f(s2, "invalid mac length"), o2 = d(a3), s2.push(o2), t2 = E(s2, t2, "nonce"); + var i2, v2 = 0 | r2._crypto_secretbox_noncebytes(); + t2.length !== v2 && f(s2, "invalid nonce length"), i2 = d(t2), s2.push(i2), _2 = E(s2, _2, "key"); + var m2, x2 = 0 | r2._crypto_secretbox_keybytes(); + _2.length !== x2 && f(s2, "invalid key length"), m2 = d(_2), s2.push(m2); + var k2 = new u(0 | h2), S2 = k2.address; + if (s2.push(S2), !(0 | r2._crypto_secretbox_open_detached(S2, c2, o2, h2, 0, i2, m2))) { + var T2 = y(k2, n2); + return g(s2), T2; + } + b(s2, "wrong secret key for the given ciphertext"); + } + function sr(e3, a3, t2, _2) { + var n2 = []; + l(_2), e3 = E(n2, e3, "ciphertext"); + var s2, c2 = r2._crypto_secretbox_macbytes(), h2 = e3.length; + h2 < c2 && f(n2, "ciphertext is too short"), s2 = d(e3), n2.push(s2), a3 = E(n2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_secretbox_noncebytes(); + a3.length !== p2 && f(n2, "invalid nonce length"), o2 = d(a3), n2.push(o2), t2 = E(n2, t2, "key"); + var i2, v2 = 0 | r2._crypto_secretbox_keybytes(); + t2.length !== v2 && f(n2, "invalid key length"), i2 = d(t2), n2.push(i2); + var m2 = new u(h2 - r2._crypto_secretbox_macbytes() | 0), x2 = m2.address; + if (n2.push(x2), !(0 | r2._crypto_secretbox_open_easy(x2, s2, h2, 0, o2, i2))) { + var k2 = y(m2, _2); + return g(n2), k2; + } + b(n2, "wrong secret key for the given ciphertext"); + } + function cr(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "header"); + var n2, s2 = 0 | r2._crypto_secretstream_xchacha20poly1305_headerbytes(); + e3.length !== s2 && f(_2, "invalid header length"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_secretstream_xchacha20poly1305_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(52).address; + if (!(0 | r2._crypto_secretstream_xchacha20poly1305_init_pull(o2, n2, c2))) { + var p2 = o2; + return g(_2), p2; + } + b(_2, "invalid usage"); + } + function hr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "key"); + var _2, n2 = 0 | r2._crypto_secretstream_xchacha20poly1305_keybytes(); + e3.length !== n2 && f(t2, "invalid key length"), _2 = d(e3), t2.push(_2); + var s2 = new u(52).address, c2 = new u(0 | r2._crypto_secretstream_xchacha20poly1305_headerbytes()), h2 = c2.address; + if (t2.push(h2), !(0 | r2._crypto_secretstream_xchacha20poly1305_init_push(s2, h2, _2))) { + var o2 = { state: s2, header: y(c2, a3) }; + return g(t2), o2; + } + b(t2, "invalid usage"); + } + function or(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_secretstream_xchacha20poly1305_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_secretstream_xchacha20poly1305_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function pr(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "state_address"), a3 = E(n2, a3, "cipher"); + var s2, c2 = r2._crypto_secretstream_xchacha20poly1305_abytes(), h2 = a3.length; + h2 < c2 && f(n2, "cipher is too short"), s2 = d(a3), n2.push(s2); + var o2 = null, p2 = 0; + null != t2 && (o2 = d(t2 = E(n2, t2, "ad")), p2 = t2.length, n2.push(o2)); + var i2 = new u(h2 - r2._crypto_secretstream_xchacha20poly1305_abytes() | 0), b2 = i2.address; + n2.push(b2); + var x2, k2 = (x2 = v(1), n2.push(x2), (k2 = 0 === r2._crypto_secretstream_xchacha20poly1305_pull(e3, b2, 0, x2, s2, h2, 0, o2, p2) && { tag: r2.HEAPU8[x2], message: i2 }) && { message: y(k2.message, _2), tag: k2.tag }); + return g(n2), k2; + } + function yr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2), m(s2, e3, "state_address"); + var c2 = d(a3 = E(s2, a3, "message_chunk")), h2 = a3.length; + s2.push(c2); + var o2 = null, p2 = 0; + null != t2 && (o2 = d(t2 = E(s2, t2, "ad")), p2 = t2.length, s2.push(o2)), m(s2, _2, "tag"), ("number" != typeof _2 || (0 | _2) !== _2 || _2 < 0) && f(s2, "tag must be an unsigned integer"); + var i2 = new u(h2 + r2._crypto_secretstream_xchacha20poly1305_abytes() | 0), v2 = i2.address; + if (s2.push(v2), !(0 | r2._crypto_secretstream_xchacha20poly1305_push(e3, v2, 0, c2, h2, 0, o2, p2, 0, _2))) { + var x2 = y(i2, n2); + return g(s2), x2; + } + b(s2, "invalid usage"); + } + function ir(e3, a3) { + var t2 = []; + return l(a3), m(t2, e3, "state_address"), r2._crypto_secretstream_xchacha20poly1305_rekey(e3), g(t2), true; + } + function lr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_shorthash_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_shorthash_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_shorthash(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function ur(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_shorthash_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_shorthash_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function dr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "key"); + var c2, h2 = 0 | r2._crypto_shorthash_siphashx24_keybytes(); + a3.length !== h2 && f(_2, "invalid key length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_shorthash_siphashx24_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_shorthash_siphashx24(p2, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function vr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_sign_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(e3.length + r2._crypto_sign_bytes() | 0), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_sign(p2, null, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function gr(e3, a3, t2) { + var _2 = []; + l(t2); + var n2 = d(e3 = E(_2, e3, "message")), s2 = e3.length; + _2.push(n2), a3 = E(_2, a3, "privateKey"); + var c2, h2 = 0 | r2._crypto_sign_secretkeybytes(); + a3.length !== h2 && f(_2, "invalid privateKey length"), c2 = d(a3), _2.push(c2); + var o2 = new u(0 | r2._crypto_sign_bytes()), p2 = o2.address; + if (_2.push(p2), !(0 | r2._crypto_sign_detached(p2, null, n2, s2, 0, c2))) { + var i2 = y(o2, t2); + return g(_2), i2; + } + b(_2, "invalid usage"); + } + function br(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "edPk"); + var _2, n2 = 0 | r2._crypto_sign_publickeybytes(); + e3.length !== n2 && f(t2, "invalid edPk length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_pk_to_curve25519(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function fr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "edSk"); + var _2, n2 = 0 | r2._crypto_sign_secretkeybytes(); + e3.length !== n2 && f(t2, "invalid edSk length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_scalarmult_scalarbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_sk_to_curve25519(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function mr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "privateKey"); + var _2, n2 = 0 | r2._crypto_sign_secretkeybytes(); + e3.length !== n2 && f(t2, "invalid privateKey length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_sign_publickeybytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_sk_to_pk(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function Er(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "privateKey"); + var _2, n2 = 0 | r2._crypto_sign_secretkeybytes(); + e3.length !== n2 && f(t2, "invalid privateKey length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_sign_seedbytes()), c2 = s2.address; + if (t2.push(c2), !(0 | r2._crypto_sign_ed25519_sk_to_seed(c2, _2))) { + var h2 = y(s2, a3); + return g(t2), h2; + } + b(t2, "invalid key"); + } + function xr(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"), a3 = E(_2, a3, "privateKey"); + var n2, s2 = 0 | r2._crypto_sign_secretkeybytes(); + a3.length !== s2 && f(_2, "invalid privateKey length"), n2 = d(a3), _2.push(n2); + var c2 = new u(0 | r2._crypto_sign_bytes()), h2 = c2.address; + if (_2.push(h2), !(0 | r2._crypto_sign_final_create(e3, h2, null, n2))) { + var o2 = (r2._free(e3), y(c2, t2)); + return g(_2), o2; + } + b(_2, "invalid usage"); + } + function kr(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "state_address"), a3 = E(n2, a3, "signature"); + var s2, c2 = 0 | r2._crypto_sign_bytes(); + a3.length !== c2 && f(n2, "invalid signature length"), s2 = d(a3), n2.push(s2), t2 = E(n2, t2, "publicKey"); + var h2, o2 = 0 | r2._crypto_sign_publickeybytes(); + t2.length !== o2 && f(n2, "invalid publicKey length"), h2 = d(t2), n2.push(h2); + var p2 = !(0 | r2._crypto_sign_final_verify(e3, s2, h2)); + return g(n2), p2; + } + function Sr(e3) { + var a3 = []; + l(e3); + var t2 = new u(208).address; + if (!(0 | r2._crypto_sign_init(t2))) { + var _2 = t2; + return g(a3), _2; + } + b(a3, "internal error"); + } + function Tr(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_sign_publickeybytes()), _2 = t2.address; + a3.push(_2); + var n2 = new u(0 | r2._crypto_sign_secretkeybytes()), s2 = n2.address; + if (a3.push(s2), !(0 | r2._crypto_sign_keypair(_2, s2))) { + var c2 = { publicKey: y(t2, e3), privateKey: y(n2, e3), keyType: "ed25519" }; + return g(a3), c2; + } + b(a3, "internal error"); + } + function wr(e3, a3, t2) { + var _2 = []; + l(t2), e3 = E(_2, e3, "signedMessage"); + var n2, s2 = r2._crypto_sign_bytes(), c2 = e3.length; + c2 < s2 && f(_2, "signedMessage is too short"), n2 = d(e3), _2.push(n2), a3 = E(_2, a3, "publicKey"); + var h2, o2 = 0 | r2._crypto_sign_publickeybytes(); + a3.length !== o2 && f(_2, "invalid publicKey length"), h2 = d(a3), _2.push(h2); + var p2 = new u(c2 - r2._crypto_sign_bytes() | 0), i2 = p2.address; + if (_2.push(i2), !(0 | r2._crypto_sign_open(i2, null, n2, c2, 0, h2))) { + var v2 = y(p2, t2); + return g(_2), v2; + } + b(_2, "incorrect signature for the given public key"); + } + function Yr(e3, a3) { + var t2 = []; + l(a3), e3 = E(t2, e3, "seed"); + var _2, n2 = 0 | r2._crypto_sign_seedbytes(); + e3.length !== n2 && f(t2, "invalid seed length"), _2 = d(e3), t2.push(_2); + var s2 = new u(0 | r2._crypto_sign_publickeybytes()), c2 = s2.address; + t2.push(c2); + var h2 = new u(0 | r2._crypto_sign_secretkeybytes()), o2 = h2.address; + if (t2.push(o2), !(0 | r2._crypto_sign_seed_keypair(c2, o2, _2))) { + var p2 = { publicKey: y(s2, a3), privateKey: y(h2, a3), keyType: "ed25519" }; + return g(t2), p2; + } + b(t2, "invalid usage"); + } + function Br(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "state_address"); + var n2 = d(a3 = E(_2, a3, "message_chunk")), s2 = a3.length; + _2.push(n2), 0 | r2._crypto_sign_update(e3, n2, s2, 0) && b(_2, "invalid usage"), g(_2); + } + function Ar(e3, a3, t2) { + var _2 = []; + e3 = E(_2, e3, "signature"); + var n2, s2 = 0 | r2._crypto_sign_bytes(); + e3.length !== s2 && f(_2, "invalid signature length"), n2 = d(e3), _2.push(n2); + var c2 = d(a3 = E(_2, a3, "message")), h2 = a3.length; + _2.push(c2), t2 = E(_2, t2, "publicKey"); + var o2, p2 = 0 | r2._crypto_sign_publickeybytes(); + t2.length !== p2 && f(_2, "invalid publicKey length"), o2 = d(t2), _2.push(o2); + var y2 = !(0 | r2._crypto_sign_verify_detached(n2, c2, h2, 0, o2)); + return g(_2), y2; + } + function Mr(e3, a3, t2, _2) { + var n2 = []; + l(_2), m(n2, e3, "outLength"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(n2, "outLength must be an unsigned integer"), a3 = E(n2, a3, "key"); + var s2, c2 = 0 | r2._crypto_stream_chacha20_keybytes(); + a3.length !== c2 && f(n2, "invalid key length"), s2 = d(a3), n2.push(s2), t2 = E(n2, t2, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_chacha20_noncebytes(); + t2.length !== o2 && f(n2, "invalid nonce length"), h2 = d(t2), n2.push(h2); + var p2 = new u(0 | e3), i2 = p2.address; + n2.push(i2), r2._crypto_stream_chacha20(i2, e3, 0, h2, s2); + var v2 = y(p2, _2); + return g(n2), v2; + } + function Ir(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "input_message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_chacha20_ietf_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_stream_chacha20_ietf_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + if (n2.push(m2), 0 === r2._crypto_stream_chacha20_ietf_xor(m2, s2, c2, 0, h2, p2)) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Kr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "input_message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_stream_chacha20_ietf_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), m(s2, t2, "nonce_increment"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "nonce_increment must be an unsigned integer"), _2 = E(s2, _2, "key"); + var i2, v2 = 0 | r2._crypto_stream_chacha20_ietf_keybytes(); + _2.length !== v2 && f(s2, "invalid key length"), i2 = d(_2), s2.push(i2); + var x2 = new u(0 | h2), k2 = x2.address; + if (s2.push(k2), 0 === r2._crypto_stream_chacha20_ietf_xor_ic(k2, c2, h2, 0, o2, t2, i2)) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function Nr(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_stream_chacha20_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_stream_chacha20_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Lr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "input_message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_chacha20_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_stream_chacha20_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + if (n2.push(m2), 0 === r2._crypto_stream_chacha20_xor(m2, s2, c2, 0, h2, p2)) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Or(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "input_message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_stream_chacha20_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), m(s2, t2, "nonce_increment"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "nonce_increment must be an unsigned integer"), _2 = E(s2, _2, "key"); + var i2, v2 = 0 | r2._crypto_stream_chacha20_keybytes(); + _2.length !== v2 && f(s2, "invalid key length"), i2 = d(_2), s2.push(i2); + var x2 = new u(0 | h2), k2 = x2.address; + if (s2.push(k2), 0 === r2._crypto_stream_chacha20_xor_ic(k2, c2, h2, 0, o2, t2, 0, i2)) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function Ur(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_stream_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_stream_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Cr(e3) { + var a3 = []; + l(e3); + var t2 = new u(0 | r2._crypto_stream_xchacha20_keybytes()), _2 = t2.address; + a3.push(_2), r2._crypto_stream_xchacha20_keygen(_2); + var n2 = y(t2, e3); + return g(a3), n2; + } + function Pr(e3, a3, t2, _2) { + var n2 = []; + l(_2); + var s2 = d(e3 = E(n2, e3, "input_message")), c2 = e3.length; + n2.push(s2), a3 = E(n2, a3, "nonce"); + var h2, o2 = 0 | r2._crypto_stream_xchacha20_noncebytes(); + a3.length !== o2 && f(n2, "invalid nonce length"), h2 = d(a3), n2.push(h2), t2 = E(n2, t2, "key"); + var p2, i2 = 0 | r2._crypto_stream_xchacha20_keybytes(); + t2.length !== i2 && f(n2, "invalid key length"), p2 = d(t2), n2.push(p2); + var v2 = new u(0 | c2), m2 = v2.address; + if (n2.push(m2), 0 === r2._crypto_stream_xchacha20_xor(m2, s2, c2, 0, h2, p2)) { + var x2 = y(v2, _2); + return g(n2), x2; + } + b(n2, "invalid usage"); + } + function Rr(e3, a3, t2, _2, n2) { + var s2 = []; + l(n2); + var c2 = d(e3 = E(s2, e3, "input_message")), h2 = e3.length; + s2.push(c2), a3 = E(s2, a3, "nonce"); + var o2, p2 = 0 | r2._crypto_stream_xchacha20_noncebytes(); + a3.length !== p2 && f(s2, "invalid nonce length"), o2 = d(a3), s2.push(o2), m(s2, t2, "nonce_increment"), ("number" != typeof t2 || (0 | t2) !== t2 || t2 < 0) && f(s2, "nonce_increment must be an unsigned integer"), _2 = E(s2, _2, "key"); + var i2, v2 = 0 | r2._crypto_stream_xchacha20_keybytes(); + _2.length !== v2 && f(s2, "invalid key length"), i2 = d(_2), s2.push(i2); + var x2 = new u(0 | h2), k2 = x2.address; + if (s2.push(k2), 0 === r2._crypto_stream_xchacha20_xor_ic(k2, c2, h2, 0, o2, t2, 0, i2)) { + var S2 = y(x2, n2); + return g(s2), S2; + } + b(s2, "invalid usage"); + } + function Xr(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "length"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(t2, "length must be an unsigned integer"); + var _2 = new u(0 | e3), n2 = _2.address; + t2.push(n2), r2._randombytes_buf(n2, e3); + var s2 = y(_2, a3); + return g(t2), s2; + } + function Gr(e3, a3, t2) { + var _2 = []; + l(t2), m(_2, e3, "length"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(_2, "length must be an unsigned integer"), a3 = E(_2, a3, "seed"); + var n2, s2 = 0 | r2._randombytes_seedbytes(); + a3.length !== s2 && f(_2, "invalid seed length"), n2 = d(a3), _2.push(n2); + var c2 = new u(0 | e3), h2 = c2.address; + _2.push(h2), r2._randombytes_buf_deterministic(h2, e3, n2); + var o2 = y(c2, t2); + return g(_2), o2; + } + function Dr(e3) { + l(e3), r2._randombytes_close(); + } + function Fr(e3) { + l(e3); + var a3 = r2._randombytes_random() >>> 0; + return g([]), a3; + } + function Vr(e3, a3) { + var t2 = []; + l(a3); + for (var _2 = r2._malloc(24), n2 = 0; n2 < 6; n2++) r2.setValue(_2 + 4 * n2, r2.Runtime.addFunction(e3[["implementation_name", "random", "stir", "uniform", "buf", "close"][n2]]), "i32"); + 0 | r2._randombytes_set_implementation(_2) && b(t2, "unsupported implementation"), g(t2); + } + function Hr(e3) { + l(e3), r2._randombytes_stir(); + } + function Wr(e3, a3) { + var t2 = []; + l(a3), m(t2, e3, "upper_bound"), ("number" != typeof e3 || (0 | e3) !== e3 || e3 < 0) && f(t2, "upper_bound must be an unsigned integer"); + var _2 = r2._randombytes_uniform(e3) >>> 0; + return g(t2), _2; + } + function qr() { + var e3 = r2._sodium_version_string(), a3 = r2.UTF8ToString(e3); + return g([]), a3; + } + return u.prototype.to_Uint8Array = function() { + var e3 = new Uint8Array(this.length); + return e3.set(r2.HEAPU8.subarray(this.address, this.address + this.length)), e3; + }, e2.add = function(e3, a3) { + if (!(e3 instanceof Uint8Array && a3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can added"); + var r3 = e3.length, t2 = 0, _2 = 0; + if (a3.length != e3.length) throw new TypeError("Arguments must have the same length"); + for (_2 = 0; _2 < r3; _2++) t2 >>= 8, t2 += e3[_2] + a3[_2], e3[_2] = 255 & t2; + }, e2.base64_variants = h, e2.compare = function(e3, a3) { + if (!(e3 instanceof Uint8Array && a3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be compared"); + if (e3.length !== a3.length) throw new TypeError("Only instances of identical length can be compared"); + for (var r3 = 0, t2 = 1, _2 = e3.length; _2-- > 0; ) r3 |= a3[_2] - e3[_2] >> 8 & t2, t2 &= (a3[_2] ^ e3[_2]) - 1 >> 8; + return r3 + r3 + t2 - 1; + }, e2.from_base64 = function(e3, a3) { + a3 = o(a3); + var t2, _2 = [], n2 = new u(3 * (e3 = E(_2, e3, "input")).length / 4), s2 = d(e3), c2 = v(4), h2 = v(4); + return _2.push(s2), _2.push(n2.address), _2.push(n2.result_bin_len_p), _2.push(n2.b64_end_p), 0 !== r2._sodium_base642bin(n2.address, n2.length, s2, e3.length, 0, c2, h2, a3) && b(_2, "invalid input"), r2.getValue(h2, "i32") - s2 !== e3.length && b(_2, "incomplete input"), n2.length = r2.getValue(c2, "i32"), t2 = n2.to_Uint8Array(), g(_2), t2; + }, e2.from_hex = function(e3) { + var a3, t2 = [], _2 = new u((e3 = E(t2, e3, "input")).length / 2), n2 = d(e3), s2 = v(4); + return t2.push(n2), t2.push(_2.address), t2.push(_2.hex_end_p), 0 !== r2._sodium_hex2bin(_2.address, _2.length, n2, e3.length, 0, 0, s2) && b(t2, "invalid input"), r2.getValue(s2, "i32") - n2 !== e3.length && b(t2, "incomplete input"), a3 = _2.to_Uint8Array(), g(t2), a3; + }, e2.from_string = n, e2.increment = function(e3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be incremented"); + for (var a3 = 256, r3 = 0, t2 = e3.length; r3 < t2; r3++) a3 >>= 8, a3 += e3[r3], e3[r3] = 255 & a3; + }, e2.is_zero = function(e3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be checked"); + for (var a3 = 0, r3 = 0, t2 = e3.length; r3 < t2; r3++) a3 |= e3[r3]; + return 0 === a3; + }, e2.libsodium = a2, e2.memcmp = function(e3, a3) { + if (!(e3 instanceof Uint8Array && a3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be compared"); + if (e3.length !== a3.length) throw new TypeError("Only instances of identical length can be compared"); + for (var r3 = 0, t2 = 0, _2 = e3.length; t2 < _2; t2++) r3 |= e3[t2] ^ a3[t2]; + return 0 === r3; + }, e2.memzero = function(e3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be wiped"); + for (var a3 = 0, r3 = e3.length; a3 < r3; a3++) e3[a3] = 0; + }, e2.output_formats = function() { + return ["uint8array", "text", "hex", "base64"]; + }, e2.pad = function(e3, a3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("buffer must be a Uint8Array"); + if ((a3 |= 0) <= 0) throw new Error("block size must be > 0"); + var t2, _2 = [], n2 = v(4), s2 = 1, c2 = 0, h2 = 0 | e3.length, o2 = new u(h2 + a3); + _2.push(n2), _2.push(o2.address); + for (var p2 = o2.address, y2 = o2.address + h2 + a3; p2 < y2; p2++) r2.HEAPU8[p2] = e3[c2], c2 += s2 = 1 & ~((65535 & ((h2 -= s2) >>> 48 | h2 >>> 32 | h2 >>> 16 | h2)) - 1 >> 16); + return 0 !== r2._sodium_pad(n2, o2.address, e3.length, a3, o2.length) && b(_2, "internal error"), o2.length = r2.getValue(n2, "i32"), t2 = o2.to_Uint8Array(), g(_2), t2; + }, e2.unpad = function(e3, a3) { + if (!(e3 instanceof Uint8Array)) throw new TypeError("buffer must be a Uint8Array"); + if ((a3 |= 0) <= 0) throw new Error("block size must be > 0"); + var t2 = [], _2 = d(e3), n2 = v(4); + return t2.push(_2), t2.push(n2), 0 !== r2._sodium_unpad(n2, _2, e3.length, a3) && b(t2, "unsupported/invalid padding"), e3 = (e3 = new Uint8Array(e3)).subarray(0, r2.getValue(n2, "i32")), g(t2), e3; + }, e2.ready = _, e2.symbols = function() { + return Object.keys(e2).sort(); + }, e2.to_base64 = p, e2.to_hex = c, e2.to_string = s, e2; + } + var r = "object" == typeof e.sodium && "function" == typeof e.sodium.onload ? e.sodium.onload : null; + "function" == typeof define && define.amd ? define(["exports", "libsodium"], a) : "object" == typeof exports2 && "string" != typeof exports2.nodeName ? a(exports2, require_libsodium()) : e.sodium = a(e.commonJsStrict = {}, e.libsodium), r && e.sodium.ready.then(function() { + r(e.sodium); + }); + }(exports2); + } +}); + +// node_modules/ts-dedent/dist/index.js +var require_dist = __commonJS({ + "node_modules/ts-dedent/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.dedent = void 0; + function dedent(templ) { + var values = []; + for (var _i = 1; _i < arguments.length; _i++) { + values[_i - 1] = arguments[_i]; + } + var strings = Array.from(typeof templ === "string" ? [templ] : templ); + strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, ""); + var indentLengths = strings.reduce(function(arr, str) { + var matches = str.match(/\n([\t ]+|(?!\s).)/g); + if (matches) { + return arr.concat(matches.map(function(match) { + var _a2, _b; + return (_b = (_a2 = match.match(/[\t ]/g)) === null || _a2 === void 0 ? void 0 : _a2.length) !== null && _b !== void 0 ? _b : 0; + })); + } + return arr; + }, []); + if (indentLengths.length) { + var pattern_1 = new RegExp("\n[ ]{" + Math.min.apply(Math, indentLengths) + "}", "g"); + strings = strings.map(function(str) { + return str.replace(pattern_1, "\n"); + }); + } + strings[0] = strings[0].replace(/^\r?\n/, ""); + var string = strings[0]; + values.forEach(function(value, i) { + var endentations = string.match(/(?:^|\n)( *)$/); + var endentation = endentations ? endentations[1] : ""; + var indentedValue = value; + if (typeof value === "string" && value.includes("\n")) { + indentedValue = String(value).split("\n").map(function(str, i2) { + return i2 === 0 ? str : "" + endentation + str; + }).join("\n"); + } + string += indentedValue + strings[i + 1]; + }); + return string; + } + exports2.dedent = dedent; + exports2.default = dedent; + } +}); + +// src/preview.ts +var import_core = __toESM(require_core()); +var exec3 = __toESM(require_exec()); +var github2 = __toESM(require_github()); + +// node_modules/@stainless-api/sdk/internal/tslib.mjs +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +// node_modules/@stainless-api/sdk/internal/utils/uuid.mjs +var uuid4 = function() { + const { crypto } = globalThis; + if (crypto?.randomUUID) { + uuid4 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16)); +}; + +// node_modules/@stainless-api/sdk/internal/errors.mjs +function isAbortError(err) { + return typeof err === "object" && err !== null && // Spec-compliant fetch implementations + ("name" in err && err.name === "AbortError" || // Expo fetch + "message" in err && String(err.message).includes("FetchRequestCanceledException")); +} +var castToError = (err) => { + if (err instanceof Error) + return err; + if (typeof err === "object" && err !== null) { + try { + if (Object.prototype.toString.call(err) === "[object Error]") { + const error = new Error(err.message, err.cause ? { cause: err.cause } : {}); + if (err.stack) + error.stack = err.stack; + if (err.cause && !error.cause) + error.cause = err.cause; + if (err.name) + error.name = err.name; + return error; + } + } catch { + } + try { + return new Error(JSON.stringify(err)); + } catch { + } + } + return new Error(err); +}; + +// node_modules/@stainless-api/sdk/core/error.mjs +var StainlessError = class extends Error { +}; +var APIError = class _APIError extends StainlessError { + constructor(status, error, message, headers) { + super(`${_APIError.makeMessage(status, error, message)}`); + this.status = status; + this.headers = headers; + this.error = error; + } + static makeMessage(status, error, message) { + const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message; + if (status && msg) { + return `${status} ${msg}`; + } + if (status) { + return `${status} status code (no body)`; + } + if (msg) { + return msg; + } + return "(no status code or body)"; + } + static generate(status, errorResponse, message, headers) { + if (!status || !headers) { + return new APIConnectionError({ message, cause: castToError(errorResponse) }); + } + const error = errorResponse; + if (status === 400) { + return new BadRequestError(status, error, message, headers); + } + if (status === 401) { + return new AuthenticationError(status, error, message, headers); + } + if (status === 403) { + return new PermissionDeniedError(status, error, message, headers); + } + if (status === 404) { + return new NotFoundError(status, error, message, headers); + } + if (status === 409) { + return new ConflictError(status, error, message, headers); + } + if (status === 422) { + return new UnprocessableEntityError(status, error, message, headers); + } + if (status === 429) { + return new RateLimitError(status, error, message, headers); + } + if (status >= 500) { + return new InternalServerError(status, error, message, headers); + } + return new _APIError(status, error, message, headers); + } +}; +var APIUserAbortError = class extends APIError { + constructor({ message } = {}) { + super(void 0, void 0, message || "Request was aborted.", void 0); + } +}; +var APIConnectionError = class extends APIError { + constructor({ message, cause }) { + super(void 0, void 0, message || "Connection error.", void 0); + if (cause) + this.cause = cause; + } +}; +var APIConnectionTimeoutError = class extends APIConnectionError { + constructor({ message } = {}) { + super({ message: message ?? "Request timed out." }); + } +}; +var BadRequestError = class extends APIError { +}; +var AuthenticationError = class extends APIError { +}; +var PermissionDeniedError = class extends APIError { +}; +var NotFoundError = class extends APIError { +}; +var ConflictError = class extends APIError { +}; +var UnprocessableEntityError = class extends APIError { +}; +var RateLimitError = class extends APIError { +}; +var InternalServerError = class extends APIError { +}; + +// node_modules/@stainless-api/sdk/internal/utils/values.mjs +var startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i; +var isAbsoluteURL = (url) => { + return startsWithSchemeRegexp.test(url); +}; +var isArray = (val) => (isArray = Array.isArray, isArray(val)); +var isReadonlyArray = isArray; +function maybeObj(x) { + if (typeof x !== "object") { + return {}; + } + return x ?? {}; +} +function isEmptyObj(obj) { + if (!obj) + return true; + for (const _k in obj) + return false; + return true; +} +function hasOwn(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} +var validatePositiveInteger = (name, n) => { + if (typeof n !== "number" || !Number.isInteger(n)) { + throw new StainlessError(`${name} must be an integer`); + } + if (n < 0) { + throw new StainlessError(`${name} must be a positive integer`); + } + return n; +}; +var safeJSON = (text) => { + try { + return JSON.parse(text); + } catch (err) { + return void 0; + } +}; + +// node_modules/@stainless-api/sdk/internal/utils/sleep.mjs +var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); + +// node_modules/@stainless-api/sdk/version.mjs +var VERSION = "0.1.0-alpha.11"; + +// node_modules/@stainless-api/sdk/internal/detect-platform.mjs +function getDetectedPlatform() { + if (typeof Deno !== "undefined" && Deno.build != null) { + return "deno"; + } + if (typeof EdgeRuntime !== "undefined") { + return "edge"; + } + if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") { + return "node"; + } + return "unknown"; +} +var getPlatformProperties = () => { + const detectedPlatform = getDetectedPlatform(); + if (detectedPlatform === "deno") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(Deno.build.os), + "X-Stainless-Arch": normalizeArch(Deno.build.arch), + "X-Stainless-Runtime": "deno", + "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown" + }; + } + if (typeof EdgeRuntime !== "undefined") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": `other:${EdgeRuntime}`, + "X-Stainless-Runtime": "edge", + "X-Stainless-Runtime-Version": globalThis.process.version + }; + } + if (detectedPlatform === "node") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"), + "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"), + "X-Stainless-Runtime": "node", + "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown" + }; + } + const browserInfo = getBrowserInfo(); + if (browserInfo) { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": `browser:${browserInfo.browser}`, + "X-Stainless-Runtime-Version": browserInfo.version + }; + } + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": "unknown", + "X-Stainless-Runtime-Version": "unknown" + }; +}; +function getBrowserInfo() { + if (typeof navigator === "undefined" || !navigator) { + return null; + } + const browserPatterns = [ + { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ } + ]; + for (const { key, pattern } of browserPatterns) { + const match = pattern.exec(navigator.userAgent); + if (match) { + const major = match[1] || 0; + const minor = match[2] || 0; + const patch = match[3] || 0; + return { browser: key, version: `${major}.${minor}.${patch}` }; + } + } + return null; +} +var normalizeArch = (arch) => { + if (arch === "x32") + return "x32"; + if (arch === "x86_64" || arch === "x64") + return "x64"; + if (arch === "arm") + return "arm"; + if (arch === "aarch64" || arch === "arm64") + return "arm64"; + if (arch) + return `other:${arch}`; + return "unknown"; +}; +var normalizePlatform = (platform) => { + platform = platform.toLowerCase(); + if (platform.includes("ios")) + return "iOS"; + if (platform === "android") + return "Android"; + if (platform === "darwin") + return "MacOS"; + if (platform === "win32") + return "Windows"; + if (platform === "freebsd") + return "FreeBSD"; + if (platform === "openbsd") + return "OpenBSD"; + if (platform === "linux") + return "Linux"; + if (platform) + return `Other:${platform}`; + return "Unknown"; +}; +var _platformHeaders; +var getPlatformHeaders = () => { + return _platformHeaders ?? (_platformHeaders = getPlatformProperties()); +}; + +// node_modules/@stainless-api/sdk/internal/shims.mjs +function getDefaultFetch() { + if (typeof fetch !== "undefined") { + return fetch; + } + throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Stainless({ fetch })` or polyfill the global, `globalThis.fetch = fetch`"); +} +function makeReadableStream(...args) { + const ReadableStream = globalThis.ReadableStream; + if (typeof ReadableStream === "undefined") { + throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`"); + } + return new ReadableStream(...args); +} +function ReadableStreamFrom(iterable) { + let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); + return makeReadableStream({ + start() { + }, + async pull(controller) { + const { done, value } = await iter.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel() { + await iter.return?.(); + } + }); +} +async function CancelReadableStream(stream) { + if (stream === null || typeof stream !== "object") + return; + if (stream[Symbol.asyncIterator]) { + await stream[Symbol.asyncIterator]().return?.(); + return; + } + const reader = stream.getReader(); + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; +} + +// node_modules/@stainless-api/sdk/internal/request-options.mjs +var FallbackEncoder = ({ headers, body }) => { + return { + bodyHeaders: { + "content-type": "application/json" + }, + body: JSON.stringify(body) + }; +}; + +// node_modules/@stainless-api/sdk/internal/qs/formats.mjs +var default_format = "RFC3986"; +var default_formatter = (v) => String(v); +var formatters = { + RFC1738: (v) => String(v).replace(/%20/g, "+"), + RFC3986: default_formatter +}; +var RFC1738 = "RFC1738"; + +// node_modules/@stainless-api/sdk/internal/qs/utils.mjs +var has = (obj, key) => (has = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), has(obj, key)); +var hex_table = /* @__PURE__ */ (() => { + const array = []; + for (let i = 0; i < 256; ++i) { + array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + } + return array; +})(); +var limit = 1024; +var encode = (str, _defaultEncoder, charset, _kind, format) => { + if (str.length === 0) { + return str; + } + let string = str; + if (typeof str === "symbol") { + string = Symbol.prototype.toString.call(str); + } else if (typeof str !== "string") { + string = String(str); + } + if (charset === "iso-8859-1") { + return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) { + return "%26%23" + parseInt($0.slice(2), 16) + "%3B"; + }); + } + let out = ""; + for (let j = 0; j < string.length; j += limit) { + const segment = string.length >= limit ? string.slice(j, j + limit) : string; + const arr = []; + for (let i = 0; i < segment.length; ++i) { + let c = segment.charCodeAt(i); + if (c === 45 || // - + c === 46 || // . + c === 95 || // _ + c === 126 || // ~ + c >= 48 && c <= 57 || // 0-9 + c >= 65 && c <= 90 || // a-z + c >= 97 && c <= 122 || // A-Z + format === RFC1738 && (c === 40 || c === 41)) { + arr[arr.length] = segment.charAt(i); + continue; + } + if (c < 128) { + arr[arr.length] = hex_table[c]; + continue; + } + if (c < 2048) { + arr[arr.length] = hex_table[192 | c >> 6] + hex_table[128 | c & 63]; + continue; + } + if (c < 55296 || c >= 57344) { + arr[arr.length] = hex_table[224 | c >> 12] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + continue; + } + i += 1; + c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023); + arr[arr.length] = hex_table[240 | c >> 18] + hex_table[128 | c >> 12 & 63] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63]; + } + out += arr.join(""); + } + return out; +}; +function is_buffer(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); +} +function maybe_map(val, fn) { + if (isArray(val)) { + const mapped = []; + for (let i = 0; i < val.length; i += 1) { + mapped.push(fn(val[i])); + } + return mapped; + } + return fn(val); +} + +// node_modules/@stainless-api/sdk/internal/qs/stringify.mjs +var array_prefix_generators = { + brackets(prefix) { + return String(prefix) + "[]"; + }, + comma: "comma", + indices(prefix, key) { + return String(prefix) + "[" + key + "]"; + }, + repeat(prefix) { + return String(prefix); + } +}; +var push_to_array = function(arr, value_or_array) { + Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]); +}; +var toISOString; +var defaults = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: encode, + encodeValuesOnly: false, + format: default_format, + formatter: default_formatter, + /** @deprecated */ + indices: false, + serializeDate(date) { + return (toISOString ?? (toISOString = Function.prototype.call.bind(Date.prototype.toISOString)))(date); + }, + skipNulls: false, + strictNullHandling: false +}; +function is_non_nullish_primitive(v) { + return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint"; +} +var sentinel = {}; +function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { + let obj = object; + let tmp_sc = sideChannel; + let step = 0; + let find_flag = false; + while ((tmp_sc = tmp_sc.get(sentinel)) !== void 0 && !find_flag) { + const pos = tmp_sc.get(object); + step += 1; + if (typeof pos !== "undefined") { + if (pos === step) { + throw new RangeError("Cyclic object value"); + } else { + find_flag = true; + } + } + if (typeof tmp_sc.get(sentinel) === "undefined") { + step = 0; + } + } + if (typeof filter === "function") { + obj = filter(prefix, obj); + } else if (obj instanceof Date) { + obj = serializeDate?.(obj); + } else if (generateArrayPrefix === "comma" && isArray(obj)) { + obj = maybe_map(obj, function(value) { + if (value instanceof Date) { + return serializeDate?.(value); + } + return value; + }); + } + if (obj === null) { + if (strictNullHandling) { + return encoder && !encodeValuesOnly ? ( + // @ts-expect-error + encoder(prefix, defaults.encoder, charset, "key", format) + ) : prefix; + } + obj = ""; + } + if (is_non_nullish_primitive(obj) || is_buffer(obj)) { + if (encoder) { + const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format); + return [ + formatter?.(key_value) + "=" + // @ts-expect-error + formatter?.(encoder(obj, defaults.encoder, charset, "value", format)) + ]; + } + return [formatter?.(prefix) + "=" + formatter?.(String(obj))]; + } + const values = []; + if (typeof obj === "undefined") { + return values; + } + let obj_keys; + if (generateArrayPrefix === "comma" && isArray(obj)) { + if (encodeValuesOnly && encoder) { + obj = maybe_map(obj, encoder); + } + obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray(filter)) { + obj_keys = filter; + } else { + const keys = Object.keys(obj); + obj_keys = sort ? keys.sort(sort) : keys; + } + const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + const adjusted_prefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix; + if (allowEmptyArrays && isArray(obj) && obj.length === 0) { + return adjusted_prefix + "[]"; + } + for (let j = 0; j < obj_keys.length; ++j) { + const key = obj_keys[j]; + const value = ( + // @ts-ignore + typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key] + ); + if (skipNulls && value === null) { + continue; + } + const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key; + const key_prefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]"); + sideChannel.set(object, step); + const valueSideChannel = /* @__PURE__ */ new WeakMap(); + valueSideChannel.set(sentinel, sideChannel); + push_to_array(values, inner_stringify( + value, + key_prefix, + generateArrayPrefix, + commaRoundTrip, + allowEmptyArrays, + strictNullHandling, + skipNulls, + encodeDotInKeys, + // @ts-ignore + generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, + filter, + sort, + allowDots, + serializeDate, + format, + formatter, + encodeValuesOnly, + charset, + valueSideChannel + )); + } + return values; +} +function normalize_stringify_options(opts = defaults) { + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") { + throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") { + throw new TypeError("Encoder has to be a function."); + } + const charset = opts.charset || defaults.charset; + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + let format = default_format; + if (typeof opts.format !== "undefined") { + if (!has(formatters, opts.format)) { + throw new TypeError("Unknown format option provided."); + } + format = opts.format; + } + const formatter = formatters[format]; + let filter = defaults.filter; + if (typeof opts.filter === "function" || isArray(opts.filter)) { + filter = opts.filter; + } + let arrayFormat; + if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) { + arrayFormat = opts.arrayFormat; + } else if ("indices" in opts) { + arrayFormat = opts.indices ? "indices" : "repeat"; + } else { + arrayFormat = defaults.arrayFormat; + } + if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") { + throw new TypeError("`commaRoundTrip` must be a boolean, or absent"); + } + const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix, + // @ts-ignore + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays, + arrayFormat, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel, + commaRoundTrip: !!opts.commaRoundTrip, + delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter, + encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode, + encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys, + encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder, + encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly, + filter, + format, + formatter, + serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate, + skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls, + // @ts-ignore + sort: typeof opts.sort === "function" ? opts.sort : null, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling + }; +} +function stringify(object, opts = {}) { + let obj = object; + const options = normalize_stringify_options(opts); + let obj_keys; + let filter; + if (typeof options.filter === "function") { + filter = options.filter; + obj = filter("", obj); + } else if (isArray(options.filter)) { + filter = options.filter; + obj_keys = filter; + } + const keys = []; + if (typeof obj !== "object" || obj === null) { + return ""; + } + const generateArrayPrefix = array_prefix_generators[options.arrayFormat]; + const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip; + if (!obj_keys) { + obj_keys = Object.keys(obj); + } + if (options.sort) { + obj_keys.sort(options.sort); + } + const sideChannel = /* @__PURE__ */ new WeakMap(); + for (let i = 0; i < obj_keys.length; ++i) { + const key = obj_keys[i]; + if (options.skipNulls && obj[key] === null) { + continue; + } + push_to_array(keys, inner_stringify( + obj[key], + key, + // @ts-expect-error + generateArrayPrefix, + commaRoundTrip, + options.allowEmptyArrays, + options.strictNullHandling, + options.skipNulls, + options.encodeDotInKeys, + options.encode ? options.encoder : null, + options.filter, + options.sort, + options.allowDots, + options.serializeDate, + options.format, + options.formatter, + options.encodeValuesOnly, + options.charset, + sideChannel + )); + } + const joined = keys.join(options.delimiter); + let prefix = options.addQueryPrefix === true ? "?" : ""; + if (options.charsetSentinel) { + if (options.charset === "iso-8859-1") { + prefix += "utf8=%26%2310003%3B&"; + } else { + prefix += "utf8=%E2%9C%93&"; + } + } + return joined.length > 0 ? prefix + joined : ""; +} + +// node_modules/@stainless-api/sdk/internal/utils/log.mjs +var levelNumbers = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500 +}; +var parseLogLevel = (maybeLevel, sourceName, client) => { + if (!maybeLevel) { + return void 0; + } + if (hasOwn(levelNumbers, maybeLevel)) { + return maybeLevel; + } + loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`); + return void 0; +}; +function noop() { +} +function makeLogFn(fnLevel, logger, logLevel) { + if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) { + return noop; + } else { + return logger[fnLevel].bind(logger); + } +} +var noopLogger = { + error: noop, + warn: noop, + info: noop, + debug: noop +}; +var cachedLoggers = /* @__PURE__ */ new WeakMap(); +function loggerFor(client) { + const logger = client.logger; + const logLevel = client.logLevel ?? "off"; + if (!logger) { + return noopLogger; + } + const cachedLogger = cachedLoggers.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) { + return cachedLogger[1]; + } + const levelLogger = { + error: makeLogFn("error", logger, logLevel), + warn: makeLogFn("warn", logger, logLevel), + info: makeLogFn("info", logger, logLevel), + debug: makeLogFn("debug", logger, logLevel) + }; + cachedLoggers.set(logger, [logLevel, levelLogger]); + return levelLogger; +} +var formatRequestDetails = (details) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options["headers"]; + } + if (details.headers) { + details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [ + name, + name.toLowerCase() === "authorization" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value + ])); + } + if ("retryOfRequestLogID" in details) { + if (details.retryOfRequestLogID) { + details.retryOf = details.retryOfRequestLogID; + } + delete details.retryOfRequestLogID; + } + return details; +}; + +// node_modules/@stainless-api/sdk/internal/parse.mjs +async function defaultParseResponse(client, props) { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + const body = await (async () => { + if (response.status === 204) { + return null; + } + if (props.options.__binaryResponse) { + return response; + } + const contentType = response.headers.get("content-type"); + const mediaType = contentType?.split(";")[0]?.trim(); + const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json"); + if (isJSON) { + const json = await response.json(); + return json; + } + const text = await response.text(); + return text; + })(); + loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body, + durationMs: Date.now() - startTime + })); + return body; +} + +// node_modules/@stainless-api/sdk/core/api-promise.mjs +var _APIPromise_client; +var APIPromise = class _APIPromise extends Promise { + constructor(client, responsePromise, parseResponse = defaultParseResponse) { + super((resolve) => { + resolve(null); + }); + this.responsePromise = responsePromise; + this.parseResponse = parseResponse; + _APIPromise_client.set(this, void 0); + __classPrivateFieldSet(this, _APIPromise_client, client, "f"); + } + _thenUnwrap(transform) { + return new _APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props)); + } + /** + * Gets the raw `Response` instance instead of parsing the response + * data. + * + * If you want to parse the response body but still get the `Response` + * instance, you can use {@link withResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + asResponse() { + return this.responsePromise.then((p) => p.response); + } + /** + * Gets the parsed response data and the raw `Response` instance. + * + * If you just want to get the raw `Response` instance without parsing it, + * you can use {@link asResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + async withResponse() { + const [data, response] = await Promise.all([this.parse(), this.asResponse()]); + return { data, response }; + } + parse() { + if (!this.parsedPromise) { + this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet(this, _APIPromise_client, "f"), data)); + } + return this.parsedPromise; + } + then(onfulfilled, onrejected) { + return this.parse().then(onfulfilled, onrejected); + } + catch(onrejected) { + return this.parse().catch(onrejected); + } + finally(onfinally) { + return this.parse().finally(onfinally); + } +}; +_APIPromise_client = /* @__PURE__ */ new WeakMap(); + +// node_modules/@stainless-api/sdk/core/pagination.mjs +var _AbstractPage_client; +var AbstractPage = class { + constructor(client, response, body, options) { + _AbstractPage_client.set(this, void 0); + __classPrivateFieldSet(this, _AbstractPage_client, client, "f"); + this.options = options; + this.response = response; + this.body = body; + } + hasNextPage() { + const items = this.getPaginatedItems(); + if (!items.length) + return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + const nextOptions = this.nextPageRequestOptions(); + if (!nextOptions) { + throw new StainlessError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); + } + return await __classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions); + } + async *iterPages() { + let page = this; + yield page; + while (page.hasNextPage()) { + page = await page.getNextPage(); + yield page; + } + } + async *[(_AbstractPage_client = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (const page of this.iterPages()) { + for (const item of page.getPaginatedItems()) { + yield item; + } + } + } +}; +var PagePromise = class extends APIPromise { + constructor(client, request, Page2) { + super(client, request, async (client2, props) => new Page2(client2, props.response, await defaultParseResponse(client2, props), props.options)); + } + /** + * Allow auto-paginating iteration on an unawaited list call, eg: + * + * for await (const item of client.items.list()) { + * console.log(item) + * } + */ + async *[Symbol.asyncIterator]() { + const page = await this; + for await (const item of page) { + yield item; + } + } +}; +var Page = class extends AbstractPage { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body.data || []; + this.next_cursor = body.next_cursor || ""; + } + getPaginatedItems() { + return this.data ?? []; + } + nextPageRequestOptions() { + const cursor = this.next_cursor; + if (!cursor) { + return null; + } + return { + ...this.options, + query: { + ...maybeObj(this.options.query), + cursor + } + }; + } +}; + +// node_modules/@stainless-api/sdk/internal/uploads.mjs +var checkFileSupport = () => { + if (typeof File === "undefined") { + const { process: process2 } = globalThis; + const isOldNode = typeof process2?.versions?.node === "string" && parseInt(process2.versions.node.split(".")) < 20; + throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : "")); + } +}; +function makeFile(fileBits, fileName, options) { + checkFileSupport(); + return new File(fileBits, fileName ?? "unknown_file", options); +} +function getName(value) { + return (typeof value === "object" && value !== null && ("name" in value && value.name && String(value.name) || "url" in value && value.url && String(value.url) || "filename" in value && value.filename && String(value.filename) || "path" in value && value.path && String(value.path)) || "").split(/[\\/]/).pop() || void 0; +} +var isAsyncIterable = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function"; + +// node_modules/@stainless-api/sdk/internal/to-file.mjs +var isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function"; +var isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value); +var isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function"; +async function toFile(value, name, options) { + checkFileSupport(); + value = await value; + if (isFileLike(value)) { + if (value instanceof File) { + return value; + } + return makeFile([await value.arrayBuffer()], value.name); + } + if (isResponseLike(value)) { + const blob = await value.blob(); + name || (name = new URL(value.url).pathname.split(/[\\/]/).pop()); + return makeFile(await getBytes(blob), name, options); + } + const parts = await getBytes(value); + name || (name = getName(value)); + if (!options?.type) { + const type = parts.find((part) => typeof part === "object" && "type" in part && part.type); + if (typeof type === "string") { + options = { ...options, type }; + } + } + return makeFile(parts, name, options); +} +async function getBytes(value) { + let parts = []; + if (typeof value === "string" || ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc. + value instanceof ArrayBuffer) { + parts.push(value); + } else if (isBlobLike(value)) { + parts.push(value instanceof Blob ? value : await value.arrayBuffer()); + } else if (isAsyncIterable(value)) { + for await (const chunk of value) { + parts.push(...await getBytes(chunk)); + } + } else { + const constructor = value?.constructor?.name; + throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ""}${propsForError(value)}`); + } + return parts; +} +function propsForError(value) { + if (typeof value !== "object" || value === null) + return ""; + const props = Object.getOwnPropertyNames(value); + return `; props: [${props.map((p) => `"${p}"`).join(", ")}]`; +} + +// node_modules/@stainless-api/sdk/core/resource.mjs +var APIResource = class { + constructor(client) { + this._client = client; + } +}; + +// node_modules/@stainless-api/sdk/internal/utils/path.mjs +function encodeURIPath(str) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); +var createPathTagFunction = (pathEncoder = encodeURIPath) => function path3(statics, ...params) { + if (statics.length === 1) + return statics[0]; + let postPath = false; + const invalidSegments = []; + const path4 = statics.reduce((previousValue, currentValue, index) => { + if (/[?#]/.test(currentValue)) { + postPath = true; + } + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value); + if (index !== params.length && (value == null || typeof value === "object" && // handle values from other realms + value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)?.toString)) { + encoded = value + ""; + invalidSegments.push({ + start: previousValue.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter` + }); + } + return previousValue + currentValue + (index === params.length ? "" : encoded); + }, ""); + const pathOnly = path4.split(/[?#]/, 1)[0]; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { + invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can't be safely passed as a path parameter` + }); + } + invalidSegments.sort((a, b) => a.start - b.start); + if (invalidSegments.length > 0) { + let lastEnd = 0; + const underline = invalidSegments.reduce((acc, segment) => { + const spaces = " ".repeat(segment.start - lastEnd); + const arrows = "^".repeat(segment.length); + lastEnd = segment.start + segment.length; + return acc + spaces + arrows; + }, ""); + throw new StainlessError(`Path parameters result in path with invalid segments: +${invalidSegments.map((e) => e.error).join("\n")} +${path4} +${underline}`); + } + return path4; +}; +var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath); + +// node_modules/@stainless-api/sdk/resources/builds/diagnostics.mjs +var Diagnostics = class extends APIResource { + /** + * Get diagnostics for a build + */ + list(buildID, query = {}, options) { + return this._client.getAPIList(path`/v0/builds/${buildID}/diagnostics`, Page, { + query, + ...options + }); + } +}; + +// node_modules/@stainless-api/sdk/resources/builds/target-outputs.mjs +var TargetOutputs = class extends APIResource { + /** + * Download the output of a build target + */ + retrieve(query, options) { + return this._client.get("/v0/build_target_outputs", { query, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/builds/builds.mjs +var Builds = class extends APIResource { + constructor() { + super(...arguments); + this.diagnostics = new Diagnostics(this._client); + this.targetOutputs = new TargetOutputs(this._client); + } + /** + * Create a new build + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds", { body: { project, ...body }, ...options }); + } + /** + * Retrieve a build by ID + */ + retrieve(buildID, options) { + return this._client.get(path`/v0/builds/${buildID}`, options); + } + /** + * List builds for a project + */ + list(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.getAPIList("/v0/builds", Page, { + query: { project, ...query }, + ...options + }); + } + /** + * Creates two builds whose outputs can be compared directly + */ + compare(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/builds/compare", { body: { project, ...body }, ...options }); + } +}; +Builds.Diagnostics = Diagnostics; +Builds.TargetOutputs = TargetOutputs; + +// node_modules/@stainless-api/sdk/resources/generate.mjs +var Generate = class extends APIResource { + createSpec(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post("/v0/generate/spec", { body: { project, ...body }, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/orgs.mjs +var Orgs = class extends APIResource { + /** + * Retrieve an organization by name + */ + retrieve(org, options) { + return this._client.get(path`/v0/orgs/${org}`, options); + } + /** + * List organizations the user has access to + */ + list(options) { + return this._client.get("/v0/orgs", options); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/branches.mjs +var Branches = class extends APIResource { + /** + * Create a new branch for a project + */ + create(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/branches`, { body, ...options }); + } + /** + * Retrieve a project branch + */ + retrieve(branch, params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/branches/${branch}`, options); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/configs.mjs +var Configs = class extends APIResource { + /** + * Retrieve configuration files for a project + */ + retrieve(params = {}, options) { + const { project = this._client.project, ...query } = params ?? {}; + return this._client.get(path`/v0/projects/${project}/configs`, { query, ...options }); + } + /** + * Generate configuration suggestions based on an OpenAPI spec + */ + guess(params, options) { + const { project = this._client.project, ...body } = params; + return this._client.post(path`/v0/projects/${project}/configs/guess`, { body, ...options }); + } +}; + +// node_modules/@stainless-api/sdk/resources/projects/projects.mjs +var Projects = class extends APIResource { + constructor() { + super(...arguments); + this.branches = new Branches(this._client); + this.configs = new Configs(this._client); + } + /** + * Create a new project + */ + create(body, options) { + return this._client.post("/v0/projects", { body, ...options }); + } + /** + * Retrieve a project by name + */ + retrieve(params = {}, options) { + const { project = this._client.project } = params ?? {}; + return this._client.get(path`/v0/projects/${project}`, options); + } + /** + * Update a project's properties + */ + update(params = {}, options) { + const { project = this._client.project, ...body } = params ?? {}; + return this._client.patch(path`/v0/projects/${project}`, { body, ...options }); + } + /** + * List projects in an organization, from oldest to newest + */ + list(query = {}, options) { + return this._client.getAPIList("/v0/projects", Page, { query, ...options }); + } +}; +Projects.Branches = Branches; +Projects.Configs = Configs; + +// node_modules/@stainless-api/sdk/internal/headers.mjs +var brand_privateNullableHeaders = /* @__PURE__ */ Symbol("brand.privateNullableHeaders"); +function* iterateHeaders(headers) { + if (!headers) + return; + if (brand_privateNullableHeaders in headers) { + const { values, nulls } = headers; + yield* values.entries(); + for (const name of nulls) { + yield [name, null]; + } + return; + } + let shouldClear = false; + let iter; + if (headers instanceof Headers) { + iter = headers.entries(); + } else if (isReadonlyArray(headers)) { + iter = headers; + } else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== "string") + throw new TypeError("expected header name to be a string"); + const values = isReadonlyArray(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === void 0) + continue; + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} +var buildHeaders = (newHeaders) => { + const targetHeaders = new Headers(); + const nullHeaders = /* @__PURE__ */ new Set(); + for (const headers of newHeaders) { + const seenHeaders = /* @__PURE__ */ new Set(); + for (const [name, value] of iterateHeaders(headers)) { + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(name); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(name); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(name, value); + nullHeaders.delete(lowerName); + } + } + } + return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders }; +}; + +// node_modules/@stainless-api/sdk/internal/utils/env.mjs +var readEnv = (env) => { + if (typeof globalThis.process !== "undefined") { + return globalThis.process.env?.[env]?.trim() ?? void 0; + } + if (typeof globalThis.Deno !== "undefined") { + return globalThis.Deno.env?.get?.(env)?.trim(); + } + return void 0; +}; + +// node_modules/@stainless-api/sdk/lib/unwrap.mjs +async function unwrapFile(value) { + if (value === null) { + return null; + } + if (value.type === "content") { + return value.content; + } + const response = await fetch(value.url); + return response.text(); +} + +// node_modules/@stainless-api/sdk/client.mjs +var _Stainless_instances; +var _a; +var _Stainless_encoder; +var _Stainless_baseURLOverridden; +var Stainless = class { + /** + * API Client for interfacing with the Stainless API. + * + * @param {string | null | undefined} [opts.apiKey=process.env['STAINLESS_API_KEY'] ?? null] + * @param {string | null | undefined} [opts.project] + * @param {string} [opts.baseURL=process.env['STAINLESS_BASE_URL'] ?? https://api.stainless.com] - Override the default base URL for the API. + * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out. + * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls. + * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation. + * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request. + * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API. + * @param {Record} opts.defaultQuery - Default query parameters to include with every request to the API. + */ + constructor({ baseURL = readEnv("STAINLESS_BASE_URL"), apiKey = readEnv("STAINLESS_API_KEY") ?? null, project = null, ...opts } = {}) { + _Stainless_instances.add(this); + _Stainless_encoder.set(this, void 0); + this.projects = new Projects(this); + this.builds = new Builds(this); + this.orgs = new Orgs(this); + this.generate = new Generate(this); + const options = { + apiKey, + project, + ...opts, + baseURL: baseURL || `https://api.stainless.com` + }; + this.baseURL = options.baseURL; + this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT; + this.logger = options.logger ?? console; + const defaultLogLevel = "warn"; + this.logLevel = defaultLogLevel; + this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("STAINLESS_LOG"), "process.env['STAINLESS_LOG']", this) ?? defaultLogLevel; + this.fetchOptions = options.fetchOptions; + this.maxRetries = options.maxRetries ?? 2; + this.fetch = options.fetch ?? getDefaultFetch(); + __classPrivateFieldSet(this, _Stainless_encoder, FallbackEncoder, "f"); + this._options = options; + this.apiKey = apiKey; + this.project = project; + } + /** + * Create a new client instance re-using the same options given to the current client with optional overriding. + */ + withOptions(options) { + return new this.constructor({ + ...this._options, + baseURL: this.baseURL, + maxRetries: this.maxRetries, + timeout: this.timeout, + logger: this.logger, + logLevel: this.logLevel, + fetch: this.fetch, + fetchOptions: this.fetchOptions, + apiKey: this.apiKey, + project: this.project, + ...options + }); + } + defaultQuery() { + return this._options.defaultQuery; + } + validateHeaders({ values, nulls }) { + if (this.apiKey && values.get("authorization")) { + return; + } + if (nulls.has("authorization")) { + return; + } + throw new Error('Could not resolve authentication method. Expected the apiKey to be set. Or for the "Authorization" headers to be explicitly omitted'); + } + authHeaders(opts) { + if (this.apiKey == null) { + return void 0; + } + return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]); + } + stringifyQuery(query) { + return stringify(query, { arrayFormat: "comma" }); + } + getUserAgent() { + return `${this.constructor.name}/JS ${VERSION}`; + } + defaultIdempotencyKey() { + return `stainless-node-retry-${uuid4()}`; + } + makeStatusError(status, error, message, headers) { + return APIError.generate(status, error, message, headers); + } + buildURL(path3, query, defaultBaseURL) { + const baseURL = !__classPrivateFieldGet(this, _Stainless_instances, "m", _Stainless_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL; + const url = isAbsoluteURL(path3) ? new URL(path3) : new URL(baseURL + (baseURL.endsWith("/") && path3.startsWith("/") ? path3.slice(1) : path3)); + const defaultQuery = this.defaultQuery(); + if (!isEmptyObj(defaultQuery)) { + query = { ...defaultQuery, ...query }; + } + if (typeof query === "object" && query && !Array.isArray(query)) { + url.search = this.stringifyQuery(query); + } + return url.toString(); + } + /** + * Used as a callback for mutating the given `FinalRequestOptions` object. + */ + async prepareOptions(options) { + } + /** + * Used as a callback for mutating the given `RequestInit` object. + * + * This is useful for cases where you want to add certain headers based off of + * the request properties, e.g. `method` or `url`. + */ + async prepareRequest(request, { url, options }) { + } + get(path3, opts) { + return this.methodRequest("get", path3, opts); + } + post(path3, opts) { + return this.methodRequest("post", path3, opts); + } + patch(path3, opts) { + return this.methodRequest("patch", path3, opts); + } + put(path3, opts) { + return this.methodRequest("put", path3, opts); + } + delete(path3, opts) { + return this.methodRequest("delete", path3, opts); + } + methodRequest(method, path3, opts) { + return this.request(Promise.resolve(opts).then((opts2) => { + return { method, path: path3, ...opts2 }; + })); + } + request(options, remainingRetries = null) { + return new APIPromise(this, this.makeRequest(options, remainingRetries, void 0)); + } + async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { + const options = await optionsInput; + const maxRetries = options.maxRetries ?? this.maxRetries; + if (retriesRemaining == null) { + retriesRemaining = maxRetries; + } + await this.prepareOptions(options); + const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); + await this.prepareRequest(req, { url, options }); + const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0"); + const retryLogStr = retryOfRequestLogID === void 0 ? "" : `, retryOf: ${retryOfRequestLogID}`; + const startTime = Date.now(); + loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({ + retryOfRequestLogID, + method: options.method, + url, + options, + headers: req.headers + })); + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const controller = new AbortController(); + const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError); + const headersTime = Date.now(); + if (response instanceof Error) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (options.signal?.aborted) { + throw new APIUserAbortError(); + } + const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : "")); + if (retriesRemaining) { + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID); + } + loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`); + loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + if (isTimeout) { + throw new APIConnectionTimeoutError(); + } + throw new APIConnectionError({ cause: response }); + } + const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`; + if (!response.ok) { + const shouldRetry = this.shouldRetry(response); + if (retriesRemaining && shouldRetry) { + const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`; + await CancelReadableStream(response.body); + loggerFor(this).info(`${responseInfo} - ${retryMessage2}`); + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers); + } + const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`; + loggerFor(this).info(`${responseInfo} - ${retryMessage}`); + const errText = await response.text().catch((err2) => castToError(err2).message); + const errJSON = safeJSON(errText); + const errMessage = errJSON ? void 0 : errText; + loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + message: errMessage, + durationMs: Date.now() - startTime + })); + const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers); + throw err; + } + loggerFor(this).info(responseInfo); + loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return { response, options, controller, requestLogID, retryOfRequestLogID, startTime }; + } + getAPIList(path3, Page2, opts) { + return this.requestAPIList(Page2, { method: "get", path: path3, ...opts }); + } + requestAPIList(Page2, options) { + const request = this.makeRequest(options, null, void 0); + return new PagePromise(this, request, Page2); + } + async fetchWithTimeout(url, init, ms, controller) { + const { signal, method, ...options } = init || {}; + if (signal) + signal.addEventListener("abort", () => controller.abort()); + const timeout = setTimeout(() => controller.abort(), ms); + const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body; + const fetchOptions = { + signal: controller.signal, + ...isReadableBody ? { duplex: "half" } : {}, + method: "GET", + ...options + }; + if (method) { + fetchOptions.method = method.toUpperCase(); + } + try { + return await this.fetch.call(void 0, url, fetchOptions); + } finally { + clearTimeout(timeout); + } + } + shouldRetry(response) { + const shouldRetryHeader = response.headers.get("x-should-retry"); + if (shouldRetryHeader === "true") + return true; + if (shouldRetryHeader === "false") + return false; + if (response.status === 408) + return true; + if (response.status === 409) + return true; + if (response.status === 429) + return true; + if (response.status >= 500) + return true; + return false; + } + async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) { + let timeoutMillis; + const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms"); + if (retryAfterMillisHeader) { + const timeoutMs = parseFloat(retryAfterMillisHeader); + if (!Number.isNaN(timeoutMs)) { + timeoutMillis = timeoutMs; + } + } + const retryAfterHeader = responseHeaders?.get("retry-after"); + if (retryAfterHeader && !timeoutMillis) { + const timeoutSeconds = parseFloat(retryAfterHeader); + if (!Number.isNaN(timeoutSeconds)) { + timeoutMillis = timeoutSeconds * 1e3; + } else { + timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + } + if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3)) { + const maxRetries = options.maxRetries ?? this.maxRetries; + timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); + } + await sleep(timeoutMillis); + return this.makeRequest(options, retriesRemaining - 1, requestLogID); + } + calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) { + const initialRetryDelay = 0.5; + const maxRetryDelay = 8; + const numRetries = maxRetries - retriesRemaining; + const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay); + const jitter = 1 - Math.random() * 0.25; + return sleepSeconds * jitter * 1e3; + } + buildRequest(inputOptions, { retryCount = 0 } = {}) { + const options = { ...inputOptions }; + const { method, path: path3, query, defaultBaseURL } = options; + const url = this.buildURL(path3, query, defaultBaseURL); + if ("timeout" in options) + validatePositiveInteger("timeout", options.timeout); + options.timeout = options.timeout ?? this.timeout; + const { bodyHeaders, body } = this.buildBody({ options }); + const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount }); + const req = { + method, + headers: reqHeaders, + ...options.signal && { signal: options.signal }, + ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" }, + ...body && { body }, + ...this.fetchOptions ?? {}, + ...options.fetchOptions ?? {} + }; + return { req, url, timeout: options.timeout }; + } + buildHeaders({ options, method, bodyHeaders, retryCount }) { + let idempotencyHeaders = {}; + if (this.idempotencyHeader && method !== "get") { + if (!options.idempotencyKey) + options.idempotencyKey = this.defaultIdempotencyKey(); + idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; + } + const headers = buildHeaders([ + idempotencyHeaders, + { + Accept: "application/json", + "User-Agent": this.getUserAgent(), + "X-Stainless-Retry-Count": String(retryCount), + ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1e3)) } : {}, + ...getPlatformHeaders() + }, + this.authHeaders(options), + this._options.defaultHeaders, + bodyHeaders, + options.headers + ]); + this.validateHeaders(headers); + return headers.values; + } + buildBody({ options: { body, headers: rawHeaders } }) { + if (!body) { + return { bodyHeaders: void 0, body: void 0 }; + } + const headers = buildHeaders([rawHeaders]); + if ( + // Pass raw type verbatim + ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && // Preserve legacy string encoding behavior for now + headers.values.has("content-type") || // `Blob` is superset of `File` + body instanceof Blob || // `FormData` -> `multipart/form-data` + body instanceof FormData || // `URLSearchParams` -> `application/x-www-form-urlencoded` + body instanceof URLSearchParams || // Send chunked stream (each chunk has own `length`) + globalThis.ReadableStream && body instanceof globalThis.ReadableStream + ) { + return { bodyHeaders: void 0, body }; + } else if (typeof body === "object" && (Symbol.asyncIterator in body || Symbol.iterator in body && "next" in body && typeof body.next === "function")) { + return { bodyHeaders: void 0, body: ReadableStreamFrom(body) }; + } else { + return __classPrivateFieldGet(this, _Stainless_encoder, "f").call(this, { body, headers }); + } + } +}; +_a = Stainless, _Stainless_encoder = /* @__PURE__ */ new WeakMap(), _Stainless_instances = /* @__PURE__ */ new WeakSet(), _Stainless_baseURLOverridden = function _Stainless_baseURLOverridden2() { + return this.baseURL !== "https://api.stainless.com"; +}; +Stainless.Stainless = _a; +Stainless.DEFAULT_TIMEOUT = 6e4; +Stainless.StainlessError = StainlessError; +Stainless.APIError = APIError; +Stainless.APIConnectionError = APIConnectionError; +Stainless.APIConnectionTimeoutError = APIConnectionTimeoutError; +Stainless.APIUserAbortError = APIUserAbortError; +Stainless.NotFoundError = NotFoundError; +Stainless.ConflictError = ConflictError; +Stainless.RateLimitError = RateLimitError; +Stainless.BadRequestError = BadRequestError; +Stainless.AuthenticationError = AuthenticationError; +Stainless.InternalServerError = InternalServerError; +Stainless.PermissionDeniedError = PermissionDeniedError; +Stainless.UnprocessableEntityError = UnprocessableEntityError; +Stainless.toFile = toFile; +Stainless.unwrapFile = unwrapFile; +Stainless.Projects = Projects; +Stainless.Builds = Builds; +Stainless.Orgs = Orgs; +Stainless.Generate = Generate; + +// src/runBuilds.ts +var fs = __toESM(require("fs")); +var CONVENTIONAL_COMMIT_REGEX = new RegExp( + /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?(!?): .*$/ +); +var isValidConventionalCommitMessage = (message) => { + return CONVENTIONAL_COMMIT_REGEX.test(message); +}; +var POLLING_INTERVAL_SECONDS = 5; +var MAX_POLLING_SECONDS = 10 * 60; +async function* runBuilds({ + stainless, + projectName, + baseRevision, + baseBranch, + mergeBranch, + branch, + oasPath, + configPath, + guessConfig = false, + commitMessage, + outputDir +}) { + if (mergeBranch && (oasPath || configPath)) { + throw new Error( + "Cannot specify both merge_branch and oas_path or config_path" + ); + } + if (guessConfig && (configPath || !oasPath)) { + throw new Error( + "If guess_config is true, must have oas_path and no config_path" + ); + } + if (baseRevision && mergeBranch) { + throw new Error("Cannot specify both base_revision and merge_branch"); + } + if (commitMessage && !isValidConventionalCommitMessage(commitMessage)) { + console.warn( + `Commit message: "${commitMessage}" is not in Conventional Commits format: https://www.conventionalcommits.org/en/v1.0.0/. Prepending "feat" and using anyway.` + ); + commitMessage = `feat: ${commitMessage}`; + } + const oasContent = oasPath ? fs.readFileSync(oasPath, "utf-8") : void 0; + let configContent = configPath ? fs.readFileSync(configPath, "utf-8") : void 0; + if (!baseRevision) { + const build = await stainless.builds.create( + { + project: projectName, + revision: mergeBranch ? `${branch}..${mergeBranch}` : { + ...oasContent && { + "openapi.yml": { + content: oasContent + } + }, + ...configContent && { + "openapi.stainless.yml": { + content: configContent + } + } + }, + branch, + commit_message: commitMessage, + allow_empty: true + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1e3 + } + ); + for (const waitFor of ["postgen", "completed"]) { + const { outcomes, documentedSpec } = await pollBuild({ + stainless, + build, + waitFor + }); + let documentedSpecPath = null; + if (outputDir && documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, documentedSpec); + } + yield { + baseOutcomes: null, + outcomes, + documentedSpecPath + }; + } + return; + } + if (!configContent) { + if (guessConfig) { + console.log("Guessing config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.guess({ + branch, + spec: oasContent + }) + )[0]?.content; + } else { + console.log("Saving config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.retrieve({ + branch + }) + )[0]?.content; + } + } + console.log(`Hard resetting ${branch} to ${baseRevision}`); + const { config_commit } = await stainless.projects.branches.create({ + branch_from: baseRevision, + branch, + force: true + }); + console.log(`Hard reset ${branch}, now at ${config_commit.sha}`); + const { base, head } = await stainless.builds.compare( + { + base: { + revision: baseRevision, + branch: baseBranch, + commit_message: commitMessage + }, + head: { + revision: { + ...oasContent && { + "openapi.yml": { + content: oasContent + } + }, + ...configContent && { + "openapi.stainless.yml": { + content: configContent + } + } + }, + branch, + commit_message: commitMessage + } + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1e3 + } + ); + for (const waitFor of ["postgen", "completed"]) { + const results = await Promise.all([ + pollBuild({ stainless, build: base, waitFor }), + pollBuild({ stainless, build: head, waitFor }) + ]); + let documentedSpecPath = null; + if (outputDir && results[1].documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, results[1].documentedSpec); + } + yield { + baseOutcomes: results[0].outcomes, + outcomes: results[1].outcomes, + documentedSpecPath + }; + } + return; +} +async function pollBuild({ + stainless, + build, + waitFor, + pollingIntervalSeconds = POLLING_INTERVAL_SECONDS, + maxPollingSeconds = MAX_POLLING_SECONDS +}) { + const outcomes = {}; + let documentedSpec = null; + const buildId = build.id; + const languages = Object.keys(build.targets); + if (buildId) { + console.log( + `[${buildId}] Created build against ${build.config_commit} for languages: ${languages.join(", ")}` + ); + } else { + console.log(`No new build was created; exiting.`); + return { outcomes, documentedSpec }; + } + const pollingStart = Date.now(); + while (Object.keys(outcomes).length < languages.length && Date.now() - pollingStart < maxPollingSeconds * 1e3) { + const build2 = await stainless.builds.retrieve(buildId); + for (const language of languages) { + if (!(language in outcomes)) { + const buildOutput = build2.targets[language]; + console.log( + `[${buildId}] Build for ${language} has status ${buildOutput.status}` + ); + if ([waitFor, "completed"].includes(buildOutput.status) && buildOutput.commit.status === "completed") { + console.log( + `[${buildId}] Build has output:`, + JSON.stringify(buildOutput) + ); + const diagnostics = []; + try { + for await (const diagnostic of stainless.builds.diagnostics.list( + buildId + )) { + diagnostics.push(diagnostic); + } + } catch (e) { + console.error( + `[${buildId}] Error getting diagnostics, continuing anyway`, + e + ); + } + outcomes[language] = { + ...buildOutput, + commit: buildOutput.commit, + diagnostics + }; + } + } + } + if (!documentedSpec && build2.documented_spec) { + documentedSpec = await Stainless.unwrapFile(build2.documented_spec); + } + await new Promise( + (resolve) => setTimeout(resolve, pollingIntervalSeconds * 1e3) + ); + } + const languagesWithoutOutcome = languages.filter( + (language) => !(language in outcomes) + ); + for (const language of languagesWithoutOutcome) { + console.log( + `[${buildId}] Build for ${language} timed out after ${maxPollingSeconds} seconds` + ); + outcomes[language] = { + object: "build_target", + status: "completed", + lint: { + status: "not_started" + }, + test: { + status: "not_started" + }, + commit: { + status: "completed", + completed: { + conclusion: "timed_out", + commit: null, + merge_conflict_pr: null, + url: null + } + }, + diagnostics: [] + }; + } + return { outcomes, documentedSpec }; +} +function checkResults({ + outcomes, + failRunOn +}) { + if (failRunOn === "never") { + return true; + } + const failedLanguages = Object.entries(outcomes).filter(([_, outcome]) => { + if (!outcome.commit || outcome.commit.completed.conclusion === "noop") { + return true; + } + if (failRunOn === "error" || failRunOn === "warning" || failRunOn === "note") { + if (outcome.commit.completed.conclusion === "error") return true; + } + if (failRunOn === "warning" || failRunOn === "note") { + if (outcome.commit.completed.conclusion === "warning") return true; + } + if (failRunOn === "note") { + if (outcome.commit.completed.conclusion === "note") return true; + } + return false; + }); + if (failedLanguages.length > 0) { + console.log( + `The following languages did not build successfully: ${failedLanguages.map(([lang]) => lang).join(", ")}` + ); + return false; + } + return true; +} + +// src/comment.ts +var github = __toESM(require_github()); + +// node_modules/@stainless-api/github-internal/core/resource.mjs +var APIResource2 = /* @__PURE__ */ (() => { + class APIResource3 { + constructor(client) { + this._client = client; + } + } + APIResource3._key = []; + return APIResource3; +})(); + +// node_modules/@stainless-api/github-internal/internal/tslib.mjs +function __classPrivateFieldSet2(receiver, state, value, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +function __classPrivateFieldGet2(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +// node_modules/@stainless-api/github-internal/internal/errors.mjs +function isAbortError2(err) { + return typeof err === "object" && err !== null && // Spec-compliant fetch implementations + ("name" in err && err.name === "AbortError" || // Expo fetch + "message" in err && String(err.message).includes("FetchRequestCanceledException")); +} +var castToError2 = (err) => { + if (err instanceof Error) + return err; + if (typeof err === "object" && err !== null) { + try { + if (Object.prototype.toString.call(err) === "[object Error]") { + const error = new Error(err.message, err.cause ? { cause: err.cause } : {}); + if (err.stack) + error.stack = err.stack; + if (err.cause && !error.cause) + error.cause = err.cause; + if (err.name) + error.name = err.name; + return error; + } + } catch { + } + try { + return new Error(JSON.stringify(err)); + } catch { + } + } + return new Error(err); +}; + +// node_modules/@stainless-api/github-internal/core/error.mjs +var GitHubError = /* @__PURE__ */ (() => { + class GitHubError2 extends Error { + } + return GitHubError2; +})(); +var APIError2 = class _APIError extends GitHubError { + constructor(status, error, message, headers) { + super(`${_APIError.makeMessage(status, error, message)}`); + this.status = status; + this.headers = headers; + this.error = error; + } + static makeMessage(status, error, message) { + const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message; + if (status && msg) { + return `${status} ${msg}`; + } + if (status) { + return `${status} status code (no body)`; + } + if (msg) { + return msg; + } + return "(no status code or body)"; + } + static generate(status, errorResponse, message, headers) { + if (!status || !headers) { + return new APIConnectionError2({ message, cause: castToError2(errorResponse) }); + } + const error = errorResponse; + if (status === 400) { + return new BadRequestError2(status, error, message, headers); + } + if (status === 401) { + return new AuthenticationError2(status, error, message, headers); + } + if (status === 403) { + return new PermissionDeniedError2(status, error, message, headers); + } + if (status === 404) { + return new NotFoundError2(status, error, message, headers); + } + if (status === 409) { + return new ConflictError2(status, error, message, headers); + } + if (status === 422) { + return new UnprocessableEntityError2(status, error, message, headers); + } + if (status === 429) { + return new RateLimitError2(status, error, message, headers); + } + if (status >= 500) { + return new InternalServerError2(status, error, message, headers); + } + return new _APIError(status, error, message, headers); + } +}; +var APIUserAbortError2 = class extends APIError2 { + constructor({ message } = {}) { + super(void 0, void 0, message || "Request was aborted.", void 0); + } +}; +var APIConnectionError2 = class extends APIError2 { + constructor({ message, cause }) { + super(void 0, void 0, message || "Connection error.", void 0); + if (cause) + this.cause = cause; + } +}; +var APIConnectionTimeoutError2 = class extends APIConnectionError2 { + constructor({ message } = {}) { + super({ message: message ?? "Request timed out." }); + } +}; +var BadRequestError2 = class extends APIError2 { +}; +var AuthenticationError2 = class extends APIError2 { +}; +var PermissionDeniedError2 = class extends APIError2 { +}; +var NotFoundError2 = class extends APIError2 { +}; +var ConflictError2 = class extends APIError2 { +}; +var UnprocessableEntityError2 = class extends APIError2 { +}; +var RateLimitError2 = class extends APIError2 { +}; +var InternalServerError2 = class extends APIError2 { +}; + +// node_modules/@stainless-api/github-internal/internal/utils/values.mjs +var startsWithSchemeRegexp2 = /^[a-z][a-z0-9+.-]*:/i; +var isAbsoluteURL2 = (url) => { + return startsWithSchemeRegexp2.test(url); +}; +var isArray2 = (val) => (isArray2 = Array.isArray, isArray2(val)); +var isReadonlyArray2 = isArray2; +function maybeObj2(x) { + if (typeof x !== "object") { + return {}; + } + return x ?? {}; +} +function isEmptyObj2(obj) { + if (!obj) + return true; + for (const _k in obj) + return false; + return true; +} +function hasOwn2(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} +var validatePositiveInteger2 = (name, n) => { + if (typeof n !== "number" || !Number.isInteger(n)) { + throw new GitHubError(`${name} must be an integer`); + } + if (n < 0) { + throw new GitHubError(`${name} must be a positive integer`); + } + return n; +}; +var safeJSON2 = (text) => { + try { + return JSON.parse(text); + } catch (err) { + return void 0; + } +}; + +// node_modules/@stainless-api/github-internal/internal/utils/log.mjs +var levelNumbers2 = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500 +}; +var parseLogLevel2 = (maybeLevel, sourceName, client) => { + if (!maybeLevel) { + return void 0; + } + if (hasOwn2(levelNumbers2, maybeLevel)) { + return maybeLevel; + } + loggerFor2(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers2))}`); + return void 0; +}; +function noop2() { +} +function makeLogFn2(fnLevel, logger, logLevel) { + if (!logger || levelNumbers2[fnLevel] > levelNumbers2[logLevel]) { + return noop2; + } else { + return logger[fnLevel].bind(logger); + } +} +var noopLogger2 = { + error: noop2, + warn: noop2, + info: noop2, + debug: noop2 +}; +var cachedLoggers2 = /* @__PURE__ */ new WeakMap(); +function loggerFor2(client) { + const logger = client.logger; + const logLevel = client.logLevel ?? "off"; + if (!logger) { + return noopLogger2; + } + const cachedLogger = cachedLoggers2.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) { + return cachedLogger[1]; + } + const levelLogger = { + error: makeLogFn2("error", logger, logLevel), + warn: makeLogFn2("warn", logger, logLevel), + info: makeLogFn2("info", logger, logLevel), + debug: makeLogFn2("debug", logger, logLevel) + }; + cachedLoggers2.set(logger, [logLevel, levelLogger]); + return levelLogger; +} +var formatRequestDetails2 = (details) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options["headers"]; + } + if (details.headers) { + details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [ + name, + name.toLowerCase() === "authorization" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value + ])); + } + if ("retryOfRequestLogID" in details) { + if (details.retryOfRequestLogID) { + details.retryOf = details.retryOfRequestLogID; + } + delete details.retryOfRequestLogID; + } + return details; +}; + +// node_modules/@stainless-api/github-internal/internal/parse.mjs +async function defaultParseResponse2(client, props) { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + const body = await (async () => { + if (response.status === 204) { + return null; + } + if (props.options.__binaryResponse) { + return response; + } + const contentType = response.headers.get("content-type"); + const mediaType = contentType?.split(";")[0]?.trim(); + const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json"); + if (isJSON) { + const json = await response.json(); + return json; + } + const text = await response.text(); + return text; + })(); + loggerFor2(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body, + durationMs: Date.now() - startTime + })); + return body; +} + +// node_modules/@stainless-api/github-internal/core/api-promise.mjs +var _APIPromise_client2; +var APIPromise2 = /* @__PURE__ */ (() => { + class APIPromise3 extends Promise { + constructor(client, responsePromise, parseResponse = defaultParseResponse2) { + super((resolve) => { + resolve(null); + }); + this.responsePromise = responsePromise; + this.parseResponse = parseResponse; + _APIPromise_client2.set(this, void 0); + __classPrivateFieldSet2(this, _APIPromise_client2, client, "f"); + } + _thenUnwrap(transform) { + return new APIPromise3(__classPrivateFieldGet2(this, _APIPromise_client2, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props)); + } + /** + * Gets the raw `Response` instance instead of parsing the response + * data. + * + * If you want to parse the response body but still get the `Response` + * instance, you can use {@link withResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + asResponse() { + return this.responsePromise.then((p) => p.response); + } + /** + * Gets the parsed response data and the raw `Response` instance. + * + * If you just want to get the raw `Response` instance without parsing it, + * you can use {@link asResponse()}. + * + * 👋 Getting the wrong TypeScript type for `Response`? + * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]` + * to your `tsconfig.json`. + */ + async withResponse() { + const [data, response] = await Promise.all([this.parse(), this.asResponse()]); + return { data, response }; + } + parse() { + if (!this.parsedPromise) { + this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet2(this, _APIPromise_client2, "f"), data)); + } + return this.parsedPromise; + } + then(onfulfilled, onrejected) { + return this.parse().then(onfulfilled, onrejected); + } + catch(onrejected) { + return this.parse().catch(onrejected); + } + finally(onfinally) { + return this.parse().finally(onfinally); + } + } + _APIPromise_client2 = /* @__PURE__ */ new WeakMap(); + return APIPromise3; +})(); + +// node_modules/@stainless-api/github-internal/core/pagination.mjs +var _AbstractPage_client2; +var AbstractPage2 = /* @__PURE__ */ (() => { + class AbstractPage3 { + constructor(client, response, body, options) { + _AbstractPage_client2.set(this, void 0); + __classPrivateFieldSet2(this, _AbstractPage_client2, client, "f"); + this.options = options; + this.response = response; + this.body = body; + } + hasNextPage() { + const items = this.getPaginatedItems(); + if (!items.length) + return false; + return this.nextPageRequestOptions() != null; + } + async getNextPage() { + const nextOptions = this.nextPageRequestOptions(); + if (!nextOptions) { + throw new GitHubError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."); + } + return await __classPrivateFieldGet2(this, _AbstractPage_client2, "f").requestAPIList(this.constructor, nextOptions); + } + async *iterPages() { + let page = this; + yield page; + while (page.hasNextPage()) { + page = await page.getNextPage(); + yield page; + } + } + async *[(_AbstractPage_client2 = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() { + for await (const page of this.iterPages()) { + for (const item of page.getPaginatedItems()) { + yield item; + } + } + } + } + return AbstractPage3; +})(); +var PagePromise2 = /* @__PURE__ */ (() => { + class PagePromise3 extends APIPromise2 { + constructor(client, request, Page2) { + super(client, request, async (client2, props) => new Page2(client2, props.response, await defaultParseResponse2(client2, props), props.options)); + } + /** + * Allow auto-paginating iteration on an unawaited list call, eg: + * + * for await (const item of client.items.list()) { + * console.log(item) + * } + */ + async *[Symbol.asyncIterator]() { + const page = await this; + for await (const item of page) { + yield item; + } + } + } + return PagePromise3; +})(); +var NumberedPage = class extends AbstractPage2 { + constructor(client, response, body, options) { + super(client, response, body, options); + this.data = body || []; + } + getPaginatedItems() { + return this.data ?? []; + } + nextPageRequestOptions() { + const query = this.options.query; + const currentPage = query?.page ?? 1; + return { + ...this.options, + query: { + ...maybeObj2(this.options.query), + page: currentPage + 1 + } + }; + } +}; + +// node_modules/@stainless-api/github-internal/internal/headers.mjs +var brand_privateNullableHeaders2 = /* @__PURE__ */ Symbol("brand.privateNullableHeaders"); +function* iterateHeaders2(headers) { + if (!headers) + return; + if (brand_privateNullableHeaders2 in headers) { + const { values, nulls } = headers; + yield* values.entries(); + for (const name of nulls) { + yield [name, null]; + } + return; + } + let shouldClear = false; + let iter; + if (headers instanceof Headers) { + iter = headers.entries(); + } else if (isReadonlyArray2(headers)) { + iter = headers; + } else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== "string") + throw new TypeError("expected header name to be a string"); + const values = isReadonlyArray2(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === void 0) + continue; + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} +var buildHeaders2 = (newHeaders) => { + const targetHeaders = new Headers(); + const nullHeaders = /* @__PURE__ */ new Set(); + for (const headers of newHeaders) { + const seenHeaders = /* @__PURE__ */ new Set(); + for (const [name, value] of iterateHeaders2(headers)) { + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(name); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(name); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(name, value); + nullHeaders.delete(lowerName); + } + } + } + return { [brand_privateNullableHeaders2]: true, values: targetHeaders, nulls: nullHeaders }; +}; + +// node_modules/@stainless-api/github-internal/internal/utils/path.mjs +function encodeURIPath2(str) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} +var EMPTY2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); +var createPathTagFunction2 = (pathEncoder = encodeURIPath2) => function path3(statics, ...params) { + if (statics.length === 1) + return statics[0]; + let postPath = false; + const invalidSegments = []; + const path4 = statics.reduce((previousValue, currentValue, index) => { + if (/[?#]/.test(currentValue)) { + postPath = true; + } + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value); + if (index !== params.length && (value == null || typeof value === "object" && // handle values from other realms + value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY2) ?? EMPTY2)?.toString)) { + encoded = value + ""; + invalidSegments.push({ + start: previousValue.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter` + }); + } + return previousValue + currentValue + (index === params.length ? "" : encoded); + }, ""); + const pathOnly = path4.split(/[?#]/, 1)[0]; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { + invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can't be safely passed as a path parameter` + }); + } + invalidSegments.sort((a, b) => a.start - b.start); + if (invalidSegments.length > 0) { + let lastEnd = 0; + const underline = invalidSegments.reduce((acc, segment) => { + const spaces = " ".repeat(segment.start - lastEnd); + const arrows = "^".repeat(segment.length); + lastEnd = segment.start + segment.length; + return acc + spaces + arrows; + }, ""); + throw new GitHubError(`Path parameters result in path with invalid segments: +${invalidSegments.map((e) => e.error).join("\n")} +${path4} +${underline}`); + } + return path4; +}; +var path2 = /* @__PURE__ */ createPathTagFunction2(encodeURIPath2); + +// node_modules/@stainless-api/github-internal/resources/repos/issues/comments/reactions.mjs +var BaseReactions = /* @__PURE__ */ (() => { + class BaseReactions8 extends APIResource2 { + /** + * Create a reaction to an + * [issue comment](https://docs.github.com/rest/issues/comments#get-an-issue-comment). + * A response with an HTTP `200` status means that you already added the reaction + * type to this issue comment. + * + * @example + * ```ts + * const reaction = + * await client.repos.issues.comments.reactions.create(0, { + * owner: 'owner', + * repo: 'repo', + * content: 'heart', + * }); + * ``` + */ + create(commentID, params, options) { + const { owner = this._client.owner, repo = this._client.repo, ...body } = params; + return this._client.post(path2`/repos/${owner}/${repo}/issues/comments/${commentID}/reactions`, { + body, + ...options + }); + } + /** + * List the reactions to an + * [issue comment](https://docs.github.com/rest/issues/comments#get-an-issue-comment). + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const reactionListResponse of client.repos.issues.comments.reactions.list( + * 0, + * { owner: 'owner', repo: 'repo' }, + * )) { + * // ... + * } + * ``` + */ + list(commentID, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo, ...query } = params ?? {}; + return this._client.getAPIList(path2`/repos/${owner}/${repo}/issues/comments/${commentID}/reactions`, NumberedPage, { query, ...options }); + } + /** + * > [!NOTE] You can also specify a repository by `repository_id` using the route + * > `DELETE delete /repositories/:repository_id/issues/comments/:comment_id/reactions/:reaction_id`. + * + * Delete a reaction to an + * [issue comment](https://docs.github.com/rest/issues/comments#get-an-issue-comment). + * + * @example + * ```ts + * await client.repos.issues.comments.reactions.delete(0, { + * owner: 'owner', + * repo: 'repo', + * comment_id: 0, + * }); + * ``` + */ + delete(reactionID, params, options) { + const { owner = this._client.owner, repo = this._client.repo, comment_id } = params; + return this._client.delete(path2`/repos/${owner}/${repo}/issues/comments/${comment_id}/reactions/${reactionID}`, { ...options, headers: buildHeaders2([{ Accept: "*/*" }, options?.headers]) }); + } + } + BaseReactions8._key = Object.freeze(["repos", "issues", "comments", "reactions"]); + return BaseReactions8; +})(); +var Reactions = class extends BaseReactions { +}; + +// node_modules/@stainless-api/github-internal/resources/repos/issues/comments/comments.mjs +var BaseComments = /* @__PURE__ */ (() => { + class BaseComments7 extends APIResource2 { + /** + * You can use the REST API to create comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * This endpoint triggers + * [notifications](https://docs.github.com/github/managing-subscriptions-and-notifications-on-github/about-notifications). + * Creating content too quickly using this endpoint may result in secondary rate + * limiting. For more information, see + * "[Rate limits for the API](https://docs.github.com/rest/using-the-rest-api/rate-limits-for-the-rest-api#about-secondary-rate-limits)" + * and + * "[Best practices for using the REST API](https://docs.github.com/rest/guides/best-practices-for-using-the-rest-api)." + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * const issueComment = + * await client.repos.issues.comments.create(0, { + * owner: 'owner', + * repo: 'repo', + * body: 'Me too', + * }); + * ``` + */ + create(issueNumber, params, options) { + const { owner = this._client.owner, repo = this._client.repo, ...body } = params; + return this._client.post(path2`/repos/${owner}/${repo}/issues/${issueNumber}/comments`, { + body, + ...options + }); + } + /** + * You can use the REST API to get comments on issues and pull requests. Every pull + * request is an issue, but not every issue is a pull request. + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * const issueComment = + * await client.repos.issues.comments.retrieve(0, { + * owner: 'owner', + * repo: 'repo', + * }); + * ``` + */ + retrieve(commentID, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo } = params ?? {}; + return this._client.get(path2`/repos/${owner}/${repo}/issues/comments/${commentID}`, options); + } + /** + * You can use the REST API to update comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * const issueComment = + * await client.repos.issues.comments.update(0, { + * owner: 'owner', + * repo: 'repo', + * body: 'Me too', + * }); + * ``` + */ + update(commentID, params, options) { + const { owner = this._client.owner, repo = this._client.repo, ...body } = params; + return this._client.patch(path2`/repos/${owner}/${repo}/issues/comments/${commentID}`, { + body, + ...options + }); + } + async upsertBasedOnBodyMatch(issueNumber, { bodyIncludes, createParams, updateParams, options }) { + const comments = await this.list(issueNumber); + const match = comments.data.find((comment) => comment.body?.includes(bodyIncludes)); + if (match) { + return this.update(match.id, updateParams, options); + } else { + return this.create(issueNumber, createParams, options); + } + } + /** + * You can use the REST API to list comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * Issue comments are ordered by ascending ID. + * + * This endpoint supports the following custom media types. For more information, + * see + * "[Media types](https://docs.github.com/rest/using-the-rest-api/getting-started-with-the-rest-api#media-types)." + * + * - **`application/vnd.github.raw+json`**: Returns the raw markdown body. Response + * will include `body`. This is the default if you do not pass any specific media + * type. + * - **`application/vnd.github.text+json`**: Returns a text only representation of + * the markdown body. Response will include `body_text`. + * - **`application/vnd.github.html+json`**: Returns HTML rendered from the body's + * markdown. Response will include `body_html`. + * - **`application/vnd.github.full+json`**: Returns raw, text, and HTML + * representations. Response will include `body`, `body_text`, and `body_html`. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const issueComment of client.repos.issues.comments.list( + * 0, + * { owner: 'owner', repo: 'repo' }, + * )) { + * // ... + * } + * ``` + */ + list(issueNumber, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo, ...query } = params ?? {}; + return this._client.getAPIList(path2`/repos/${owner}/${repo}/issues/${issueNumber}/comments`, NumberedPage, { query, ...options }); + } + /** + * You can use the REST API to delete comments on issues and pull requests. Every + * pull request is an issue, but not every issue is a pull request. + * + * @example + * ```ts + * await client.repos.issues.comments.delete(0, { + * owner: 'owner', + * repo: 'repo', + * }); + * ``` + */ + delete(commentID, params = {}, options) { + const { owner = this._client.owner, repo = this._client.repo } = params ?? {}; + return this._client.delete(path2`/repos/${owner}/${repo}/issues/comments/${commentID}`, { + ...options, + headers: buildHeaders2([{ Accept: "*/*" }, options?.headers]) + }); + } + } + BaseComments7._key = Object.freeze(["repos", "issues", "comments"]); + return BaseComments7; +})(); +var Comments = /* @__PURE__ */ (() => { + class Comments7 extends BaseComments { + constructor() { + super(...arguments); + this.reactions = new Reactions(this._client); + } + } + Comments7.Reactions = Reactions; + Comments7.BaseReactions = BaseReactions; + return Comments7; +})(); + +// node_modules/@stainless-api/github-internal/internal/utils/uuid.mjs +var uuid42 = function() { + const { crypto } = globalThis; + if (crypto?.randomUUID) { + uuid42 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255; + return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16)); +}; + +// node_modules/@stainless-api/github-internal/internal/utils/sleep.mjs +var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); + +// node_modules/@stainless-api/github-internal/version.mjs +var VERSION2 = "0.12.1"; + +// node_modules/@stainless-api/github-internal/internal/detect-platform.mjs +function getDetectedPlatform2() { + if (typeof Deno !== "undefined" && Deno.build != null) { + return "deno"; + } + if (typeof EdgeRuntime !== "undefined") { + return "edge"; + } + if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") { + return "node"; + } + return "unknown"; +} +var getPlatformProperties2 = () => { + const detectedPlatform = getDetectedPlatform2(); + if (detectedPlatform === "deno") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": normalizePlatform2(Deno.build.os), + "X-Stainless-Arch": normalizeArch2(Deno.build.arch), + "X-Stainless-Runtime": "deno", + "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown" + }; + } + if (typeof EdgeRuntime !== "undefined") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": `other:${EdgeRuntime}`, + "X-Stainless-Runtime": "edge", + "X-Stainless-Runtime-Version": globalThis.process.version + }; + } + if (detectedPlatform === "node") { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": normalizePlatform2(globalThis.process.platform ?? "unknown"), + "X-Stainless-Arch": normalizeArch2(globalThis.process.arch ?? "unknown"), + "X-Stainless-Runtime": "node", + "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown" + }; + } + const browserInfo = getBrowserInfo2(); + if (browserInfo) { + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": `browser:${browserInfo.browser}`, + "X-Stainless-Runtime-Version": browserInfo.version + }; + } + return { + "X-Stainless-Lang": "js", + "X-Stainless-Package-Version": VERSION2, + "X-Stainless-OS": "Unknown", + "X-Stainless-Arch": "unknown", + "X-Stainless-Runtime": "unknown", + "X-Stainless-Runtime-Version": "unknown" + }; +}; +function getBrowserInfo2() { + if (typeof navigator === "undefined" || !navigator) { + return null; + } + const browserPatterns = [ + { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ } + ]; + for (const { key, pattern } of browserPatterns) { + const match = pattern.exec(navigator.userAgent); + if (match) { + const major = match[1] || 0; + const minor = match[2] || 0; + const patch = match[3] || 0; + return { browser: key, version: `${major}.${minor}.${patch}` }; + } + } + return null; +} +var normalizeArch2 = (arch) => { + if (arch === "x32") + return "x32"; + if (arch === "x86_64" || arch === "x64") + return "x64"; + if (arch === "arm") + return "arm"; + if (arch === "aarch64" || arch === "arm64") + return "arm64"; + if (arch) + return `other:${arch}`; + return "unknown"; +}; +var normalizePlatform2 = (platform) => { + platform = platform.toLowerCase(); + if (platform.includes("ios")) + return "iOS"; + if (platform === "android") + return "Android"; + if (platform === "darwin") + return "MacOS"; + if (platform === "win32") + return "Windows"; + if (platform === "freebsd") + return "FreeBSD"; + if (platform === "openbsd") + return "OpenBSD"; + if (platform === "linux") + return "Linux"; + if (platform) + return `Other:${platform}`; + return "Unknown"; +}; +var _platformHeaders2; +var getPlatformHeaders2 = () => { + return _platformHeaders2 ?? (_platformHeaders2 = getPlatformProperties2()); +}; + +// node_modules/@stainless-api/github-internal/internal/shims.mjs +function getDefaultFetch2() { + if (typeof fetch !== "undefined") { + return fetch; + } + throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new GitHub({ fetch })` or polyfill the global, `globalThis.fetch = fetch`"); +} +function makeReadableStream2(...args) { + const ReadableStream = globalThis.ReadableStream; + if (typeof ReadableStream === "undefined") { + throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`"); + } + return new ReadableStream(...args); +} +function ReadableStreamFrom2(iterable) { + let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); + return makeReadableStream2({ + start() { + }, + async pull(controller) { + const { done, value } = await iter.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel() { + await iter.return?.(); + } + }); +} +async function CancelReadableStream2(stream) { + if (stream === null || typeof stream !== "object") + return; + if (stream[Symbol.asyncIterator]) { + await stream[Symbol.asyncIterator]().return?.(); + return; + } + const reader = stream.getReader(); + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; +} + +// node_modules/@stainless-api/github-internal/internal/request-options.mjs +var FallbackEncoder2 = ({ headers, body }) => { + return { + bodyHeaders: { + "content-type": "application/json" + }, + body: JSON.stringify(body) + }; +}; + +// node_modules/@stainless-api/github-internal/internal/qs/formats.mjs +var default_format2 = "RFC3986"; +var default_formatter2 = (v) => String(v); +var formatters2 = { + RFC1738: (v) => String(v).replace(/%20/g, "+"), + RFC3986: default_formatter2 +}; +var RFC17382 = "RFC1738"; + +// node_modules/@stainless-api/github-internal/internal/qs/utils.mjs +var has2 = (obj, key) => (has2 = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), has2(obj, key)); +var hex_table2 = /* @__PURE__ */ (() => { + const array = []; + for (let i = 0; i < 256; ++i) { + array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + } + return array; +})(); +var limit2 = 1024; +var encode2 = (str, _defaultEncoder, charset, _kind, format) => { + if (str.length === 0) { + return str; + } + let string = str; + if (typeof str === "symbol") { + string = Symbol.prototype.toString.call(str); + } else if (typeof str !== "string") { + string = String(str); + } + if (charset === "iso-8859-1") { + return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) { + return "%26%23" + parseInt($0.slice(2), 16) + "%3B"; + }); + } + let out = ""; + for (let j = 0; j < string.length; j += limit2) { + const segment = string.length >= limit2 ? string.slice(j, j + limit2) : string; + const arr = []; + for (let i = 0; i < segment.length; ++i) { + let c = segment.charCodeAt(i); + if (c === 45 || // - + c === 46 || // . + c === 95 || // _ + c === 126 || // ~ + c >= 48 && c <= 57 || // 0-9 + c >= 65 && c <= 90 || // a-z + c >= 97 && c <= 122 || // A-Z + format === RFC17382 && (c === 40 || c === 41)) { + arr[arr.length] = segment.charAt(i); + continue; + } + if (c < 128) { + arr[arr.length] = hex_table2[c]; + continue; + } + if (c < 2048) { + arr[arr.length] = hex_table2[192 | c >> 6] + hex_table2[128 | c & 63]; + continue; + } + if (c < 55296 || c >= 57344) { + arr[arr.length] = hex_table2[224 | c >> 12] + hex_table2[128 | c >> 6 & 63] + hex_table2[128 | c & 63]; + continue; + } + i += 1; + c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023); + arr[arr.length] = hex_table2[240 | c >> 18] + hex_table2[128 | c >> 12 & 63] + hex_table2[128 | c >> 6 & 63] + hex_table2[128 | c & 63]; + } + out += arr.join(""); + } + return out; +}; +function is_buffer2(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); +} +function maybe_map2(val, fn) { + if (isArray2(val)) { + const mapped = []; + for (let i = 0; i < val.length; i += 1) { + mapped.push(fn(val[i])); + } + return mapped; + } + return fn(val); +} + +// node_modules/@stainless-api/github-internal/internal/qs/stringify.mjs +var array_prefix_generators2 = { + brackets(prefix) { + return String(prefix) + "[]"; + }, + comma: "comma", + indices(prefix, key) { + return String(prefix) + "[" + key + "]"; + }, + repeat(prefix) { + return String(prefix); + } +}; +var push_to_array2 = function(arr, value_or_array) { + Array.prototype.push.apply(arr, isArray2(value_or_array) ? value_or_array : [value_or_array]); +}; +var toISOString2; +var defaults2 = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: encode2, + encodeValuesOnly: false, + format: default_format2, + formatter: default_formatter2, + /** @deprecated */ + indices: false, + serializeDate(date) { + return (toISOString2 ?? (toISOString2 = Function.prototype.call.bind(Date.prototype.toISOString)))(date); + }, + skipNulls: false, + strictNullHandling: false +}; +function is_non_nullish_primitive2(v) { + return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint"; +} +var sentinel2 = {}; +function inner_stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { + let obj = object; + let tmp_sc = sideChannel; + let step = 0; + let find_flag = false; + while ((tmp_sc = tmp_sc.get(sentinel2)) !== void 0 && !find_flag) { + const pos = tmp_sc.get(object); + step += 1; + if (typeof pos !== "undefined") { + if (pos === step) { + throw new RangeError("Cyclic object value"); + } else { + find_flag = true; + } + } + if (typeof tmp_sc.get(sentinel2) === "undefined") { + step = 0; + } + } + if (typeof filter === "function") { + obj = filter(prefix, obj); + } else if (obj instanceof Date) { + obj = serializeDate?.(obj); + } else if (generateArrayPrefix === "comma" && isArray2(obj)) { + obj = maybe_map2(obj, function(value) { + if (value instanceof Date) { + return serializeDate?.(value); + } + return value; + }); + } + if (obj === null) { + if (strictNullHandling) { + return encoder && !encodeValuesOnly ? ( + // @ts-expect-error + encoder(prefix, defaults2.encoder, charset, "key", format) + ) : prefix; + } + obj = ""; + } + if (is_non_nullish_primitive2(obj) || is_buffer2(obj)) { + if (encoder) { + const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults2.encoder, charset, "key", format); + return [ + formatter?.(key_value) + "=" + // @ts-expect-error + formatter?.(encoder(obj, defaults2.encoder, charset, "value", format)) + ]; + } + return [formatter?.(prefix) + "=" + formatter?.(String(obj))]; + } + const values = []; + if (typeof obj === "undefined") { + return values; + } + let obj_keys; + if (generateArrayPrefix === "comma" && isArray2(obj)) { + if (encodeValuesOnly && encoder) { + obj = maybe_map2(obj, encoder); + } + obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray2(filter)) { + obj_keys = filter; + } else { + const keys = Object.keys(obj); + obj_keys = sort ? keys.sort(sort) : keys; + } + const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + const adjusted_prefix = commaRoundTrip && isArray2(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix; + if (allowEmptyArrays && isArray2(obj) && obj.length === 0) { + return adjusted_prefix + "[]"; + } + for (let j = 0; j < obj_keys.length; ++j) { + const key = obj_keys[j]; + const value = ( + // @ts-ignore + typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key] + ); + if (skipNulls && value === null) { + continue; + } + const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key; + const key_prefix = isArray2(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]"); + sideChannel.set(object, step); + const valueSideChannel = /* @__PURE__ */ new WeakMap(); + valueSideChannel.set(sentinel2, sideChannel); + push_to_array2(values, inner_stringify2( + value, + key_prefix, + generateArrayPrefix, + commaRoundTrip, + allowEmptyArrays, + strictNullHandling, + skipNulls, + encodeDotInKeys, + // @ts-ignore + generateArrayPrefix === "comma" && encodeValuesOnly && isArray2(obj) ? null : encoder, + filter, + sort, + allowDots, + serializeDate, + format, + formatter, + encodeValuesOnly, + charset, + valueSideChannel + )); + } + return values; +} +function normalize_stringify_options2(opts = defaults2) { + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") { + throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") { + throw new TypeError("Encoder has to be a function."); + } + const charset = opts.charset || defaults2.charset; + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + let format = default_format2; + if (typeof opts.format !== "undefined") { + if (!has2(formatters2, opts.format)) { + throw new TypeError("Unknown format option provided."); + } + format = opts.format; + } + const formatter = formatters2[format]; + let filter = defaults2.filter; + if (typeof opts.filter === "function" || isArray2(opts.filter)) { + filter = opts.filter; + } + let arrayFormat; + if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators2) { + arrayFormat = opts.arrayFormat; + } else if ("indices" in opts) { + arrayFormat = opts.indices ? "indices" : "repeat"; + } else { + arrayFormat = defaults2.arrayFormat; + } + if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") { + throw new TypeError("`commaRoundTrip` must be a boolean, or absent"); + } + const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults2.addQueryPrefix, + // @ts-ignore + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays, + arrayFormat, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel, + commaRoundTrip: !!opts.commaRoundTrip, + delimiter: typeof opts.delimiter === "undefined" ? defaults2.delimiter : opts.delimiter, + encode: typeof opts.encode === "boolean" ? opts.encode : defaults2.encode, + encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults2.encodeDotInKeys, + encoder: typeof opts.encoder === "function" ? opts.encoder : defaults2.encoder, + encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults2.encodeValuesOnly, + filter, + format, + formatter, + serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults2.serializeDate, + skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults2.skipNulls, + // @ts-ignore + sort: typeof opts.sort === "function" ? opts.sort : null, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling + }; +} +function stringify2(object, opts = {}) { + let obj = object; + const options = normalize_stringify_options2(opts); + let obj_keys; + let filter; + if (typeof options.filter === "function") { + filter = options.filter; + obj = filter("", obj); + } else if (isArray2(options.filter)) { + filter = options.filter; + obj_keys = filter; + } + const keys = []; + if (typeof obj !== "object" || obj === null) { + return ""; + } + const generateArrayPrefix = array_prefix_generators2[options.arrayFormat]; + const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip; + if (!obj_keys) { + obj_keys = Object.keys(obj); + } + if (options.sort) { + obj_keys.sort(options.sort); + } + const sideChannel = /* @__PURE__ */ new WeakMap(); + for (let i = 0; i < obj_keys.length; ++i) { + const key = obj_keys[i]; + if (options.skipNulls && obj[key] === null) { + continue; + } + push_to_array2(keys, inner_stringify2( + obj[key], + key, + // @ts-expect-error + generateArrayPrefix, + commaRoundTrip, + options.allowEmptyArrays, + options.strictNullHandling, + options.skipNulls, + options.encodeDotInKeys, + options.encode ? options.encoder : null, + options.filter, + options.sort, + options.allowDots, + options.serializeDate, + options.format, + options.formatter, + options.encodeValuesOnly, + options.charset, + sideChannel + )); + } + const joined = keys.join(options.delimiter); + let prefix = options.addQueryPrefix === true ? "?" : ""; + if (options.charsetSentinel) { + if (options.charset === "iso-8859-1") { + prefix += "utf8=%26%2310003%3B&"; + } else { + prefix += "utf8=%E2%9C%93&"; + } + } + return joined.length > 0 ? prefix + joined : ""; +} + +// node_modules/@stainless-api/github-internal/lib/secrets.mjs +var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1); + +// node_modules/@stainless-api/github-internal/internal/utils/env.mjs +var readEnv2 = (env) => { + if (typeof globalThis.process !== "undefined") { + return globalThis.process.env?.[env]?.trim() ?? void 0; + } + if (typeof globalThis.Deno !== "undefined") { + return globalThis.Deno.env?.get?.(env)?.trim(); + } + return void 0; +}; + +// node_modules/@stainless-api/github-internal/client.mjs +var _BaseGitHub_instances; +var _BaseGitHub_encoder; +var _BaseGitHub_baseURLOverridden; +var BaseGitHub = /* @__PURE__ */ (() => { + class BaseGitHub2 { + /** + * API Client for interfacing with the GitHub API. + * + * @param {string | null | undefined} [opts.authToken=process.env['GITHUB_AUTH_TOKEN'] ?? null] + * @param {string | null | undefined} [opts.owner] + * @param {string | null | undefined} [opts.repo] + * @param {string} [opts.baseURL=process.env['GITHUB_BASE_URL'] ?? https://api.github.com] - Override the default base URL for the API. + * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out. + * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls. + * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation. + * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request. + * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API. + * @param {Record} opts.defaultQuery - Default query parameters to include with every request to the API. + */ + constructor({ baseURL = readEnv2("GITHUB_BASE_URL"), authToken = readEnv2("GITHUB_AUTH_TOKEN") ?? null, owner = null, repo = null, ...opts } = {}) { + _BaseGitHub_instances.add(this); + _BaseGitHub_encoder.set(this, void 0); + const options = { + authToken, + owner, + repo, + ...opts, + baseURL: baseURL || `https://api.github.com` + }; + this.baseURL = options.baseURL; + this.timeout = options.timeout ?? BaseGitHub2.DEFAULT_TIMEOUT; + this.logger = options.logger ?? console; + const defaultLogLevel = "warn"; + this.logLevel = defaultLogLevel; + this.logLevel = parseLogLevel2(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel2(readEnv2("GITHUB_LOG"), "process.env['GITHUB_LOG']", this) ?? defaultLogLevel; + this.fetchOptions = options.fetchOptions; + this.maxRetries = options.maxRetries ?? 2; + this.fetch = options.fetch ?? getDefaultFetch2(); + __classPrivateFieldSet2(this, _BaseGitHub_encoder, FallbackEncoder2, "f"); + this._options = options; + this.authToken = authToken; + this.owner = owner; + this.repo = repo; + } + /** + * Create a new client instance re-using the same options given to the current client with optional overriding. + */ + withOptions(options) { + return new this.constructor({ + ...this._options, + baseURL: this.baseURL, + maxRetries: this.maxRetries, + timeout: this.timeout, + logger: this.logger, + logLevel: this.logLevel, + fetch: this.fetch, + fetchOptions: this.fetchOptions, + authToken: this.authToken, + owner: this.owner, + repo: this.repo, + ...options + }); + } + /** + * Get Hypermedia links to resources accessible in GitHub's REST API + */ + retrieve(options) { + return this.get("/", options); + } + /** + * Get a random sentence from the Zen of GitHub + */ + zen(options) { + return this.get("/zen", { + ...options, + headers: buildHeaders2([{ Accept: "text/plain" }, options?.headers]) + }); + } + defaultQuery() { + return this._options.defaultQuery; + } + validateHeaders({ values, nulls }) { + return; + } + authHeaders(opts) { + if (this.authToken == null) { + return void 0; + } + return buildHeaders2([{ Authorization: `Bearer ${this.authToken}` }]); + } + stringifyQuery(query) { + return stringify2(query, { arrayFormat: "comma" }); + } + getUserAgent() { + return `${this.constructor.name}/JS ${VERSION2}`; + } + defaultIdempotencyKey() { + return `stainless-node-retry-${uuid42()}`; + } + makeStatusError(status, error, message, headers) { + return APIError2.generate(status, error, message, headers); + } + buildURL(path3, query, defaultBaseURL) { + const baseURL = !__classPrivateFieldGet2(this, _BaseGitHub_instances, "m", _BaseGitHub_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL; + const url = isAbsoluteURL2(path3) ? new URL(path3) : new URL(baseURL + (baseURL.endsWith("/") && path3.startsWith("/") ? path3.slice(1) : path3)); + const defaultQuery = this.defaultQuery(); + if (!isEmptyObj2(defaultQuery)) { + query = { ...defaultQuery, ...query }; + } + if (typeof query === "object" && query && !Array.isArray(query)) { + url.search = this.stringifyQuery(query); + } + return url.toString(); + } + /** + * Used as a callback for mutating the given `FinalRequestOptions` object. + */ + async prepareOptions(options) { + } + /** + * Used as a callback for mutating the given `RequestInit` object. + * + * This is useful for cases where you want to add certain headers based off of + * the request properties, e.g. `method` or `url`. + */ + async prepareRequest(request, { url, options }) { + } + get(path3, opts) { + return this.methodRequest("get", path3, opts); + } + post(path3, opts) { + return this.methodRequest("post", path3, opts); + } + patch(path3, opts) { + return this.methodRequest("patch", path3, opts); + } + put(path3, opts) { + return this.methodRequest("put", path3, opts); + } + delete(path3, opts) { + return this.methodRequest("delete", path3, opts); + } + methodRequest(method, path3, opts) { + return this.request(Promise.resolve(opts).then((opts2) => { + return { method, path: path3, ...opts2 }; + })); + } + request(options, remainingRetries = null) { + return new APIPromise2(this, this.makeRequest(options, remainingRetries, void 0)); + } + async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) { + const options = await optionsInput; + const maxRetries = options.maxRetries ?? this.maxRetries; + if (retriesRemaining == null) { + retriesRemaining = maxRetries; + } + await this.prepareOptions(options); + const { req, url, timeout } = this.buildRequest(options, { retryCount: maxRetries - retriesRemaining }); + await this.prepareRequest(req, { url, options }); + const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0"); + const retryLogStr = retryOfRequestLogID === void 0 ? "" : `, retryOf: ${retryOfRequestLogID}`; + const startTime = Date.now(); + loggerFor2(this).debug(`[${requestLogID}] sending request`, formatRequestDetails2({ + retryOfRequestLogID, + method: options.method, + url, + options, + headers: req.headers + })); + if (options.signal?.aborted) { + throw new APIUserAbortError2(); + } + const controller = new AbortController(); + const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError2); + const headersTime = Date.now(); + if (response instanceof Error) { + const retryMessage = `retrying, ${retriesRemaining} attempts remaining`; + if (options.signal?.aborted) { + throw new APIUserAbortError2(); + } + const isTimeout = isAbortError2(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : "")); + if (retriesRemaining) { + loggerFor2(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`); + loggerFor2(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails2({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID); + } + loggerFor2(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`); + loggerFor2(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails2({ + retryOfRequestLogID, + url, + durationMs: headersTime - startTime, + message: response.message + })); + if (isTimeout) { + throw new APIConnectionTimeoutError2(); + } + throw new APIConnectionError2({ cause: response }); + } + const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`; + if (!response.ok) { + const shouldRetry = this.shouldRetry(response); + if (retriesRemaining && shouldRetry) { + const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`; + await CancelReadableStream2(response.body); + loggerFor2(this).info(`${responseInfo} - ${retryMessage2}`); + loggerFor2(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers); + } + const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`; + loggerFor2(this).info(`${responseInfo} - ${retryMessage}`); + const errText = await response.text().catch((err2) => castToError2(err2).message); + const errJSON = safeJSON2(errText); + const errMessage = errJSON ? void 0 : errText; + loggerFor2(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + message: errMessage, + durationMs: Date.now() - startTime + })); + const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers); + throw err; + } + loggerFor2(this).info(responseInfo); + loggerFor2(this).debug(`[${requestLogID}] response start`, formatRequestDetails2({ + retryOfRequestLogID, + url: response.url, + status: response.status, + headers: response.headers, + durationMs: headersTime - startTime + })); + return { response, options, controller, requestLogID, retryOfRequestLogID, startTime }; + } + getAPIList(path3, Page2, opts) { + return this.requestAPIList(Page2, { method: "get", path: path3, ...opts }); + } + requestAPIList(Page2, options) { + const request = this.makeRequest(options, null, void 0); + return new PagePromise2(this, request, Page2); + } + async fetchWithTimeout(url, init, ms, controller) { + const { signal, method, ...options } = init || {}; + if (signal) + signal.addEventListener("abort", () => controller.abort()); + const timeout = setTimeout(() => controller.abort(), ms); + const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body; + const fetchOptions = { + signal: controller.signal, + ...isReadableBody ? { duplex: "half" } : {}, + method: "GET", + ...options + }; + if (method) { + fetchOptions.method = method.toUpperCase(); + } + try { + return await this.fetch.call(void 0, url, fetchOptions); + } finally { + clearTimeout(timeout); + } + } + shouldRetry(response) { + const shouldRetryHeader = response.headers.get("x-should-retry"); + if (shouldRetryHeader === "true") + return true; + if (shouldRetryHeader === "false") + return false; + if (response.status === 408) + return true; + if (response.status === 409) + return true; + if (response.status === 429) + return true; + if (response.status >= 500) + return true; + return false; + } + async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) { + let timeoutMillis; + const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms"); + if (retryAfterMillisHeader) { + const timeoutMs = parseFloat(retryAfterMillisHeader); + if (!Number.isNaN(timeoutMs)) { + timeoutMillis = timeoutMs; + } + } + const retryAfterHeader = responseHeaders?.get("retry-after"); + if (retryAfterHeader && !timeoutMillis) { + const timeoutSeconds = parseFloat(retryAfterHeader); + if (!Number.isNaN(timeoutSeconds)) { + timeoutMillis = timeoutSeconds * 1e3; + } else { + timeoutMillis = Date.parse(retryAfterHeader) - Date.now(); + } + } + if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1e3)) { + const maxRetries = options.maxRetries ?? this.maxRetries; + timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries); + } + await sleep2(timeoutMillis); + return this.makeRequest(options, retriesRemaining - 1, requestLogID); + } + calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) { + const initialRetryDelay = 0.5; + const maxRetryDelay = 8; + const numRetries = maxRetries - retriesRemaining; + const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay); + const jitter = 1 - Math.random() * 0.25; + return sleepSeconds * jitter * 1e3; + } + buildRequest(inputOptions, { retryCount = 0 } = {}) { + const options = { ...inputOptions }; + const { method, path: path3, query, defaultBaseURL } = options; + const url = this.buildURL(path3, query, defaultBaseURL); + if ("timeout" in options) + validatePositiveInteger2("timeout", options.timeout); + options.timeout = options.timeout ?? this.timeout; + const { bodyHeaders, body } = this.buildBody({ options }); + const reqHeaders = this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount }); + const req = { + method, + headers: reqHeaders, + ...options.signal && { signal: options.signal }, + ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" }, + ...body && { body }, + ...this.fetchOptions ?? {}, + ...options.fetchOptions ?? {} + }; + return { req, url, timeout: options.timeout }; + } + buildHeaders({ options, method, bodyHeaders, retryCount }) { + let idempotencyHeaders = {}; + if (this.idempotencyHeader && method !== "get") { + if (!options.idempotencyKey) + options.idempotencyKey = this.defaultIdempotencyKey(); + idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey; + } + const headers = buildHeaders2([ + idempotencyHeaders, + { + Accept: "application/json", + "User-Agent": this.getUserAgent(), + "X-Stainless-Retry-Count": String(retryCount), + ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1e3)) } : {}, + ...getPlatformHeaders2() + }, + this.authHeaders(options), + this._options.defaultHeaders, + bodyHeaders, + options.headers + ]); + this.validateHeaders(headers); + return headers.values; + } + buildBody({ options: { body, headers: rawHeaders } }) { + if (!body) { + return { bodyHeaders: void 0, body: void 0 }; + } + const headers = buildHeaders2([rawHeaders]); + if ( + // Pass raw type verbatim + ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && // Preserve legacy string encoding behavior for now + headers.values.has("content-type") || // `Blob` is superset of `File` + body instanceof Blob || // `FormData` -> `multipart/form-data` + body instanceof FormData || // `URLSearchParams` -> `application/x-www-form-urlencoded` + body instanceof URLSearchParams || // Send chunked stream (each chunk has own `length`) + globalThis.ReadableStream && body instanceof globalThis.ReadableStream + ) { + return { bodyHeaders: void 0, body }; + } else if (typeof body === "object" && (Symbol.asyncIterator in body || Symbol.iterator in body && "next" in body && typeof body.next === "function")) { + return { bodyHeaders: void 0, body: ReadableStreamFrom2(body) }; + } else { + return __classPrivateFieldGet2(this, _BaseGitHub_encoder, "f").call(this, { body, headers }); + } + } + } + _BaseGitHub_encoder = /* @__PURE__ */ new WeakMap(), _BaseGitHub_instances = /* @__PURE__ */ new WeakSet(), _BaseGitHub_baseURLOverridden = function _BaseGitHub_baseURLOverridden2() { + return this.baseURL !== "https://api.github.com"; + }; + BaseGitHub2.DEFAULT_TIMEOUT = 6e4; + return BaseGitHub2; +})(); + +// node_modules/@stainless-api/github-internal/tree-shakable.mjs +function createClient(options) { + const client = new BaseGitHub(options); + for (const ResourceClass of options.resources) { + const resourceInstance = new ResourceClass(client); + let object = client; + for (const part of ResourceClass._key.slice(0, -1)) { + if (hasOwn2(object, part)) { + object = object[part]; + } else { + Object.defineProperty(object, part, { + value: object = {}, + configurable: true, + enumerable: true, + writable: true + }); + } + } + const name = ResourceClass._key.at(-1); + if (!hasOwn2(object, name)) { + Object.defineProperty(object, name, { + value: resourceInstance, + configurable: true, + enumerable: true, + writable: true + }); + } else { + if (object[name] instanceof APIResource2) { + throw new TypeError(`Resource at ${ResourceClass._key.join(".")} already exists!`); + } else { + object[name] = Object.assign(resourceInstance, object[name]); + } + } + } + return client; +} + +// src/markdown.ts +var import_ts_dedent = __toESM(require_dist()); +var Symbol2 = { + Bulb: "\u{1F4A1}", + Exclamation: "\u2757", + GreenSquare: "\u{1F7E9}", + HeavyAsterisk: "\u2731", + HourglassFlowingSand: "\u23F3", + MiddleDot: "\xB7", + RedSquare: "\u{1F7E5}", + RightwardsArrow: "\u2192", + SpeechBalloon: "\u{1F4AC}", + Warning: "\u26A0\uFE0F", + WhiteCheckMark: "\u2705", + WhiteLargeSquare: "\u2B1C", + Zap: "\u26A1" +}; +var Bold = (content) => `${content}`; +var CodeInline = (content) => `${content}`; +var Comment = (content) => ``; +var Italic = (content) => `${content}`; +function Dedent(templ, ...args) { + return (0, import_ts_dedent.dedent)(templ, ...args).trim().replaceAll(/\n\s*\n/gi, "\n\n"); +} +var Blockquote = (content) => Dedent` +
+ + ${content} + +
+ `; +var CodeBlock = (props) => { + const delimiter = "```"; + const content = typeof props === "string" ? props : props.content; + const language = typeof props === "string" ? "" : props.language; + return Dedent` + ${delimiter}${language} + ${content} + ${delimiter} + `; +}; +var Details = ({ + summary, + body, + indent = true, + open = false +}) => { + return Dedent` + + ${summary} + + ${indent ? Blockquote(body) : body} + + + `; +}; +var Heading = (content) => `

${content}

`; +var Link = ({ text, href }) => `${text}`; +var List = (lines) => { + return Dedent` +
    + ${lines.map((line) => `
  • ${line}
    • `).join("\n")} +
+ `; +}; + +// src/comment.ts +var DiagnosticIcon = { + fatal: Symbol2.Exclamation, + error: Symbol2.Exclamation, + warning: Symbol2.Warning, + note: Symbol2.Bulb +}; +var COMMENT_TITLE = Heading( + `${Symbol2.HeavyAsterisk} Stainless SDK previews` +); +function printComment({ + noChanges, + orgName, + projectName, + branch, + commitMessage, + baseOutcomes, + outcomes +}) { + const blocks = (() => { + if (noChanges) { + return "No changes were made to the SDKs."; + } + const details = getDetails({ base: baseOutcomes, head: outcomes }); + return [ + printCommitMessage({ + commitMessage, + projectName, + // Can edit if this is a preview comment (and thus baseOutcomes exist). + // Otherwise, this is post-merge and editing it won't do anything. + canEdit: !!baseOutcomes + }), + printFailures({ orgName, projectName, branch, outcomes }), + printMergeConflicts({ projectName, outcomes }), + printRegressions({ orgName, projectName, branch, details }), + printSuccesses({ orgName, projectName, branch, details }), + printPending({ details }) + ].filter((f) => f !== null).join(` + +`); + })(); + return Dedent` + ${COMMENT_TITLE} + + ${Italic( + `Last updated: ${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}` + )} + + ${blocks} + `; +} +function printCommitMessage({ + commitMessage, + projectName, + canEdit +}) { + return Dedent` + ${Symbol2.SpeechBalloon} This PR updates ${CodeInline( + projectName + )} SDKs with this commit message.${canEdit ? " To change the commit message, edit this comment." : ""} + + ${canEdit ? Comment( + "Replace the contents of this code block with your commit message. Use a commit message in the conventional commits format: https://www.conventionalcommits.org/en/v1.0.0/" + ) : ""} + ${CodeBlock(commitMessage)} + `; +} +function printFailures({ + orgName, + projectName, + branch, + outcomes +}) { + const failures = Object.entries(outcomes).map(([lang, outcome]) => { + switch (outcome.commit.completed.conclusion) { + case "noop": + case "error": + case "warning": + case "note": + case "success": + case "merge_conflict": + case "upstream_merge_conflict": { + return null; + } + case "fatal": { + return [lang, `Fatal error.`]; + } + case "timed_out": { + return [lang, `Timed out.`]; + } + default: { + return [ + lang, + `Unknown conclusion (${CodeInline( + outcome.commit.completed.conclusion + )}).` + ]; + } + } + }).filter((f) => f !== null); + if (!failures.length) { + return null; + } + const studioURL = getStudioURL({ orgName, projectName, branch }); + const studioLink = Link({ text: "Stainless Studio", href: studioURL }); + return Dedent` + ${Symbol2.Exclamation} ${Bold( + "Failures." + )} See the ${studioLink} for details. + + ${List( + failures.map(([lang, message]) => `${projectName}-${lang}: ${message}`) + )} + `; +} +function printMergeConflicts({ + projectName, + outcomes +}) { + const mergeConflicts = Object.entries(outcomes).map(([lang, outcome]) => { + if (!outcome.commit.completed.merge_conflict_pr) { + return null; + } + const { + number, + repo: { owner, name } + } = outcome.commit.completed.merge_conflict_pr; + const url = `https://github.com/${owner}/${name}/pull/${number}`; + if (outcome.commit.completed.conclusion === "upstream_merge_conflict") { + return [ + lang, + `The base branch has a conflict. ${Link({ + text: "Link to conflict.", + href: url + })}` + ]; + } + return [lang, `${Link({ text: "Link to conflict.", href: url })}`]; + }).filter((f) => f !== null); + if (!mergeConflicts.length) { + return null; + } + const runURL = `https://github.com/${github.context.repo.owner}/${github.context.repo.repo}/actions/runs/${github.context.runId}`; + return Dedent` + ${Symbol2.Zap} ${Bold( + "Merge conflicts." + )} You can resolve conflicts now; if you do, ${Link({ + text: "re-run this GitHub action", + href: runURL + })} to get diffs. If you merge before resolving conflicts, new conflict PRs will be created after merging. + + ${List( + mergeConflicts.map( + ([lang, message]) => `${projectName}-${lang}: ${message}` + ) + )} + `; +} +function getDetails({ + base, + head +}) { + const result = {}; + for (const [lang, outcome] of Object.entries(head)) { + if (!["error", "warning", "note", "success"].includes( + outcome.commit.completed.conclusion + )) { + continue; + } + const details = []; + const baseOutcome = base?.[lang]; + let githubLink = null; + let compareLink = null; + let isPending = false; + let isRegression = false; + if (outcome.commit.completed.commit) { + const { + repo: { owner, name, branch } + } = outcome.commit.completed.commit; + const githubURL = `https://github.com/${owner}/${name}/tree/${branch}`; + githubLink = Link({ text: "code", href: githubURL }); + } + if (baseOutcome?.commit.completed.commit && outcome.commit.completed.commit) { + const { + repo: { owner, name } + } = outcome.commit.completed.commit; + const base2 = baseOutcome.commit.completed.commit.repo.branch; + const head2 = outcome.commit.completed.commit.repo.branch; + const compareURL = `https://github.com/${owner}/${name}/compare/${base2}..${head2}`; + compareLink = Link({ text: "diff", href: compareURL }); + } + for (const check of ["build", "lint", "test"]) { + const checkName = check === "build" ? "Build" : check === "lint" ? "Lint" : "Test"; + if ((!baseOutcome?.[check] || baseOutcome[check].status === "completed" && baseOutcome[check].completed.conclusion === "success") && outcome[check] && outcome[check].status === "completed" && outcome[check].completed.conclusion === "failure") { + const baseURL = baseOutcome?.[check]?.status === "completed" ? baseOutcome[check].completed.url : null; + const baseText = `${Symbol2.WhiteCheckMark} success`; + const baseLink = baseURL ? Link({ text: baseText, href: baseURL }) : null; + const headURL = outcome[check].completed.url; + const headText = `${Symbol2.Exclamation} failure`; + const headLink = headURL ? Link({ text: headText, href: headURL }) : headText; + if (baseLink) { + details.push( + `${checkName}: ${baseLink} ${Symbol2.RightwardsArrow} ${headLink}` + ); + } else { + details.push(`${checkName}: ${headLink}`); + } + isRegression = true; + } + if (baseOutcome?.[check] && baseOutcome[check].status !== "completed" || outcome[check] && outcome[check].status !== "completed") { + details.push(`${checkName}: ${Symbol2.HourglassFlowingSand} pending`); + isPending = true; + } + } + if (baseOutcome?.diagnostics && outcome.diagnostics) { + const newDiagnostics = outcome.diagnostics.filter( + (d) => !baseOutcome.diagnostics.some( + (bd) => bd.code === d.code && bd.message === d.message && bd.config_ref === d.config_ref && bd.oas_ref === d.oas_ref + ) + ); + if (newDiagnostics.length > 0) { + const levelCounts = { + fatal: 0, + error: 0, + warning: 0, + note: 0 + }; + for (const d of newDiagnostics) { + levelCounts[d.level]++; + } + if (levelCounts.fatal > 0 || levelCounts.error > 0 || levelCounts.warning > 0) { + isRegression = true; + } + const diagnosticCounts = Object.entries(levelCounts).filter(([, count]) => count > 0).map(([level, count]) => `${count} ${level}`); + let hasOmittedDiagnostics = newDiagnostics.length > 10; + const diagnosticList = newDiagnostics.slice(0, 10).map((d) => { + if (d.level === "note") { + hasOmittedDiagnostics = true; + return null; + } + return `${DiagnosticIcon[d.level]} ${Bold(d.code)}: ${d.message}`; + }).filter(Boolean); + details.push( + Details({ + summary: `New diagnostics (${diagnosticCounts.join(", ")})`, + body: Dedent` + ${hasOmittedDiagnostics ? "Some diagnostics omitted. " : ""}See the Stainless Studio for more details. + + ${List(diagnosticList)} + ` + }) + ); + } + } + const installation = getInstallation(lang, outcome); + if (installation) { + details.push( + Details({ + summary: "Installation", + body: CodeBlock({ content: installation, language: "bash" }), + indent: false + }) + ); + } + result[lang] = { + githubLink, + compareLink, + details, + isPending, + isRegression + }; + } + return result; +} +function printRegressions({ + orgName, + projectName, + branch, + details +}) { + const regressions = Object.entries(details).filter( + ([, { isRegression }]) => isRegression + ); + if (regressions.length === 0) { + return null; + } + const formattedRegressions = regressions.map( + ([lang, { githubLink, compareLink, details: details2 }]) => { + const studioURL = getStudioURL({ + orgName, + projectName, + language: lang, + branch + }); + const studioLink = Link({ text: "studio", href: studioURL }); + const headingLinks = [studioLink, githubLink, compareLink].filter((link) => link !== null).join(` ${Symbol2.MiddleDot} `); + return Details({ + summary: `${projectName}-${lang}: ${headingLinks}`, + body: details2.join("\n\n"), + open: true + }); + } + ); + return Dedent` + ${Symbol2.Warning} ${Bold("Regressions.")} + + ${formattedRegressions.join("\n\n")} + `; +} +function printSuccesses({ + orgName, + projectName, + branch, + details +}) { + const successes = Object.entries(details).filter( + ([, { isPending, isRegression }]) => !isPending && !isRegression + ); + if (successes.length === 0) { + return null; + } + const formattedSuccesses = successes.map( + ([lang, { githubLink, compareLink, details: details2 }]) => { + const studioURL = getStudioURL({ + orgName, + projectName, + language: lang, + branch + }); + const studioLink = Link({ text: "studio", href: studioURL }); + const headingLinks = [studioLink, githubLink, compareLink].filter((link) => link !== null).join(` ${Symbol2.MiddleDot} `); + const summary = `${projectName}-${lang}: ${headingLinks}`; + return details2.length > 0 ? Details({ summary, body: details2.join("\n\n") }) : `- ${summary}`; + } + ); + return Dedent` + ${Symbol2.WhiteCheckMark} ${Bold("Successes.")} + + ${formattedSuccesses.join("\n\n")} + `; +} +function printPending({ details }) { + const hasPending = Object.values(details).some(({ isPending }) => isPending); + if (!hasPending) { + return null; + } + return Dedent` + ${Symbol2.HourglassFlowingSand} These are partial results; builds are still running. + `; +} +function getInstallation(lang, outcome) { + if (!outcome.commit.completed.commit) { + return null; + } + const { repo } = outcome.commit.completed.commit; + switch (lang) { + case "typescript": + case "node": { + return `npm install ${getGitHubURL({ repo })}`; + } + case "python": { + return `pip install git+${getGitHubURL({ repo })}`; + } + default: { + return null; + } + } +} +function getGitHubURL({ + repo +}) { + return `https://github.com/${repo.owner}/${repo.name}.git#${repo.branch}`; +} +function getStudioURL({ + orgName, + projectName, + language, + branch +}) { + if (language) { + return `https://app.stainless.com/${orgName}/${projectName}/studio?language=${language}&branch=${branch}`; + } + return `https://app.stainless.com/${orgName}/${projectName}/studio?branch=${branch}`; +} +function parseCommitMessage(body) { + return body?.match(/(? comment.body?.includes(COMMENT_TITLE)) ?? null; + return { + id: existingComment?.id, + commitMessage: parseCommitMessage(existingComment?.body) + }; +} +async function upsertComment({ + body, + token, + skipCreate = false +}) { + const client = createClient({ + authToken: token, + owner: github.context.repo.owner, + repo: github.context.repo.repo, + resources: [Comments] + }); + console.log("Upserting comment on PR:", github.context.issue.number); + const { data: comments } = await client.repos.issues.comments.list( + github.context.issue.number + ); + const firstLine = body.trim().split("\n")[0]; + const existingComment = comments.find( + (comment) => comment.body?.includes(firstLine) + ); + if (existingComment) { + console.log("Updating existing comment:", existingComment.id); + await client.repos.issues.comments.update(existingComment.id, { body }); + } else if (!skipCreate) { + console.log("Creating new comment"); + await client.repos.issues.comments.create(github.context.issue.number, { + body + }); + } +} + +// src/config.ts +var exec = __toESM(require_exec()); +async function isConfigChanged({ + before, + after, + oasPath, + configPath +}) { + await exec.exec("git", ["fetch", "--depth=1", "origin", before], { + silent: true + }); + await exec.exec("git", ["fetch", "--depth=1", "origin", after], { + silent: true + }); + const diffOutput = await exec.getExecOutput("git", [ + "diff", + "--name-only", + before, + after + ]); + const changedFiles = diffOutput.stdout.trim().split("\n"); + let changed = false; + if (oasPath && changedFiles.includes(oasPath)) { + console.log("OAS file changed"); + changed = true; + } + if (configPath && changedFiles.includes(configPath)) { + console.log("Config file changed"); + changed = true; + } + return changed; +} + +// src/preview.ts +async function main() { + try { + const apiKey = (0, import_core.getInput)("stainless_api_key", { required: true }); + const orgName = (0, import_core.getInput)("org", { required: true }); + const projectName = (0, import_core.getInput)("project", { required: true }); + const oasPath = (0, import_core.getInput)("oas_path", { required: true }); + const configPath = (0, import_core.getInput)("config_path", { required: false }) || void 0; + const defaultCommitMessage = (0, import_core.getInput)("commit_message", { required: true }); + const failRunOn = (0, import_core.getInput)("fail_on", { required: true }) || "error"; + const makeComment = (0, import_core.getBooleanInput)("make_comment", { required: true }); + const githubToken = (0, import_core.getInput)("github_token", { required: false }); + const baseSha = (0, import_core.getInput)("base_sha", { required: true }); + const baseRef = (0, import_core.getInput)("base_ref", { required: true }); + const baseBranch = (0, import_core.getInput)("base_branch", { required: true }); + const defaultBranch = (0, import_core.getInput)("default_branch", { required: true }); + const headSha = (0, import_core.getInput)("head_sha", { required: true }); + const branch = (0, import_core.getInput)("branch", { required: true }); + if (makeComment && !githubToken) { + throw new Error("github_token is required to make a comment"); + } + const stainless = new Stainless({ + project: projectName, + apiKey, + logLevel: "warn" + }); + (0, import_core.startGroup)("Getting parent revision"); + const { mergeBaseSha, nonMainBaseRef } = await getParentCommits({ + baseSha, + headSha, + baseRef, + defaultBranch + }); + const configChanged = await isConfigChanged({ + before: mergeBaseSha, + after: headSha, + oasPath, + configPath + }); + if (!configChanged) { + console.log("No config files changed, skipping preview"); + if (github2.context.payload.pull_request.action !== "opened" && makeComment) { + (0, import_core.startGroup)("Updating comment"); + const commentBody = printComment({ noChanges: true }); + await upsertComment({ + body: commentBody, + token: githubToken, + skipCreate: true + }); + (0, import_core.endGroup)(); + } + return; + } + const baseRevision = await computeBaseRevision({ + stainless, + projectName, + mergeBaseSha, + nonMainBaseRef, + oasPath, + configPath + }); + (0, import_core.endGroup)(); + let commitMessage = defaultCommitMessage; + if (makeComment) { + const comment = await retrieveComment({ token: githubToken }); + if (comment.commitMessage) { + commitMessage = comment.commitMessage; + } + } + console.log("Using commit message:", commitMessage); + await exec3.exec("git", ["checkout", headSha], { silent: true }); + let latestRun; + const generator = runBuilds({ + stainless, + oasPath, + configPath, + projectName, + baseRevision, + baseBranch, + branch, + guessConfig: !configPath, + commitMessage + }); + while (true) { + (0, import_core.startGroup)("Running builds"); + const run = await generator.next(); + (0, import_core.endGroup)(); + if (run.done) { + const { outcomes, baseOutcomes } = latestRun; + (0, import_core.setOutput)("outcomes", outcomes); + (0, import_core.setOutput)("base_outcomes", baseOutcomes); + if (!checkResults({ outcomes, failRunOn })) { + process.exit(1); + } + break; + } + latestRun = run.value; + if (makeComment) { + const { outcomes, baseOutcomes } = latestRun; + (0, import_core.startGroup)("Updating comment"); + const comment = await retrieveComment({ token: githubToken }); + if (comment.commitMessage) { + commitMessage = comment.commitMessage; + } + const commentBody = printComment({ + orgName, + projectName, + branch, + commitMessage, + outcomes, + baseOutcomes + }); + await upsertComment({ body: commentBody, token: githubToken }); + (0, import_core.endGroup)(); + } + } + } catch (error) { + console.error("Error in preview action:", error); + process.exit(1); + } +} +async function getParentCommits({ + baseSha, + headSha, + baseRef, + defaultBranch +}) { + await exec3.exec("git", ["fetch", "--depth=1", "origin", baseSha], { + silent: true + }); + let mergeBaseSha; + for (let attempt = 0; attempt < 10; attempt++) { + try { + const output = await exec3.getExecOutput( + "git", + ["merge-base", headSha, baseSha], + { silent: true } + ); + mergeBaseSha = output.stdout.trim(); + if (mergeBaseSha) break; + } catch { + } + await exec3.exec( + "git", + ["fetch", "--quiet", "--deepen=10", "origin", baseSha, headSha], + { silent: true } + ); + } + if (!mergeBaseSha) { + throw new Error("Could not determine merge base SHA"); + } + console.log(`Merge base: ${mergeBaseSha}`); + let nonMainBaseRef; + if (baseRef !== defaultBranch) { + nonMainBaseRef = `preview/${baseRef}`; + console.log(`Non-main base ref: ${nonMainBaseRef}`); + } + return { mergeBaseSha, nonMainBaseRef }; +} +async function computeBaseRevision({ + stainless, + projectName, + mergeBaseSha, + nonMainBaseRef, + oasPath, + configPath +}) { + if (mergeBaseSha) { + const hashes = {}; + await exec3.exec("git", ["checkout", mergeBaseSha], { silent: true }); + for (const [path3, file] of [ + [oasPath, "openapi.yml"], + [configPath, "openapi.stainless.yml"] + ]) { + if (path3) { + await exec3.getExecOutput("md5sum", [path3], { silent: true }).then(({ stdout }) => { + hashes[file] = { hash: stdout.split(" ")[0] }; + }).catch(() => { + console.log(`File ${path3} does not exist at merge base.`); + }); + } + } + const configCommit2 = (await stainless.builds.list({ + project: projectName, + revision: hashes, + limit: 1 + })).data[0]?.config_commit; + if (configCommit2) { + console.log(`Found base via merge base SHA: ${configCommit2}`); + return configCommit2; + } + } + if (nonMainBaseRef) { + const configCommit2 = (await stainless.builds.list({ + project: projectName, + branch: nonMainBaseRef, + limit: 1 + })).data[0]?.config_commit; + if (configCommit2) { + console.log(`Found base via non-main base ref: ${configCommit2}`); + return configCommit2; + } + } + const configCommit = (await stainless.builds.list({ + project: projectName, + branch: "main", + limit: 1 + })).data[0]?.config_commit; + if (!configCommit) { + throw new Error("Could not determine base revision"); + } + console.log(`Found base via main branch: ${configCommit}`); + return configCommit; +} +main(); +/*! Bundled license information: + +undici/lib/fetch/body.js: + (*! formdata-polyfill. MIT License. Jimmy Wärting *) + +undici/lib/websocket/frame.js: + (*! ws. MIT License. Einar Otto Stangvik *) +*/ diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 00000000..f5c5e413 --- /dev/null +++ b/examples/README.md @@ -0,0 +1,35 @@ +# Example workflows + +There's two kinds of workflows, depending on how you manage your GitHub repo. Both workflows require you to: + +* Provide your Stainless org and project names, as well as a Stainless API key. + +* Have a consistent path to an OpenAPI spec in your repo contents. + +* Provide a commit message, preferably in [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) format. (Commit messages that aren't in the Conventional Commits format will have `feat:` prepended to them.) + +## Pull request workflows + +The main kind of workflows are the pull-request-based workflows, such as [pull_request.yml](./pull_request.yml). If all changes to your OpenAPI spec are made via pull requests, we recommend using this workflow. It has two jobs: + +* `preview`, which runs when a pull request is opened or updated. The job creates a build of your SDK which includes only the changes introduced by the pull request. It also makes a comment on the pull request, with links to a GitHub diff, and installation commands for trying out your SDK. + +* `merge`, which runs when a pull request is merged. The job creates a build of the SDK with the changes from the pull request, along with any [custom code](https://app.stainless.com/docs/guides/patch-custom-code#project-branches) added to the preview build. + +By default, the pull request workflow uses the title of the pull request as the commit message. + +## Push workflows + +The other kind of workflows are the push-based workflows, such as [push.yml](./push.yml). If for some reason you can't use the pull-request-based workflows, you can use this workflow. It has one job: + +* `build`, which runs when a commit is pushed to a branch you specify. The job creates a build of your SDK against the latest commit on that branch. + +By default, the push workflow uses the same commit message. + +## Integration with docs platforms + +If your Stainless config has code samples configured, the `merge` and `build` actions also output a `documented_spec_path` containing a path to your OpenAPI spec with SDK code samples. + +If you sync your OpenAPI spec with a [ReadMe API Reference](https://readme.com/), you can use the [Sync to ReadMe](https://github.com/marketplace/actions/rdme-sync-to-readme) GitHub action to upload the documented spec to ReadMe. You can see examples of this in the [pull_request_readme.yml](./pull_request_readme.yml) and [push_readme.yml](./push_readme.yml) files. + +If you use [Mintlify's OpenAPI support](https://mintlify.com/docs/api-playground/openapi-setup#in-the-repo) for your API reference doucmentation, you can copy the documented spec to your Mintlify docs repo to update it. You can see examples of this in the [pull_request_mintlify.yml](./pull_request_mintlify.yml) and [push_mintlify.yml](./push_mintlify.yml) files. diff --git a/examples/github-action.yml b/examples/github-action.yml deleted file mode 100644 index 777ec1b8..00000000 --- a/examples/github-action.yml +++ /dev/null @@ -1,27 +0,0 @@ -# Example GitHub Actions workflow for uploading OpenAPI spec to Stainless - -name: Upload OpenAPI spec to Stainless - -on: - push: - branches: [main] - workflow_dispatch: - -jobs: - stainless: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - uses: stainless-api/upload-openapi-spec-action@main - with: - # Required parameters - stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} - input_path: "path/to/my-company-openapi.json" - - # Optional parameters - project_name: "my-stainless-project" - commit_message: "feat(api): my cool feature" - guess_config: true - # config_path: 'path/to/my-company.stainless.yaml' - # output_path: 'path/to/my-company-openapi.documented.json' - # branch: 'main' diff --git a/examples/gitlab-ci.yml b/examples/gitlab-ci.yml deleted file mode 100644 index 79f99340..00000000 --- a/examples/gitlab-ci.yml +++ /dev/null @@ -1,29 +0,0 @@ -# Example GitLab CI configuration file for uploading OpenAPI spec to Stainless - -include: - - remote: "https://raw.githubusercontent.com/stainless-api/upload-openapi-spec-action/main/.gitlab-ci.yml" - -# Define the workflow -stages: - - upload - -# Upload OpenAPI spec to Stainless -upload-openapi-spec: - stage: upload - extends: .upload-openapi-spec - variables: - # Required variables - STAINLESS_API_KEY: "$STAINLESS_API_KEY" - INPUT_PATH: "$CI_PROJECT_DIR/path/to/my-company-openapi.json" - PROJECT_NAME: "my-stainless-project" - - # Optional variables - COMMIT_MESSAGE: "feat(api): my cool feature" - GUESS_CONFIG: "true" # String 'true' or 'false' - # CONFIG_PATH: '$CI_PROJECT_DIR/path/to/my-company.stainless.yaml' - # OUTPUT_PATH: '$CI_PROJECT_DIR/path/to/output.json' - # BRANCH: 'main' - - # Optional: Run only on specific branches - only: - - main diff --git a/examples/pull_request.yml b/examples/pull_request.yml new file mode 100644 index 00000000..7e45e404 --- /dev/null +++ b/examples/pull_request.yml @@ -0,0 +1,86 @@ +name: Build SDKs for pull request + +on: + pull_request: + types: + - opened + - synchronize + - reopened + - closed + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number }} + cancel-in-progress: true + +env: + # Stainless organization name. + STAINLESS_ORG: YOUR_ORG + + # Stainless project name. + STAINLESS_PROJECT: YOUR_PROJECT + + # Path to your OpenAPI spec. + OAS_PATH: YOUR_OAS_PATH + + # Path to your Stainless config. Optional; only provide this if you prefer + # to maintain the ground truth Stainless config in your own repo. + CONFIG_PATH: YOUR_CONFIG_PATH + + # When to fail the job based on build conclusion. + # Options: "never" | "note" | "warning" | "error" | "fatal". + FAIL_ON: error + + # In your repo secrets, configure: + # - STAINLESS_API_KEY: a Stainless API key, which you can generate on the + # Stainless organization dashboard + +jobs: + preview: + if: github.event.action != 'closed' + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + - name: Run preview builds + uses: stainless-api/upload-openapi-spec-action/preview@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + fail_on: ${{ env.FAIL_ON }} + + merge: + if: github.event.action == 'closed' && github.event.pull_request.merged == true + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + # Note that this only merges in changes that happened on the last build on + # preview/${{ github.head_ref }}. It's possible that there are OAS/config + # changes that haven't been built, if the preview-sdk job didn't finish + # before this step starts. In theory we want to wait for all builds + # against preview/${{ github.head_ref }} to complete, but assuming that + # the preview-sdk job happens before the PR merge, it should be fine. + - name: Run merge build + uses: stainless-api/upload-openapi-spec-action/merge@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + fail_on: ${{ env.FAIL_ON }} diff --git a/examples/pull_request_mintlify.yml b/examples/pull_request_mintlify.yml new file mode 100644 index 00000000..c03028d1 --- /dev/null +++ b/examples/pull_request_mintlify.yml @@ -0,0 +1,111 @@ +name: Build SDKs for pull request + +on: + pull_request: + types: + - opened + - synchronize + - reopened + - closed + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number }} + cancel-in-progress: true + +env: + # Stainless organization name. + STAINLESS_ORG: YOUR_ORG + + # Stainless project name. + STAINLESS_PROJECT: YOUR_PROJECT + + # Path to your OpenAPI spec. + OAS_PATH: YOUR_OAS_PATH + + # Path to your Stainless config. Optional; only provide this if you prefer + # to maintain the ground truth Stainless config in your own repo. + CONFIG_PATH: YOUR_CONFIG_PATH + + # When to fail the job based on build conclusion. + # Options: "never" | "note" | "warning" | "error" | "fatal". + FAIL_ON: error + + # Name of your Mintlify GitHub repo, e.g. `stainless-api/docs`. + MINTLIFY_DOCS_REPO: YOUR_MINTLIFY_DOCS_REPO + + # Email associated with the GitHub token, for committing to the Mintlify repo. + GITHUB_TOKEN_EMAIL: YOUR_EMAIL + + # Name associated with the GitHub token, for committing to the Mintlify repo. + GITHUB_TOKEN_NAME: YOUR_NAME + + # In your repo secrets, configure: + # - STAINLESS_API_KEY: a Stainless API key, which you can generate on the + # Stainless organization dashboard + # + # - API_TOKEN_GITHUB: a GitHub personal access token with permissions to + # write to the Mintlify repo + +jobs: + preview: + if: github.event.action != 'closed' + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + - name: Run preview builds + uses: stainless-api/upload-openapi-spec-action/preview@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + fail_on: ${{ env.FAIL_ON }} + + merge: + if: github.event.action == 'closed' && github.event.pull_request.merged == true + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + # Note that this only merges in changes that happened on the last build on + # preview/${{ github.head_ref }}. It's possible that there are OAS/config + # changes that haven't been built, if the preview-sdk job didn't finish + # before this step starts. In theory we want to wait for all builds + # against preview/${{ github.head_ref }} to complete, but assuming that + # the preview-sdk job happens before the PR merge, it should be fine. + - name: Run merge build + id: build + uses: stainless-api/upload-openapi-spec-action/merge@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + fail_on: ${{ env.FAIL_ON }} + + - name: Push spec to Mintlify + uses: dmnemec/copy_file_to_another_repo_action@main + env: + API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }} + with: + source_file: ${{ steps.build.outputs.documented_spec_path }} + destination_repo: ${{ env.MINTLIFY_DOCS_REPO }} + destination_folder: openapi-specs + user_email: ${{ env.GITHUB_TOKEN_EMAIL }} + user_name: ${{ env.GITHUB_TOKEN_NAME }} + commit_message: Auto-updates from Stainless diff --git a/examples/pull_request_readme.yml b/examples/pull_request_readme.yml new file mode 100644 index 00000000..096f605d --- /dev/null +++ b/examples/pull_request_readme.yml @@ -0,0 +1,104 @@ +name: Build SDKs for pull request + +on: + pull_request: + types: + - opened + - synchronize + - reopened + - closed + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number }} + cancel-in-progress: true + +env: + # Stainless organization name. + STAINLESS_ORG: YOUR_ORG + + # Stainless project name. + STAINLESS_PROJECT: YOUR_PROJECT + + # Path to your OpenAPI spec. + OAS_PATH: YOUR_OAS_PATH + + # Path to your Stainless config. Optional; only provide this if you prefer + # to maintain the ground truth Stainless config in your own repo. + CONFIG_PATH: YOUR_CONFIG_PATH + + # When to fail the job based on build conclusion. + # Options: "never" | "note" | "warning" | "error" | "fatal". + FAIL_ON: error + + # In your repo secrets, configure: + # - STAINLESS_API_KEY: a Stainless API key, which you can generate on the + # Stainless organization dashboard + # + # - README_TOKEN: a ReadMe API key; see + # https://docs.readme.com/main/reference/intro/authentication#api-key-quick-start + # + # - README_DEFINITION_ID: the ReadMe project API definition ID, viewable when + # editing a ReadMe project API definition; see + # https://docs.readme.com/main/docs/openapi-resyncing#api-definition-ids + +jobs: + preview: + if: github.event.action != 'closed' + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + - name: Run preview builds + uses: stainless-api/upload-openapi-spec-action/preview@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + fail_on: ${{ env.FAIL_ON }} + + merge: + if: github.event.action == 'closed' && github.event.pull_request.merged == true + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + fetch-depth: 2 + + # Note that this only merges in changes that happened on the last build on + # preview/${{ github.head_ref }}. It's possible that there are OAS/config + # changes that haven't been built, if the preview-sdk job didn't finish + # before this step starts. In theory we want to wait for all builds + # against preview/${{ github.head_ref }} to complete, but assuming that + # the preview-sdk job happens before the PR merge, it should be fine. + - name: Run merge build + id: build + uses: stainless-api/upload-openapi-spec-action/merge@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + fail_on: ${{ env.FAIL_ON }} + + # Remember to set the readmeio/rdme ref to the latest stable version: + # https://github.com/marketplace/actions/rdme-sync-to-readme + - name: Push spec to ReadMe + uses: readmeio/rdme@v10 + with: + rdme: >- + openapi ${{ steps.build.outputs.documented_spec_path }} \ + --key=${{ secrets.README_TOKEN }} \ + --id=${{ secrets.README_DEFINITION_ID }} diff --git a/examples/push.yml b/examples/push.yml new file mode 100644 index 00000000..72f577c2 --- /dev/null +++ b/examples/push.yml @@ -0,0 +1,59 @@ +name: Build SDKs on branch push + +on: + push: + # Set this to the branch of the repository that the `main` Stainless branch + # of your project gets its OpenAPI spec from. This is usually the default + # branch of your repository. + branches: [main] + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }} + cancel-in-progress: true + +env: + # Stainless organization name. + STAINLESS_ORG: YOUR_ORG + + # Stainless project name. + STAINLESS_PROJECT: YOUR_PROJECT + + # Path to your OpenAPI spec. + OAS_PATH: YOUR_OAS_PATH + + # Path to your Stainless config. Optional; only provide this if you prefer + # to maintain the ground truth Stainless config in your own repo. + CONFIG_PATH: YOUR_CONFIG_PATH + + # The commit message to use for the SDK builds. Use a commit message in the + # conventional commits format: https://www.conventionalcommits.org/en/v1.0.0/ + COMMIT_MESSAGE: "feat(api): update api" + + # When to fail the job based on build conclusion. + # Options: "never" | "note" | "warning" | "error" | "fatal". + FAIL_ON: error + + # In your repo secrets, configure: + # - STAINLESS_API_KEY: a Stainless API key, which you can generate on the + # Stainless organization dashboard + +jobs: + build: + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Run build + uses: stainless-api/upload-openapi-spec-action@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + commit_message: ${{ env.COMMIT_MESSAGE }} + fail_on: ${{ env.FAIL_ON }} diff --git a/examples/push_mintlify.yml b/examples/push_mintlify.yml new file mode 100644 index 00000000..b214d93d --- /dev/null +++ b/examples/push_mintlify.yml @@ -0,0 +1,84 @@ +name: Build SDKs on branch push + +on: + push: + # Set this to the branch of the repository that the `main` Stainless branch + # of your project gets its OpenAPI spec from. This is usually the default + # branch of your repository. + branches: [main] + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }} + cancel-in-progress: true + +env: + # Stainless organization name. + STAINLESS_ORG: YOUR_ORG + + # Stainless project name. + STAINLESS_PROJECT: YOUR_PROJECT + + # Path to your OpenAPI spec. + OAS_PATH: YOUR_OAS_PATH + + # Path to your Stainless config. Optional; only provide this if you prefer + # to maintain the ground truth Stainless config in your own repo. + CONFIG_PATH: YOUR_CONFIG_PATH + + # The commit message to use for the SDK builds. Use a commit message in the + # conventional commits format: https://www.conventionalcommits.org/en/v1.0.0/ + COMMIT_MESSAGE: "feat(api): update api" + + # When to fail the job based on build conclusion. + # Options: "never" | "note" | "warning" | "error" | "fatal". + FAIL_ON: error + + # Name of your Mintlify GitHub repo, e.g. `stainless-api/docs`. + MINTLIFY_DOCS_REPO: YOUR_MINTLIFY_DOCS_REPO + + # Email associated with the GitHub token, for committing to the Mintlify repo. + GITHUB_TOKEN_EMAIL: YOUR_EMAIL + + # Name associated with the GitHub token, for committing to the Mintlify repo. + GITHUB_TOKEN_NAME: YOUR_NAME + + # In your repo secrets, configure: + # - STAINLESS_API_KEY: a Stainless API key, which you can generate on the + # Stainless organization dashboard + # + # - API_TOKEN_GITHUB: a GitHub personal access token with permissions to + # write to the Mintlify repo + +jobs: + build: + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Run build + id: build + uses: stainless-api/upload-openapi-spec-action@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + commit_message: ${{ env.COMMIT_MESSAGE }} + fail_on: ${{ env.FAIL_ON }} + + - name: Push spec to Mintlify + uses: dmnemec/copy_file_to_another_repo_action@main + env: + API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }} + with: + source_file: ${{ steps.build.outputs.documented_spec_path }} + destination_repo: ${{ env.MINTLIFY_DOCS_REPO }} + destination_folder: openapi-specs + user_email: ${{ env.GITHUB_TOKEN_EMAIL }} + user_name: ${{ env.GITHUB_TOKEN_NAME }} + commit_message: Auto-updates from Stainless diff --git a/examples/push_readme.yml b/examples/push_readme.yml new file mode 100644 index 00000000..6fbdeea1 --- /dev/null +++ b/examples/push_readme.yml @@ -0,0 +1,77 @@ +name: Build SDKs on branch push + +on: + push: + # Set this to the branch of the repository that the `main` Stainless branch + # of your project gets its OpenAPI spec from. This is usually the default + # branch of your repository. + branches: [main] + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }} + cancel-in-progress: true + +env: + # Stainless organization name. + STAINLESS_ORG: YOUR_ORG + + # Stainless project name. + STAINLESS_PROJECT: YOUR_PROJECT + + # Path to your OpenAPI spec. + OAS_PATH: YOUR_OAS_PATH + + # Path to your Stainless config. Optional; only provide this if you prefer + # to maintain the ground truth Stainless config in your own repo. + CONFIG_PATH: YOUR_CONFIG_PATH + + # The commit message to use for the SDK builds. Use a commit message in the + # conventional commits format: https://www.conventionalcommits.org/en/v1.0.0/ + COMMIT_MESSAGE: "feat(api): update api" + + # When to fail the job based on build conclusion. + # Options: "never" | "note" | "warning" | "error" | "fatal". + FAIL_ON: error + + # In your repo secrets, configure: + # - STAINLESS_API_KEY: a Stainless API key, which you can generate on the + # Stainless organization dashboard + # + # - README_TOKEN: a ReadMe API key; see + # https://docs.readme.com/main/reference/intro/authentication#api-key-quick-start + # + # - README_DEFINITION_ID: the ReadMe project API definition ID, viewable when + # editing a ReadMe project API definition; see + # https://docs.readme.com/main/docs/openapi-resyncing#api-definition-ids + +jobs: + build: + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Run build + id: build + uses: stainless-api/upload-openapi-spec-action@v1 + with: + stainless_api_key: ${{ secrets.STAINLESS_API_KEY }} + org: ${{ env.STAINLESS_ORG }} + project: ${{ env.STAINLESS_PROJECT }} + oas_path: ${{ env.OAS_PATH }} + config_path: ${{ env.CONFIG_PATH }} + commit_message: ${{ env.COMMIT_MESSAGE }} + fail_on: ${{ env.FAIL_ON }} + + # Remember to set the readmeio/rdme ref to the latest stable version: + # https://github.com/marketplace/actions/rdme-sync-to-readme + - name: Push spec to ReadMe + uses: readmeio/rdme@v10 + with: + rdme: >- + openapi ${{ steps.build.outputs.documented_spec_path }} \ + --key=${{ secrets.README_TOKEN }} \ + --id=${{ secrets.README_DEFINITION_ID }} diff --git a/merge/action.yml b/merge/action.yml new file mode 100644 index 00000000..a3d349b9 --- /dev/null +++ b/merge/action.yml @@ -0,0 +1,117 @@ +name: Stainless — Merge SDK changes +description: Build SDKs after merging a pull request +runs: + using: node20 + main: ../dist/merge.js +inputs: + stainless_api_key: + description: Stainless API key. + required: true + org: + description: Stainless organization name. + required: true + project: + description: Stainless project name. + required: true + oas_path: + description: Path to your OpenAPI spec. + required: false + config_path: + description: >- + Path to your Stainless config. Optional; only provide this if you prefer + to maintain the ground truth Stainless config in your own repo. If + omitted, the build will use the existing Stainless config on the + Stainless branch. + required: false + commit_message: + description: >- + Commit message to use in the commits in the SDK repo. Use a commit + message in the conventional commits format: + https://www.conventionalcommits.org/en/v1.0.0/ + If `make_comment` is true, this is only a default, and will be overriden + by the commit message specified in the comment. + required: false + default: ${{ github.event.pull_request.title }} + fail_on: + description: >- + When to fail the run based on build conclusion. Options: 'note', + 'warning', 'error', 'fatal', 'never'. + required: false + default: "error" + make_comment: + description: >- + If true, will comment on the pull request with the build results. + required: false + default: "true" + github_token: + description: >- + A GitHub token used for making comments on pull requests. Required if + `make_comment` is true. The token must have the `pull-requests: write` + permission. Defaults to the current workflow token. + required: false + default: ${{ github.token }} + + # We think it's unlikely you'll need to use non-default inputs for these: + base_sha: + description: >- + The SHA of the branch immediately before the merge is made. Used to + determine whether the build should be skipped. + required: false + default: ${{ github.event.pull_request.base.sha }} + base_ref: + description: >- + The branch the pull request was merged into. Used to determine whether the + build should be skipped. + required: false + default: ${{ github.event.pull_request.base.ref }} + default_branch: + description: >- + The branch of the repository that the `main` Stainless branch of your + project gets its OpenAPI spec from. This is usually the default branch of + your repository. Used to determine whether the build should be skipped. + required: false + default: ${{ github.event.repository.default_branch }} + head_sha: + description: >- + The SHA of the branch immediately after the merge is made. Used to + determine whether the build should be skipped. + required: false + default: ${{ github.event.pull_request.merge_commit_sha }} + merge_branch: + description: >- + The Stainless branch name that was merged. This should be the same as the + preview action's `branch` input. + required: false + default: ${{ format('preview/{0}', github.event.pull_request.head.ref) }} + output_dir: + description: >- + Directory to write output files to. Defaults to the runner's temporary + directory. + required: false + default: ${{ runner.temp }} + +outputs: + outcomes: + description: >- + JSON-stringified object of the preview build outcomes. Keys are + languages, and values contain the `commit` result of the build for that + language. Will look like: + + ``` + { + "typescript": { + "conclusion": "success", + "commit": { + "sha": "...", + ... + }, + }, + ... + } + ``` + documented_spec_path: + description: >- + Path to an OpenAPI spec with SDK code samples. Present when `output_dir` + is specified and `code_samples` is in your Stainless config. See + https://app.stainless.com/docs/reference/config#open-api-config for + more details. diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 00000000..4f018e25 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,3322 @@ +{ + "name": "upload-openapi-spec-action", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "upload-openapi-spec-action", + "version": "1.0.0", + "license": "ISC", + "dependencies": { + "@actions/core": "^1.11.1", + "@actions/exec": "^1.1.1", + "@actions/github": "^6.0.1", + "@stainless-api/github-internal": "^0.12.1", + "@stainless-api/sdk": "^0.1.0-alpha.11", + "ts-dedent": "^2.2.0", + "yaml": "^2.8.0" + }, + "devDependencies": { + "@types/node": "^22.10.6", + "@typescript-eslint/eslint-plugin": "^5.40.0", + "@typescript-eslint/parser": "^5.40.0", + "esbuild": "^0.25.4", + "eslint": "^8.25.0", + "eslint-config-prettier": "^10.1.5", + "eslint-plugin-prettier": "^5.5.1", + "prettier": "^3.6.2", + "typescript": "^5.7.3", + "vitest": "^3.2.4" + } + }, + "node_modules/@actions/core": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.11.1.tgz", + "integrity": "sha512-hXJCSrkwfA46Vd9Z3q4cpEpHB1rL5NG04+/rbqW9d3+CSvtB1tYe8UTpAlixa1vj0m/ULglfEK2UKxMGxCxv5A==", + "license": "MIT", + "dependencies": { + "@actions/exec": "^1.1.1", + "@actions/http-client": "^2.0.1" + } + }, + "node_modules/@actions/exec": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@actions/exec/-/exec-1.1.1.tgz", + "integrity": "sha512-+sCcHHbVdk93a0XT19ECtO/gIXoxvdsgQLzb2fE2/5sIZmWQuluYyjPQtrtTHdU1YzTZ7bAPN4sITq2xi1679w==", + "license": "MIT", + "dependencies": { + "@actions/io": "^1.0.1" + } + }, + "node_modules/@actions/github": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/@actions/github/-/github-6.0.1.tgz", + "integrity": "sha512-xbZVcaqD4XnQAe35qSQqskb3SqIAfRyLBrHMd/8TuL7hJSz2QtbDwnNM8zWx4zO5l2fnGtseNE3MbEvD7BxVMw==", + "license": "MIT", + "dependencies": { + "@actions/http-client": "^2.2.0", + "@octokit/core": "^5.0.1", + "@octokit/plugin-paginate-rest": "^9.2.2", + "@octokit/plugin-rest-endpoint-methods": "^10.4.0", + "@octokit/request": "^8.4.1", + "@octokit/request-error": "^5.1.1", + "undici": "^5.28.5" + } + }, + "node_modules/@actions/http-client": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.2.3.tgz", + "integrity": "sha512-mx8hyJi/hjFvbPokCg4uRd4ZX78t+YyRPtnKWwIl+RzNaVuFpQHfmlGVfsKEJN8LwTCvL+DfVgAM04XaHkm6bA==", + "license": "MIT", + "dependencies": { + "tunnel": "^0.0.6", + "undici": "^5.25.4" + } + }, + "node_modules/@actions/io": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/@actions/io/-/io-1.1.3.tgz", + "integrity": "sha512-wi9JjgKLYS7U/z8PPbco+PvTb/nRWjeoFlJ1Qer83k/3C5PHQi28hiVdeE2kHXmIL99mQFawx8qt/JPjZilJ8Q==", + "license": "MIT" + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.4", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.4.tgz", + "integrity": "sha512-Y1giCfM4nlHDWEfSckMzeWNdQS31BQGs9/rouw6Ub91tkK79aIMTH3q9xHvzH8d0wDru5Ci0kWB8b3up/nl16g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz", + "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.1", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz", + "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/js": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz", + "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/@fastify/busboy": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-2.1.1.tgz", + "integrity": "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==", + "license": "MIT", + "engines": { + "node": ">=14" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz", + "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==", + "deprecated": "Use @eslint/config-array instead", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanwhocodes/object-schema": "^2.0.3", + "debug": "^4.3.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz", + "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==", + "deprecated": "Use @eslint/object-schema instead", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.4.tgz", + "integrity": "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@octokit/auth-token": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-4.0.0.tgz", + "integrity": "sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA==", + "license": "MIT", + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/core": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/@octokit/core/-/core-5.2.1.tgz", + "integrity": "sha512-dKYCMuPO1bmrpuogcjQ8z7ICCH3FP6WmxpwC03yjzGfZhj9fTJg6+bS1+UAplekbN2C+M61UNllGOOoAfGCrdQ==", + "license": "MIT", + "dependencies": { + "@octokit/auth-token": "^4.0.0", + "@octokit/graphql": "^7.1.0", + "@octokit/request": "^8.4.1", + "@octokit/request-error": "^5.1.1", + "@octokit/types": "^13.0.0", + "before-after-hook": "^2.2.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/endpoint": { + "version": "9.0.6", + "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-9.0.6.tgz", + "integrity": "sha512-H1fNTMA57HbkFESSt3Y9+FBICv+0jFceJFPWDePYlR/iMGrwM5ph+Dd4XRQs+8X+PUFURLQgX9ChPfhJ/1uNQw==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^13.1.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/graphql": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-7.1.1.tgz", + "integrity": "sha512-3mkDltSfcDUoa176nlGoA32RGjeWjl3K7F/BwHwRMJUW/IteSa4bnSV8p2ThNkcIcZU2umkZWxwETSSCJf2Q7g==", + "license": "MIT", + "dependencies": { + "@octokit/request": "^8.4.1", + "@octokit/types": "^13.0.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/openapi-types": { + "version": "24.2.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-24.2.0.tgz", + "integrity": "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg==", + "license": "MIT" + }, + "node_modules/@octokit/plugin-paginate-rest": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-9.2.2.tgz", + "integrity": "sha512-u3KYkGF7GcZnSD/3UP0S7K5XUFT2FkOQdcfXZGZQPGv3lm4F2Xbf71lvjldr8c1H3nNbF+33cLEkWYbokGWqiQ==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^12.6.0" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "@octokit/core": "5" + } + }, + "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/openapi-types": { + "version": "20.0.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-20.0.0.tgz", + "integrity": "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA==", + "license": "MIT" + }, + "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/types": { + "version": "12.6.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-12.6.0.tgz", + "integrity": "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw==", + "license": "MIT", + "dependencies": { + "@octokit/openapi-types": "^20.0.0" + } + }, + "node_modules/@octokit/plugin-rest-endpoint-methods": { + "version": "10.4.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-10.4.1.tgz", + "integrity": "sha512-xV1b+ceKV9KytQe3zCVqjg+8GTGfDYwaT1ATU5isiUyVtlVAO3HNdzpS4sr4GBx4hxQ46s7ITtZrAsxG22+rVg==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^12.6.0" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "@octokit/core": "5" + } + }, + "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/openapi-types": { + "version": "20.0.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-20.0.0.tgz", + "integrity": "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA==", + "license": "MIT" + }, + "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": { + "version": "12.6.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-12.6.0.tgz", + "integrity": "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw==", + "license": "MIT", + "dependencies": { + "@octokit/openapi-types": "^20.0.0" + } + }, + "node_modules/@octokit/request": { + "version": "8.4.1", + "resolved": "https://registry.npmjs.org/@octokit/request/-/request-8.4.1.tgz", + "integrity": "sha512-qnB2+SY3hkCmBxZsR/MPCybNmbJe4KAlfWErXq+rBKkQJlbjdJeS85VI9r8UqeLYLvnAenU8Q1okM/0MBsAGXw==", + "license": "MIT", + "dependencies": { + "@octokit/endpoint": "^9.0.6", + "@octokit/request-error": "^5.1.1", + "@octokit/types": "^13.1.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/request-error": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-5.1.1.tgz", + "integrity": "sha512-v9iyEQJH6ZntoENr9/yXxjuezh4My67CBSu9r6Ve/05Iu5gNgnisNWOsoJHTP6k0Rr0+HQIpnH+kyammu90q/g==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^13.1.0", + "deprecation": "^2.0.0", + "once": "^1.4.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/types": { + "version": "13.10.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-13.10.0.tgz", + "integrity": "sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA==", + "license": "MIT", + "dependencies": { + "@octokit/openapi-types": "^24.2.0" + } + }, + "node_modules/@pkgr/core": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.2.7.tgz", + "integrity": "sha512-YLT9Zo3oNPJoBjBc4q8G2mjU4tqIbf5CEOORbUUr48dCD9q3umJ3IPlVqOqDakPfd2HuwccBaqlGhN4Gmr5OWg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/pkgr" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.44.2.tgz", + "integrity": "sha512-g0dF8P1e2QYPOj1gu7s/3LVP6kze9A7m6x0BZ9iTdXK8N5c2V7cpBKHV3/9A4Zd8xxavdhK0t4PnqjkqVmUc9Q==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.44.2.tgz", + "integrity": "sha512-Yt5MKrOosSbSaAK5Y4J+vSiID57sOvpBNBR6K7xAaQvk3MkcNVV0f9fE20T+41WYN8hDn6SGFlFrKudtx4EoxA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.44.2.tgz", + "integrity": "sha512-EsnFot9ZieM35YNA26nhbLTJBHD0jTwWpPwmRVDzjylQT6gkar+zenfb8mHxWpRrbn+WytRRjE0WKsfaxBkVUA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.44.2.tgz", + "integrity": "sha512-dv/t1t1RkCvJdWWxQ2lWOO+b7cMsVw5YFaS04oHpZRWehI1h0fV1gF4wgGCTyQHHjJDfbNpwOi6PXEafRBBezw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.44.2.tgz", + "integrity": "sha512-W4tt4BLorKND4qeHElxDoim0+BsprFTwb+vriVQnFFtT/P6v/xO5I99xvYnVzKWrK6j7Hb0yp3x7V5LUbaeOMg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.44.2.tgz", + "integrity": "sha512-tdT1PHopokkuBVyHjvYehnIe20fxibxFCEhQP/96MDSOcyjM/shlTkZZLOufV3qO6/FQOSiJTBebhVc12JyPTA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.44.2.tgz", + "integrity": "sha512-+xmiDGGaSfIIOXMzkhJ++Oa0Gwvl9oXUeIiwarsdRXSe27HUIvjbSIpPxvnNsRebsNdUo7uAiQVgBD1hVriwSQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.44.2.tgz", + "integrity": "sha512-bDHvhzOfORk3wt8yxIra8N4k/N0MnKInCW5OGZaeDYa/hMrdPaJzo7CSkjKZqX4JFUWjUGm88lI6QJLCM7lDrA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.44.2.tgz", + "integrity": "sha512-NMsDEsDiYghTbeZWEGnNi4F0hSbGnsuOG+VnNvxkKg0IGDvFh7UVpM/14mnMwxRxUf9AdAVJgHPvKXf6FpMB7A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.44.2.tgz", + "integrity": "sha512-lb5bxXnxXglVq+7imxykIp5xMq+idehfl+wOgiiix0191av84OqbjUED+PRC5OA8eFJYj5xAGcpAZ0pF2MnW+A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loongarch64-gnu": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.44.2.tgz", + "integrity": "sha512-Yl5Rdpf9pIc4GW1PmkUGHdMtbx0fBLE1//SxDmuf3X0dUC57+zMepow2LK0V21661cjXdTn8hO2tXDdAWAqE5g==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-powerpc64le-gnu": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.44.2.tgz", + "integrity": "sha512-03vUDH+w55s680YYryyr78jsO1RWU9ocRMaeV2vMniJJW/6HhoTBwyyiiTPVHNWLnhsnwcQ0oH3S9JSBEKuyqw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.44.2.tgz", + "integrity": "sha512-iYtAqBg5eEMG4dEfVlkqo05xMOk6y/JXIToRca2bAWuqjrJYJlx/I7+Z+4hSrsWU8GdJDFPL4ktV3dy4yBSrzg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.44.2.tgz", + "integrity": "sha512-e6vEbgaaqz2yEHqtkPXa28fFuBGmUJ0N2dOJK8YUfijejInt9gfCSA7YDdJ4nYlv67JfP3+PSWFX4IVw/xRIPg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.44.2.tgz", + "integrity": "sha512-evFOtkmVdY3udE+0QKrV5wBx7bKI0iHz5yEVx5WqDJkxp9YQefy4Mpx3RajIVcM6o7jxTvVd/qpC1IXUhGc1Mw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.44.2.tgz", + "integrity": "sha512-/bXb0bEsWMyEkIsUL2Yt5nFB5naLAwyOWMEviQfQY1x3l5WsLKgvZf66TM7UTfED6erckUVUJQ/jJ1FSpm3pRQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.44.2.tgz", + "integrity": "sha512-3D3OB1vSSBXmkGEZR27uiMRNiwN08/RVAcBKwhUYPaiZ8bcvdeEwWPvbnXvvXHY+A/7xluzcN+kaiOFNiOZwWg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.44.2.tgz", + "integrity": "sha512-VfU0fsMK+rwdK8mwODqYeM2hDrF2WiHaSmCBrS7gColkQft95/8tphyzv2EupVxn3iE0FI78wzffoULH1G+dkw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.44.2.tgz", + "integrity": "sha512-+qMUrkbUurpE6DVRjiJCNGZBGo9xM4Y0FXU5cjgudWqIBWbcLkjE3XprJUsOFgC6xjBClwVa9k6O3A7K3vxb5Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.44.2.tgz", + "integrity": "sha512-3+QZROYfJ25PDcxFF66UEk8jGWigHJeecZILvkPkyQN7oc5BvFo4YEXFkOs154j3FTMp9mn9Ky8RCOwastduEA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@stainless-api/github-internal": { + "version": "0.12.1", + "resolved": "https://registry.npmjs.org/@stainless-api/github-internal/-/github-internal-0.12.1.tgz", + "integrity": "sha512-1usw4cNa21O8lEqitzdb9UJGxQ4HS1E4doAX+zg7ig9POruiPhm6AtwZ3DoPmE44XcR3syMtu1maZWX5PT+bfg==", + "license": "Apache-2.0", + "dependencies": { + "libsodium-wrappers": "^0.7.15" + } + }, + "node_modules/@stainless-api/sdk": { + "version": "0.1.0-alpha.11", + "resolved": "https://registry.npmjs.org/@stainless-api/sdk/-/sdk-0.1.0-alpha.11.tgz", + "integrity": "sha512-fsKZLENhvwbCJFmjt5Gu3FnyDWx9Diy6zdBH8I6ZpbcKm+B/4qk+PH8baUHLAtJfUHfk5HuaIyiM0mWlGgI30w==", + "license": "Apache-2.0" + }, + "node_modules/@types/chai": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.2.tgz", + "integrity": "sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "22.10.6", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.6.tgz", + "integrity": "sha512-qNiuwC4ZDAUNcY47xgaSuS92cjf8JbSUoaKS77bmLG1rU7MlATVSiw/IlrjtIyyskXBZ8KkNfjK/P5na7rgXbQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.20.0" + } + }, + "node_modules/@types/semver": { + "version": "7.7.0", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.0.tgz", + "integrity": "sha512-k107IF4+Xr7UHjwDc7Cfd6PRQfbdkiRabXGRjo07b4WyPahFBZCZ1sE+BNxYIJPPg73UkfOsVOLwqVc/6ETrIA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz", + "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.4.0", + "@typescript-eslint/scope-manager": "5.62.0", + "@typescript-eslint/type-utils": "5.62.0", + "@typescript-eslint/utils": "5.62.0", + "debug": "^4.3.4", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "natural-compare-lite": "^1.4.0", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^5.0.0", + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz", + "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/scope-manager": "5.62.0", + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/typescript-estree": "5.62.0", + "debug": "^4.3.4" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz", + "integrity": "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/visitor-keys": "5.62.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz", + "integrity": "sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/typescript-estree": "5.62.0", + "@typescript-eslint/utils": "5.62.0", + "debug": "^4.3.4", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz", + "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz", + "integrity": "sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/visitor-keys": "5.62.0", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.62.0.tgz", + "integrity": "sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@types/json-schema": "^7.0.9", + "@types/semver": "^7.3.12", + "@typescript-eslint/scope-manager": "5.62.0", + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/typescript-estree": "5.62.0", + "eslint-scope": "^5.1.1", + "semver": "^7.3.7" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz", + "integrity": "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@ungap/structured-clone": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz", + "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==", + "dev": true, + "license": "ISC" + }, + "node_modules/@vitest/expect": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz", + "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/spy": "3.2.4", + "@vitest/utils": "3.2.4", + "chai": "^5.2.0", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/pretty-format": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz", + "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.4.tgz", + "integrity": "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "3.2.4", + "pathe": "^2.0.3", + "strip-literal": "^3.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.4.tgz", + "integrity": "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.4", + "magic-string": "^0.30.17", + "pathe": "^2.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz", + "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^4.0.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.4.tgz", + "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "3.2.4", + "loupe": "^3.1.4", + "tinyrainbow": "^2.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/acorn": { + "version": "8.15.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", + "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/before-after-hook": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz", + "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==", + "license": "Apache-2.0" + }, + "node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/chai": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/chai/-/chai-5.2.0.tgz", + "integrity": "sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw==", + "dev": true, + "license": "MIT", + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/check-error": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz", + "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/debug": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", + "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-eql": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", + "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/deprecation": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz", + "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==", + "license": "ISC" + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true, + "license": "MIT" + }, + "node_modules/esbuild": { + "version": "0.25.4", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz", + "integrity": "sha512-8pgjLUcUjcgDg+2Q4NYXnPbo/vncAY4UmyaCm0jZevERqCHZIaWwdJHkf8XQtu4AxSKCdvrUbT0XUr1IdZzI8Q==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.4", + "@esbuild/android-arm": "0.25.4", + "@esbuild/android-arm64": "0.25.4", + "@esbuild/android-x64": "0.25.4", + "@esbuild/darwin-arm64": "0.25.4", + "@esbuild/darwin-x64": "0.25.4", + "@esbuild/freebsd-arm64": "0.25.4", + "@esbuild/freebsd-x64": "0.25.4", + "@esbuild/linux-arm": "0.25.4", + "@esbuild/linux-arm64": "0.25.4", + "@esbuild/linux-ia32": "0.25.4", + "@esbuild/linux-loong64": "0.25.4", + "@esbuild/linux-mips64el": "0.25.4", + "@esbuild/linux-ppc64": "0.25.4", + "@esbuild/linux-riscv64": "0.25.4", + "@esbuild/linux-s390x": "0.25.4", + "@esbuild/linux-x64": "0.25.4", + "@esbuild/netbsd-arm64": "0.25.4", + "@esbuild/netbsd-x64": "0.25.4", + "@esbuild/openbsd-arm64": "0.25.4", + "@esbuild/openbsd-x64": "0.25.4", + "@esbuild/sunos-x64": "0.25.4", + "@esbuild/win32-arm64": "0.25.4", + "@esbuild/win32-ia32": "0.25.4", + "@esbuild/win32-x64": "0.25.4" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz", + "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==", + "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.6.1", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.57.1", + "@humanwhocodes/config-array": "^0.13.0", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.2", + "eslint-visitor-keys": "^3.4.3", + "espree": "^9.6.1", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-config-prettier": { + "version": "10.1.5", + "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.5.tgz", + "integrity": "sha512-zc1UmCpNltmVY34vuLRV61r1K27sWuX39E+uyUnY8xS2Bex88VV9cugG+UZbRSRGtGyFboj+D8JODyme1plMpw==", + "dev": true, + "license": "MIT", + "bin": { + "eslint-config-prettier": "bin/cli.js" + }, + "funding": { + "url": "https://opencollective.com/eslint-config-prettier" + }, + "peerDependencies": { + "eslint": ">=7.0.0" + } + }, + "node_modules/eslint-plugin-prettier": { + "version": "5.5.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.1.tgz", + "integrity": "sha512-dobTkHT6XaEVOo8IO90Q4DOSxnm3Y151QxPJlM/vKC0bVy+d6cVWQZLlFiuZPP0wS6vZwSKeJgKkcS+KfMBlRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "prettier-linter-helpers": "^1.0.0", + "synckit": "^0.11.7" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint-plugin-prettier" + }, + "peerDependencies": { + "@types/eslint": ">=8.0.0", + "eslint": ">=8.0.0", + "eslint-config-prettier": ">= 7.0.0 <10.0.0 || >=10.1.0", + "prettier": ">=3.0.0" + }, + "peerDependenciesMeta": { + "@types/eslint": { + "optional": true + }, + "eslint-config-prettier": { + "optional": true + } + } + }, + "node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/eslint-scope": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/espree": { + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.9.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", + "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esquery/node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esrecurse/node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/expect-type": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.2.2.tgz", + "integrity": "sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-diff": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz", + "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fastq": { + "version": "1.19.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", + "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fdir": { + "version": "6.4.6", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz", + "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.3", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", + "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", + "dev": true, + "license": "ISC" + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true, + "license": "MIT" + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/js-tokens": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz", + "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/libsodium": { + "version": "0.7.15", + "resolved": "https://registry.npmjs.org/libsodium/-/libsodium-0.7.15.tgz", + "integrity": "sha512-sZwRknt/tUpE2AwzHq3jEyUU5uvIZHtSssktXq7owd++3CSgn8RGrv6UZJJBpP7+iBghBqe7Z06/2M31rI2NKw==", + "license": "ISC" + }, + "node_modules/libsodium-wrappers": { + "version": "0.7.15", + "resolved": "https://registry.npmjs.org/libsodium-wrappers/-/libsodium-wrappers-0.7.15.tgz", + "integrity": "sha512-E4anqJQwcfiC6+Yrl01C1m8p99wEhLmJSs0VQqST66SbQXXBoaJY0pF4BNjRYa/sOQAxx6lXAaAFIlx+15tXJQ==", + "license": "ISC", + "dependencies": { + "libsodium": "^0.7.15" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/loupe": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.4.tgz", + "integrity": "sha512-wJzkKwJrheKtknCOKNEtDK4iqg/MxmZheEMtSTYvnzRdEYaZzmgH976nenp8WdJRdx5Vc1X/9MO0Oszl6ezeXg==", + "dev": true, + "license": "MIT" + }, + "node_modules/magic-string": { + "version": "0.30.17", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz", + "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/micromatch/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/natural-compare-lite": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz", + "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==", + "dev": true, + "license": "MIT" + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/pathval": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz", + "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", + "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.6", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prettier": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.6.2.tgz", + "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==", + "dev": true, + "license": "MIT", + "bin": { + "prettier": "bin/prettier.cjs" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/prettier-linter-helpers": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz", + "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-diff": "^1.1.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "deprecated": "Rimraf versions prior to v4 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rollup": { + "version": "4.44.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.44.2.tgz", + "integrity": "sha512-PVoapzTwSEcelaWGth3uR66u7ZRo6qhPHc0f2uRO9fX6XDVNrIiGYS0Pj9+R8yIIYSD/mCx2b16Ws9itljKSPg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.44.2", + "@rollup/rollup-android-arm64": "4.44.2", + "@rollup/rollup-darwin-arm64": "4.44.2", + "@rollup/rollup-darwin-x64": "4.44.2", + "@rollup/rollup-freebsd-arm64": "4.44.2", + "@rollup/rollup-freebsd-x64": "4.44.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.44.2", + "@rollup/rollup-linux-arm-musleabihf": "4.44.2", + "@rollup/rollup-linux-arm64-gnu": "4.44.2", + "@rollup/rollup-linux-arm64-musl": "4.44.2", + "@rollup/rollup-linux-loongarch64-gnu": "4.44.2", + "@rollup/rollup-linux-powerpc64le-gnu": "4.44.2", + "@rollup/rollup-linux-riscv64-gnu": "4.44.2", + "@rollup/rollup-linux-riscv64-musl": "4.44.2", + "@rollup/rollup-linux-s390x-gnu": "4.44.2", + "@rollup/rollup-linux-x64-gnu": "4.44.2", + "@rollup/rollup-linux-x64-musl": "4.44.2", + "@rollup/rollup-win32-arm64-msvc": "4.44.2", + "@rollup/rollup-win32-ia32-msvc": "4.44.2", + "@rollup/rollup-win32-x64-msvc": "4.44.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/semver": { + "version": "7.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", + "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/std-env": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.9.0.tgz", + "integrity": "sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==", + "dev": true, + "license": "MIT" + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/strip-literal": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.0.0.tgz", + "integrity": "sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA==", + "dev": true, + "license": "MIT", + "dependencies": { + "js-tokens": "^9.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/synckit": { + "version": "0.11.8", + "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.11.8.tgz", + "integrity": "sha512-+XZ+r1XGIJGeQk3VvXhT6xx/VpbHsRzsTkGgF6E5RX9TTXD0118l87puaEBZ566FhqblC6U0d4XnubznJDm30A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@pkgr/core": "^0.2.4" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/synckit" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.14", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz", + "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.4.4", + "picomatch": "^4.0.2" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinypool": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz", + "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.0.0 || >=20.0.0" + } + }, + "node_modules/tinyrainbow": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz", + "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tinyspy": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.3.tgz", + "integrity": "sha512-t2T/WLB2WRgZ9EpE4jgPJ9w+i66UZfDc8wHh0xrwiRNN+UwH98GIJkTeZqX9rg0i0ptwzqW+uYeIF0T4F8LR7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/ts-dedent": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz", + "integrity": "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==", + "license": "MIT", + "engines": { + "node": ">=6.10" + } + }, + "node_modules/tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "dev": true, + "license": "0BSD" + }, + "node_modules/tsutils": { + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", + "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", + "dev": true, + "license": "MIT", + "dependencies": { + "tslib": "^1.8.1" + }, + "engines": { + "node": ">= 6" + }, + "peerDependencies": { + "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta" + } + }, + "node_modules/tunnel": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz", + "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==", + "license": "MIT", + "engines": { + "node": ">=0.6.11 <=0.7.0 || >=0.7.3" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.7.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz", + "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici": { + "version": "5.29.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-5.29.0.tgz", + "integrity": "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==", + "license": "MIT", + "dependencies": { + "@fastify/busboy": "^2.0.0" + }, + "engines": { + "node": ">=14.0" + } + }, + "node_modules/undici-types": { + "version": "6.20.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz", + "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==", + "dev": true, + "license": "MIT" + }, + "node_modules/universal-user-agent": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.1.tgz", + "integrity": "sha512-yCzhz6FN2wU1NiiQRogkTQszlQSlpWaw8SvVegAc+bDxbzHgh1vX8uIe8OYyMH6DwH+sdTJsgMl36+mSMdRJIQ==", + "license": "ISC" + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/vite-node": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz", + "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cac": "^6.7.14", + "debug": "^4.4.1", + "es-module-lexer": "^1.7.0", + "pathe": "^2.0.3", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "bin": { + "vite-node": "vite-node.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/vite-node/node_modules/@types/node": { + "version": "24.0.10", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.0.10.tgz", + "integrity": "sha512-ENHwaH+JIRTDIEEbDK6QSQntAYGtbvdDXnMXnZaZ6k13Du1dPMmprkEHIL7ok2Wl2aZevetwTAb5S+7yIF+enA==", + "dev": true, + "license": "MIT", + "optional": true, + "peer": true, + "dependencies": { + "undici-types": "~7.8.0" + } + }, + "node_modules/vite-node/node_modules/undici-types": { + "version": "7.8.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz", + "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==", + "dev": true, + "license": "MIT", + "optional": true, + "peer": true + }, + "node_modules/vite-node/node_modules/vite": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.0.2.tgz", + "integrity": "sha512-hxdyZDY1CM6SNpKI4w4lcUc3Mtkd9ej4ECWVHSMrOdSinVc2zYOAppHeGc/hzmRo3pxM5blMzkuWHOJA/3NiFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.6", + "picomatch": "^4.0.2", + "postcss": "^8.5.6", + "rollup": "^4.40.0", + "tinyglobby": "^0.2.14" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vitest": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz", + "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/expect": "3.2.4", + "@vitest/mocker": "3.2.4", + "@vitest/pretty-format": "^3.2.4", + "@vitest/runner": "3.2.4", + "@vitest/snapshot": "3.2.4", + "@vitest/spy": "3.2.4", + "@vitest/utils": "3.2.4", + "chai": "^5.2.0", + "debug": "^4.4.1", + "expect-type": "^1.2.1", + "magic-string": "^0.30.17", + "pathe": "^2.0.3", + "picomatch": "^4.0.2", + "std-env": "^3.9.0", + "tinybench": "^2.9.0", + "tinyexec": "^0.3.2", + "tinyglobby": "^0.2.14", + "tinypool": "^1.1.1", + "tinyrainbow": "^2.0.0", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", + "vite-node": "3.2.4", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@types/debug": "^4.1.12", + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "@vitest/browser": "3.2.4", + "@vitest/ui": "3.2.4", + "happy-dom": "*", + "jsdom": "*" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@types/debug": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + } + } + }, + "node_modules/vitest/node_modules/@vitest/mocker": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.4.tgz", + "integrity": "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "3.2.4", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.17" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/vitest/node_modules/vite": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.0.2.tgz", + "integrity": "sha512-hxdyZDY1CM6SNpKI4w4lcUc3Mtkd9ej4ECWVHSMrOdSinVc2zYOAppHeGc/hzmRo3pxM5blMzkuWHOJA/3NiFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.6", + "picomatch": "^4.0.2", + "postcss": "^8.5.6", + "rollup": "^4.40.0", + "tinyglobby": "^0.2.14" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/yaml": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.0.tgz", + "integrity": "sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ==", + "license": "ISC", + "bin": { + "yaml": "bin.mjs" + }, + "engines": { + "node": ">= 14.6" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/package.json b/package.json index 9f4e07b3..85233e39 100644 --- a/package.json +++ b/package.json @@ -1,34 +1,41 @@ { - "name": "upload-openapi-spec", + "name": "upload-openapi-spec-action", "version": "1.0.0", - "description": "Upload OpenAPI spec to Stainless (GitHub Action & GitLab CI component)", - "main": "index.ts", - "repository": "https://github.com/stainless-api/upload-openapi-spec-action.git", - "author": "Matt Gleich ", - "license": "Copyright Stainless 2022", - "private": true, - "dependencies": { - "@actions/core": "^1.10.0", - "@stainless-api/sdk": "^0.1.0-alpha.10", - "yaml": "^2.8.0" - }, + "description": "", + "main": "dist/index.js", "scripts": { - "build": "ncc build index.ts --license licenses.txt", - "start": "node dist/index.js", - "prepare": "husky install", - "lint": "eslint ." + "build": "npm run build:build && npm run build:index && npm run build:merge && npm run build:preview", + "build:build": "esbuild --bundle src/build.ts --outdir=dist --platform=node --target=node20", + "build:index": "esbuild --bundle src/index.ts --outdir=dist --platform=node --target=node20", + "build:merge": "esbuild --bundle src/merge.ts --outdir=dist --platform=node --target=node20", + "build:preview": "esbuild --bundle src/preview.ts --outdir=dist --platform=node --target=node20", + "lint": "eslint src", + "lint:fix": "eslint src --fix", + "test": "vitest" }, + "keywords": [], + "author": "", + "license": "ISC", "devDependencies": { "@types/node": "^22.10.6", "@typescript-eslint/eslint-plugin": "^5.40.0", "@typescript-eslint/parser": "^5.40.0", - "@vercel/ncc": "^0.38.0", + "esbuild": "^0.25.4", "eslint": "^8.25.0", "eslint-config-prettier": "^10.1.5", "eslint-plugin-prettier": "^5.5.1", "prettier": "^3.6.2", - "husky": "^8.0.1", - "typescript": "^5.7.3" + "typescript": "^5.7.3", + "vitest": "^3.2.4" + }, + "dependencies": { + "@actions/core": "^1.11.1", + "@actions/exec": "^1.1.1", + "@actions/github": "^6.0.1", + "@stainless-api/github-internal": "^0.12.1", + "@stainless-api/sdk": "^0.1.0-alpha.11", + "ts-dedent": "^2.2.0", + "yaml": "^2.8.0" }, - "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e" + "packageManager": "pnpm@9.15.0+sha512.76e2379760a4328ec4415815bcd6628dee727af3779aaa4c914e3944156c4299921a89f976381ee107d41f12cfa4b66681ca9c718f0668fa0831ed4c6d8ba56c" } diff --git a/preview/action.yml b/preview/action.yml new file mode 100644 index 00000000..1f9dd01c --- /dev/null +++ b/preview/action.yml @@ -0,0 +1,127 @@ +name: Stainless — Preview SDK changes +description: Build SDKs to preview a pull request +runs: + using: node20 + main: ../dist/preview.js +inputs: + stainless_api_key: + description: Stainless API key. + required: true + org: + description: Stainless organization name. + required: true + project: + description: Stainless project name. + required: true + oas_path: + description: Path to your OpenAPI spec. + required: true + config_path: + description: >- + Path to your Stainless config. Optional; only provide this if you prefer + to maintain the ground truth Stainless config in your own repo. If + omitted, the existing Stainless config will be updated based on the + OpenAPI spec. + required: false + commit_message: + description: >- + Commit message to use in the commits in the SDK repo. Use a commit + message in the conventional commits format: + https://www.conventionalcommits.org/en/v1.0.0/ + If `make_comment` is true, this is only a default, and will be overriden + by the commit message specified in the comment. + required: false + default: ${{ github.event.pull_request.title }} + fail_on: + description: >- + When to fail the run based on build conclusion. Options: 'note', + 'warning', 'error', 'fatal', 'never'. + required: false + default: "error" + make_comment: + description: >- + If true, will comment on the pull request with the build results. + required: false + default: "true" + github_token: + description: >- + A GitHub token used for making comments on pull requests. Required if + `make_comment` is true. The token must have the `pull-requests: write` + permission. Defaults to the current workflow token. + required: false + default: ${{ github.token }} + + # We think it's unlikely you'll need to use non-default inputs for these: + base_sha: + description: >- + The base SHA for the pull request. Used to create a base build. + required: false + default: ${{ github.event.pull_request.base.sha }} + base_ref: + description: >- + The branch the pull request will be merged into. Used to create a base + build, if no existing build matches the base SHA. + required: false + default: ${{ github.event.pull_request.base.ref }} + base_branch: + description: The Stainless branch name of the base build. + required: false + default: ${{ format('preview/base/{0}', github.event.pull_request.head.ref) }} + default_branch: + description: >- + The branch of the repository that the `main` Stainless branch of your + project gets its OpenAPI spec from. This is usually the default branch of + your repository. Used to find a base build, if no build matches the + base SHA or base ref. + required: false + default: ${{ github.event.repository.default_branch }} + head_sha: + description: >- + The head SHA for the pull request. Used to get the OpenAPI spec and + Stainless config for the preview build. + required: false + default: ${{ github.event.pull_request.head.sha }} + branch: + description: >- + The Stainless branch name of the preview build. This should be the same + as the merge action's `merge_branch` input. + required: false + default: ${{ format('preview/{0}', github.event.pull_request.head.ref) }} + +outputs: + outcomes: + description: >- + JSON-stringified object of the preview build outcomes. Keys are + languages, and values contain the `commit` result of the build for that + language. Will look like: + + ``` + { + "typescript": { + "conclusion": "success", + "commit": { + "sha": "...", + ... + }, + }, + ... + } + ``` + base_outcomes: + description: >- + JSON-stringified object of the base build outcomes. Keys are languages, + and values contain the `commit` result of the build for that language. + Will look like: + + ``` + { + "typescript": { + "conclusion": "success", + "commit": { + "sha": "...", + ... + }, + }, + ... + } + ``` diff --git a/src/__snapshots__/comment.test.ts.snap b/src/__snapshots__/comment.test.ts.snap new file mode 100644 index 00000000..f3e1da6e --- /dev/null +++ b/src/__snapshots__/comment.test.ts.snap @@ -0,0 +1,70 @@ +// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html + +exports[`printComment > should print comment 1`] = ` +"

✱ Stainless SDK previews

+ +Last updated: 2000-01-01 00:00:00 UTC + +💬 This PR updates test-project SDKs with this commit message. To change the commit message, edit this comment. + + +\`\`\` +Update API endpoints +\`\`\` + +❗ Failures. See the Stainless Studio for details. + +
    +
  • test-project-python: Fatal error.
    • +
+ +⚡ Merge conflicts. You can resolve conflicts now; if you do, re-run this GitHub action to get diffs. If you merge before resolving conflicts, new conflict PRs will be created after merging. + + + +⚠️ Regressions. + +
+test-project-typescript: studio · code · diff + +
+ +Build: ✅ success → ❗ failure + +
+New diagnostics (1 error, 1 warning) + +
+ +See the Stainless Studio for more details. + +
    +
  • ❗ Error: Error
    • +
  • ⚠️ Warning: Other warning
    • +
+ +
+ +
+ +
+Installation + +\`\`\`bash +npm install https://github.com/test-org/test-sdk.git#feature-branch +\`\`\` + +
+ +
+ +
+ +✅ Successes. + +- test-project-kotlin: studio · code + +⏳ These are partial results; builds are still running." +`; diff --git a/src/build.ts b/src/build.ts new file mode 100644 index 00000000..d68a0c2a --- /dev/null +++ b/src/build.ts @@ -0,0 +1,57 @@ +import { getBooleanInput, getInput, setOutput } from "@actions/core"; +import { Stainless } from "@stainless-api/sdk"; +import { runBuilds } from "./runBuilds"; + +async function main() { + try { + const apiKey = getInput("stainless_api_key", { required: true }); + const oasPath = getInput("oas_path", { required: false }) || undefined; + const configPath = + getInput("config_path", { required: false }) || undefined; + const projectName = getInput("project", { required: true }); + const commitMessage = + getInput("commit_message", { required: false }) || undefined; + const guessConfig = getBooleanInput("guess_config", { required: false }); + const branch = getInput("branch", { required: false }) || undefined; + const mergeBranch = + getInput("merge_branch", { required: false }) || undefined; + const baseRevision = + getInput("base_revision", { required: false }) || undefined; + const baseBranch = + getInput("base_branch", { required: false }) || undefined; + const outputDir = getInput("output_dir", { required: false }) || undefined; + + const stainless = new Stainless({ + project: projectName, + apiKey, + logLevel: "warn", + }); + + for await (const { + baseOutcomes, + outcomes, + documentedSpecPath, + } of runBuilds({ + stainless, + projectName, + baseRevision, + baseBranch, + mergeBranch, + branch, + oasPath, + configPath, + guessConfig, + commitMessage, + outputDir, + })) { + setOutput("outcomes", outcomes); + setOutput("base_outcomes", baseOutcomes); + setOutput("documented_spec_path", documentedSpecPath); + } + } catch (error) { + console.error("Error interacting with API:", error); + process.exit(1); + } +} + +main(); diff --git a/src/comment.test.ts b/src/comment.test.ts new file mode 100644 index 00000000..41f03045 --- /dev/null +++ b/src/comment.test.ts @@ -0,0 +1,319 @@ +import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"; +import type { Outcomes } from "./runBuilds"; +import { parseCommitMessage, printComment } from "./comment"; +import * as MD from "./markdown"; + +vi.mock("@actions/github", () => { + return { + context: { + repo: { + owner: "test-org", + repo: "test-sdk", + }, + runId: 200, + }, + }; +}); + +describe("printComment", () => { + beforeAll(() => { + vi.useFakeTimers(); + vi.setSystemTime(new Date("2000-01-01")); + }); + + afterAll(() => { + vi.useRealTimers(); + vi.clearAllMocks(); + }); + + it("should print no changes comment", () => { + expect(printComment({ noChanges: true })).toMatchInlineSnapshot(` + "

✱ Stainless SDK previews

+ + Last updated: 2000-01-01 00:00:00 UTC + + No changes were made to the SDKs." + `); + }); + + it("should print comment", () => { + const baseOutcomes = { + typescript: { + object: "build_target", + status: "completed", + commit: { + status: "completed", + completed: { + conclusion: "success", + commit: { + sha: "def456", + repo: { + owner: "test-org", + name: "test-sdk", + branch: "base-branch", + }, + }, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/199", + }, + }, + build: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/200", + }, + }, + lint: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/201", + }, + }, + test: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/202", + }, + }, + diagnostics: [ + { + level: "warning", + code: "Warning", + message: "Warning", + ignored: false, + }, + ], + }, + } satisfies Outcomes; + + const outcomes = { + python: { + object: "build_target", + status: "completed", + commit: { + status: "completed", + completed: { + conclusion: "fatal", + commit: null, + merge_conflict_pr: null, + url: null, + }, + }, + lint: { + status: "not_started", + }, + test: { + status: "not_started", + }, + diagnostics: [], + }, + go: { + object: "build_target", + status: "completed", + commit: { + status: "completed", + completed: { + conclusion: "merge_conflict", + commit: null, + merge_conflict_pr: { + number: 1, + repo: { + owner: "test-org", + name: "test-sdk", + }, + }, + url: null, + }, + }, + lint: { + status: "not_started", + }, + test: { + status: "not_started", + }, + diagnostics: [], + }, + typescript: { + object: "build_target", + status: "completed", + commit: { + status: "completed", + completed: { + conclusion: "success", + commit: { + sha: "abc123", + repo: { + owner: "test-org", + name: "test-sdk", + branch: "feature-branch", + }, + }, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/210", + }, + }, + build: { + status: "completed", + completed: { + conclusion: "failure", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/211", + }, + }, + lint: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/212", + }, + }, + test: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/213", + }, + }, + diagnostics: [ + { + level: "error", + code: "Error", + message: "Error", + ignored: false, + }, + { + level: "warning", + code: "Warning", + message: "Warning", + ignored: false, + }, + { + level: "warning", + code: "Warning", + message: "Other warning", + ignored: false, + }, + ], + }, + java: { + object: "build_target", + status: "completed", + commit: { + status: "completed", + completed: { + conclusion: "success", + commit: { + sha: "abc123", + repo: { + owner: "test-org", + name: "test-sdk", + branch: "feature-branch", + }, + }, + merge_conflict_pr: null, + url: null, + }, + }, + lint: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/213", + }, + }, + test: { + status: "not_started", + }, + diagnostics: [], + }, + kotlin: { + object: "build_target", + status: "completed", + commit: { + status: "completed", + completed: { + conclusion: "success", + commit: { + sha: "abc123", + repo: { + owner: "test-org", + name: "test-sdk", + branch: "feature-branch", + }, + }, + merge_conflict_pr: null, + url: null, + }, + }, + lint: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/213", + }, + }, + test: { + status: "completed", + completed: { + conclusion: "success", + commit: null, + merge_conflict_pr: null, + url: "https://github.com/test-org/test-sdk/actions/runs/214", + }, + }, + diagnostics: [], + }, + } satisfies Outcomes; + + expect( + printComment({ + orgName: "test-org", + projectName: "test-project", + branch: "feature-branch", + commitMessage: "Update API endpoints", + baseOutcomes, + outcomes, + }), + ).toMatchSnapshot(); + }); +}); + +describe("parseCommitMessage", () => { + it("should parse commit message", () => { + const commitMessage = MD.Dedent(` + feat(api): add new thing + + This is related to #243 + `); + + expect( + parseCommitMessage( + MD.Dedent(` + ${MD.Symbol.SpeechBalloon} This PR updates ${MD.CodeInline( + "test-project", + )} SDKs with this commit message. + + ${MD.CodeBlock(commitMessage)} + `), + ), + ).toBe(commitMessage); + }); +}); diff --git a/src/comment.ts b/src/comment.ts new file mode 100644 index 00000000..fb027b88 --- /dev/null +++ b/src/comment.ts @@ -0,0 +1,636 @@ +import * as github from "@actions/github"; +import { Comments as GitHubComments } from "@stainless-api/github-internal/resources/repos/issues/comments"; +import { createClient as createGitHubClient } from "@stainless-api/github-internal/tree-shakable"; +import type { Stainless } from "@stainless-api/sdk"; +import { Outcomes } from "./runBuilds"; +import * as MD from "./markdown"; + +type DiagnosticLevel = + Stainless.Builds.Diagnostics.DiagnosticListResponse["level"]; + +const DiagnosticIcon: Record = { + fatal: MD.Symbol.Exclamation, + error: MD.Symbol.Exclamation, + warning: MD.Symbol.Warning, + note: MD.Symbol.Bulb, +}; + +type PrintCommentOptions = { + noChanges: boolean; + orgName: string; + projectName: string; + branch: string; + commitMessage: string; + baseOutcomes?: Outcomes | null; + outcomes: Outcomes; +}; + +const COMMENT_TITLE = MD.Heading( + `${MD.Symbol.HeavyAsterisk} Stainless SDK previews`, +); + +export function printComment({ + noChanges, + orgName, + projectName, + branch, + commitMessage, + baseOutcomes, + outcomes, +}: + | ({ noChanges?: never } & Omit) + | ({ noChanges: true } & { + [K in keyof Omit]?: never; + })) { + const blocks = (() => { + if (noChanges) { + return "No changes were made to the SDKs."; + } + + const details = getDetails({ base: baseOutcomes, head: outcomes }); + + return [ + printCommitMessage({ + commitMessage, + projectName, + // Can edit if this is a preview comment (and thus baseOutcomes exist). + // Otherwise, this is post-merge and editing it won't do anything. + canEdit: !!baseOutcomes, + }), + printFailures({ orgName, projectName, branch, outcomes }), + printMergeConflicts({ projectName, outcomes }), + printRegressions({ orgName, projectName, branch, details }), + printSuccesses({ orgName, projectName, branch, details }), + printPending({ details }), + ] + .filter((f): f is string => f !== null) + .join(`\n\n`); + })(); + + return MD.Dedent` + ${COMMENT_TITLE} + + ${MD.Italic( + `Last updated: ${new Date() + .toISOString() + .replace("T", " ") + .replace(/\.\d+Z$/, " UTC")}`, + )} + + ${blocks} + `; +} + +function printCommitMessage({ + commitMessage, + projectName, + canEdit, +}: { + commitMessage: string; + projectName: string; + canEdit: boolean; +}) { + return MD.Dedent` + ${MD.Symbol.SpeechBalloon} This PR updates ${MD.CodeInline( + projectName, + )} SDKs with this commit message.${ + canEdit ? " To change the commit message, edit this comment." : "" + } + + ${ + canEdit + ? MD.Comment( + "Replace the contents of this code block with your commit message. Use a commit message in the conventional commits format: https://www.conventionalcommits.org/en/v1.0.0/", + ) + : "" + } + ${MD.CodeBlock(commitMessage)} + `; +} + +function printFailures({ + orgName, + projectName, + branch, + outcomes, +}: { + orgName: string; + projectName: string; + branch: string; + outcomes: Outcomes; +}) { + const failures = Object.entries(outcomes) + .map<[string, string] | null>(([lang, outcome]) => { + switch (outcome.commit.completed.conclusion) { + case "noop": + case "error": + case "warning": + case "note": + case "success": + case "merge_conflict": + case "upstream_merge_conflict": { + // non-failures + return null; + } + case "fatal": { + return [lang, `Fatal error.`]; + } + case "timed_out": { + return [lang, `Timed out.`]; + } + default: { + return [ + lang, + `Unknown conclusion (${MD.CodeInline( + outcome.commit.completed.conclusion, + )}).`, + ]; + } + } + }) + .filter((f): f is [string, string] => f !== null); + + if (!failures.length) { + return null; + } + + const studioURL = getStudioURL({ orgName, projectName, branch }); + const studioLink = MD.Link({ text: "Stainless Studio", href: studioURL }); + + return MD.Dedent` + ${MD.Symbol.Exclamation} ${MD.Bold( + "Failures.", + )} See the ${studioLink} for details. + + ${MD.List( + failures.map(([lang, message]) => `${projectName}-${lang}: ${message}`), + )} + `; +} + +function printMergeConflicts({ + projectName, + outcomes, +}: { + projectName: string; + outcomes: Outcomes; +}) { + const mergeConflicts = Object.entries(outcomes) + .map<[string, string] | null>(([lang, outcome]) => { + if (!outcome.commit.completed.merge_conflict_pr) { + return null; + } + const { + number, + repo: { owner, name }, + } = outcome.commit.completed.merge_conflict_pr!; + const url = `https://github.com/${owner}/${name}/pull/${number}`; + if (outcome.commit.completed.conclusion === "upstream_merge_conflict") { + return [ + lang, + `The base branch has a conflict. ${MD.Link({ + text: "Link to conflict.", + href: url, + })}`, + ]; + } + return [lang, `${MD.Link({ text: "Link to conflict.", href: url })}`]; + }) + .filter((f): f is [string, string] => f !== null); + + if (!mergeConflicts.length) { + return null; + } + + const runURL = `https://github.com/${github.context.repo.owner}/${github.context.repo.repo}/actions/runs/${github.context.runId}`; + return MD.Dedent` + ${MD.Symbol.Zap} ${MD.Bold( + "Merge conflicts.", + )} You can resolve conflicts now; if you do, ${MD.Link({ + text: "re-run this GitHub action", + href: runURL, + })} to get diffs. If you merge before resolving conflicts, new conflict PRs will be created after merging. + + ${MD.List( + mergeConflicts.map( + ([lang, message]) => `${projectName}-${lang}: ${message}`, + ), + )} + `; +} + +type Details = Record< + string, + { + githubLink: string | null; + compareLink: string | null; + details: string[]; + isPending: boolean; + isRegression: boolean; + } +>; + +function getDetails({ + base, + head, +}: { + base?: Outcomes | null; + head: Outcomes; +}) { + const result: Details = {}; + + for (const [lang, outcome] of Object.entries(head)) { + if ( + !["error", "warning", "note", "success"].includes( + outcome.commit.completed.conclusion, + ) + ) { + continue; + } + + const details: string[] = []; + const baseOutcome = base?.[lang]; + let githubLink: string | null = null; + let compareLink: string | null = null; + let isPending = false; + let isRegression = false; + + // Get the GitHub link: + if (outcome.commit.completed.commit) { + const { + repo: { owner, name, branch }, + } = outcome.commit.completed.commit; + const githubURL = `https://github.com/${owner}/${name}/tree/${branch}`; + githubLink = MD.Link({ text: "code", href: githubURL }); + } + + // Get the diff link: + if ( + baseOutcome?.commit.completed.commit && + outcome.commit.completed.commit + ) { + const { + repo: { owner, name }, + } = outcome.commit.completed.commit; + const base = baseOutcome.commit.completed.commit.repo.branch; + const head = outcome.commit.completed.commit.repo.branch; + const compareURL = `https://github.com/${owner}/${name}/compare/${base}..${head}`; + // TODO: can we get a label with stats? + compareLink = MD.Link({ text: "diff", href: compareURL }); + } + + // Show a check if it fails, but previously succeeded or didn't exist: + for (const check of ["build", "lint", "test"] as const) { + const checkName = + check === "build" ? "Build" : check === "lint" ? "Lint" : "Test"; + + if ( + (!baseOutcome?.[check] || + (baseOutcome[check].status === "completed" && + baseOutcome[check].completed.conclusion === "success")) && + outcome[check] && + outcome[check].status === "completed" && + outcome[check].completed.conclusion === "failure" + ) { + const baseURL = + baseOutcome?.[check]?.status === "completed" + ? baseOutcome[check].completed.url + : null; + const baseText = `${MD.Symbol.WhiteCheckMark} success`; + const baseLink = baseURL + ? MD.Link({ text: baseText, href: baseURL }) + : null; + + const headURL = outcome[check].completed.url; + const headText = `${MD.Symbol.Exclamation} failure`; + const headLink = headURL + ? MD.Link({ text: headText, href: headURL }) + : headText; + + if (baseLink) { + details.push( + `${checkName}: ${baseLink} ${MD.Symbol.RightwardsArrow} ${headLink}`, + ); + } else { + details.push(`${checkName}: ${headLink}`); + } + + isRegression = true; + } + + if ( + (baseOutcome?.[check] && baseOutcome[check].status !== "completed") || + (outcome[check] && outcome[check].status !== "completed") + ) { + details.push(`${checkName}: ${MD.Symbol.HourglassFlowingSand} pending`); + isPending = true; + } + } + + // New diagnostics. Show count of every severity, but only show the details + // of the first few diagnostics. Regression if we have a new non-info + // diagnostic. + if (baseOutcome?.diagnostics && outcome.diagnostics) { + const newDiagnostics = outcome.diagnostics.filter( + (d) => + !baseOutcome.diagnostics.some( + (bd) => + bd.code === d.code && + bd.message === d.message && + bd.config_ref === d.config_ref && + bd.oas_ref === d.oas_ref, + ), + ); + if (newDiagnostics.length > 0) { + const levelCounts: Record = { + fatal: 0, + error: 0, + warning: 0, + note: 0, + }; + + for (const d of newDiagnostics) { + levelCounts[d.level]++; + } + + if ( + levelCounts.fatal > 0 || + levelCounts.error > 0 || + levelCounts.warning > 0 + ) { + isRegression = true; + } + + const diagnosticCounts = Object.entries(levelCounts) + .filter(([, count]) => count > 0) + .map(([level, count]) => `${count} ${level}`); + + let hasOmittedDiagnostics = newDiagnostics.length > 10; + const diagnosticList = newDiagnostics + .slice(0, 10) + .map((d) => { + if (d.level === "note") { + hasOmittedDiagnostics = true; + return null; + } + return `${DiagnosticIcon[d.level]} ${MD.Bold(d.code)}: ${ + d.message + }`; + }) + .filter(Boolean) as string[]; + + details.push( + MD.Details({ + summary: `New diagnostics (${diagnosticCounts.join(", ")})`, + body: MD.Dedent` + ${ + hasOmittedDiagnostics ? "Some diagnostics omitted. " : "" + }See the Stainless Studio for more details. + + ${MD.List(diagnosticList)} + `, + }), + ); + } + } + + // Installation instructions: + const installation = getInstallation(lang, outcome); + if (installation) { + details.push( + MD.Details({ + summary: "Installation", + body: MD.CodeBlock({ content: installation, language: "bash" }), + indent: false, + }), + ); + } + + result[lang] = { + githubLink, + compareLink, + details, + isPending, + isRegression, + }; + } + + return result; +} + +function printRegressions({ + orgName, + projectName, + branch, + details, +}: { + orgName: string; + projectName: string; + branch: string; + details: Details; +}) { + const regressions = Object.entries(details).filter( + ([, { isRegression }]) => isRegression, + ); + + if (regressions.length === 0) { + return null; + } + + const formattedRegressions = regressions.map( + ([lang, { githubLink, compareLink, details }]) => { + const studioURL = getStudioURL({ + orgName, + projectName, + language: lang, + branch, + }); + const studioLink = MD.Link({ text: "studio", href: studioURL }); + + const headingLinks = [studioLink, githubLink, compareLink] + .filter((link): link is string => link !== null) + .join(` ${MD.Symbol.MiddleDot} `); + + return MD.Details({ + summary: `${projectName}-${lang}: ${headingLinks}`, + body: details.join("\n\n"), + open: true, + }); + }, + ); + + return MD.Dedent` + ${MD.Symbol.Warning} ${MD.Bold("Regressions.")} + + ${formattedRegressions.join("\n\n")} + `; +} + +function printSuccesses({ + orgName, + projectName, + branch, + details, +}: { + orgName: string; + projectName: string; + branch: string; + details: Details; +}) { + const successes = Object.entries(details).filter( + ([, { isPending, isRegression }]) => !isPending && !isRegression, + ); + + if (successes.length === 0) { + return null; + } + + const formattedSuccesses = successes.map( + ([lang, { githubLink, compareLink, details }]) => { + const studioURL = getStudioURL({ + orgName, + projectName, + language: lang, + branch, + }); + const studioLink = MD.Link({ text: "studio", href: studioURL }); + + const headingLinks = [studioLink, githubLink, compareLink] + .filter((link): link is string => link !== null) + .join(` ${MD.Symbol.MiddleDot} `); + const summary = `${projectName}-${lang}: ${headingLinks}`; + + return details.length > 0 + ? MD.Details({ summary, body: details.join("\n\n") }) + : `- ${summary}`; + }, + ); + + return MD.Dedent` + ${MD.Symbol.WhiteCheckMark} ${MD.Bold("Successes.")} + + ${formattedSuccesses.join("\n\n")} + `; +} + +function printPending({ details }: { details: Details }) { + const hasPending = Object.values(details).some(({ isPending }) => isPending); + + if (!hasPending) { + return null; + } + + return MD.Dedent` + ${MD.Symbol.HourglassFlowingSand} These are partial results; builds are still running. + `; +} + +function getInstallation(lang: string, outcome: Outcomes[string]) { + if (!outcome.commit.completed.commit) { + return null; + } + + const { repo } = outcome.commit.completed.commit; + + // TODO: update the API to return a URL, under build, and use that + switch (lang) { + case "typescript": + case "node": { + return `npm install ${getGitHubURL({ repo })}`; + } + case "python": { + return `pip install git+${getGitHubURL({ repo })}`; + } + default: { + return null; + } + } +} + +function getGitHubURL({ + repo, +}: { + repo: { owner: string; name: string; branch: string }; +}) { + return `https://github.com/${repo.owner}/${repo.name}.git#${repo.branch}`; +} + +function getStudioURL({ + orgName, + projectName, + language, + branch, +}: { + orgName: string; + projectName: string; + language?: string; + branch: string; +}) { + if (language) { + return `https://app.stainless.com/${orgName}/${projectName}/studio?language=${language}&branch=${branch}`; + } + return `https://app.stainless.com/${orgName}/${projectName}/studio?branch=${branch}`; +} + +export function parseCommitMessage(body?: string | null) { + return body?.match(/(? comment.body?.includes(COMMENT_TITLE)) ?? null; + + return { + id: existingComment?.id, + commitMessage: parseCommitMessage(existingComment?.body), + }; +} + +export async function upsertComment({ + body, + token, + skipCreate = false, +}: { + body: string; + token: string; + skipCreate?: boolean; +}) { + const client = createGitHubClient({ + authToken: token, + owner: github.context.repo.owner, + repo: github.context.repo.repo, + resources: [GitHubComments], + }); + + console.log("Upserting comment on PR:", github.context.issue.number); + + const { data: comments } = await client.repos.issues.comments.list( + github.context.issue.number, + ); + + const firstLine = body.trim().split("\n")[0]; + const existingComment = comments.find((comment) => + comment.body?.includes(firstLine), + ); + + if (existingComment) { + console.log("Updating existing comment:", existingComment.id); + await client.repos.issues.comments.update(existingComment.id, { body }); + } else if (!skipCreate) { + console.log("Creating new comment"); + await client.repos.issues.comments.create(github.context.issue.number, { + body, + }); + } +} diff --git a/src/config.ts b/src/config.ts new file mode 100644 index 00000000..2fe37514 --- /dev/null +++ b/src/config.ts @@ -0,0 +1,42 @@ +import * as exec from "@actions/exec"; + +export async function isConfigChanged({ + before, + after, + oasPath, + configPath, +}: { + before: string; + after: string; + oasPath?: string; + configPath?: string; +}): Promise { + await exec.exec("git", ["fetch", "--depth=1", "origin", before], { + silent: true, + }); + await exec.exec("git", ["fetch", "--depth=1", "origin", after], { + silent: true, + }); + + const diffOutput = await exec.getExecOutput("git", [ + "diff", + "--name-only", + before, + after, + ]); + const changedFiles = diffOutput.stdout.trim().split("\n"); + + let changed = false; + + if (oasPath && changedFiles.includes(oasPath)) { + console.log("OAS file changed"); + changed = true; + } + + if (configPath && changedFiles.includes(configPath)) { + console.log("Config file changed"); + changed = true; + } + + return changed; +} diff --git a/index.ts b/src/index.ts similarity index 100% rename from index.ts rename to src/index.ts diff --git a/src/markdown.ts b/src/markdown.ts new file mode 100644 index 00000000..214cae6f --- /dev/null +++ b/src/markdown.ts @@ -0,0 +1,97 @@ +import { dedent as tsdedent } from "ts-dedent"; + +export const Symbol = { + Bulb: "💡", + Exclamation: "❗", + GreenSquare: "🟩", + HeavyAsterisk: "✱", + HourglassFlowingSand: "⏳", + MiddleDot: "·", + RedSquare: "🟥", + RightwardsArrow: "→", + SpeechBalloon: "💬", + Warning: "⚠️", + WhiteCheckMark: "✅", + WhiteLargeSquare: "⬜", + Zap: "⚡", +}; + +export const Bold = (content: string) => `${content}`; + +export const CodeInline = (content: string) => `${content}`; + +export const Comment = (content: string) => ``; + +export const Italic = (content: string) => `${content}`; + +export function Dedent( + templ: string | TemplateStringsArray, + ...args: unknown[] +): string { + return ( + tsdedent(templ, ...args) + .trim() + // Wrapping dedent to remove lines that only contain spaces. + // Here's the corresponding bug report: https://github.com/tamino-martinius/node-ts-dedent/issues/37 + .replaceAll(/\n\s*\n/gi, "\n\n") + ); +} + +export const Blockquote = (content: string) => + Dedent` +
+ + ${content} + +
+ `; + +export const CodeBlock = ( + props: string | { content: string; language?: string }, +): string => { + const delimiter = "```"; + const content = typeof props === "string" ? props : props.content; + const language = typeof props === "string" ? "" : props.language; + + return Dedent` + ${delimiter}${language} + ${content} + ${delimiter} + `; +}; + +export const Details = ({ + summary, + body, + indent = true, + open = false, +}: { + summary: string; + body: string; + indent?: boolean; + open?: boolean; +}) => { + return Dedent` + + ${summary} + + ${indent ? Blockquote(body) : body} + + + `; +}; + +export const Heading = (content: string) => `

${content}

`; + +export const Link = ({ text, href }: { text: string; href: string }) => + `${text}`; + +export const List = (lines: string[]) => { + return Dedent` +
    + ${lines.map((line) => `
  • ${line}
    • `).join("\n")} +
+ `; +}; + +export const Rule = () => `
`; diff --git a/src/merge.ts b/src/merge.ts new file mode 100644 index 00000000..1da9ac93 --- /dev/null +++ b/src/merge.ts @@ -0,0 +1,130 @@ +import { + endGroup, + getBooleanInput, + getInput, + setOutput, + startGroup, +} from "@actions/core"; +import { Stainless } from "@stainless-api/sdk"; +import { checkResults, runBuilds, RunResult } from "./runBuilds"; +import { printComment, retrieveComment, upsertComment } from "./comment"; +import { isConfigChanged } from "./config"; + +async function main() { + try { + const apiKey = getInput("stainless_api_key", { required: true }); + const orgName = getInput("org", { required: false }); + const projectName = getInput("project", { required: true }); + const oasPath = getInput("oas_path", { required: false }); + const configPath = + getInput("config_path", { required: false }) || undefined; + const defaultCommitMessage = getInput("commit_message", { required: true }); + const failRunOn = getInput("fail_on", { required: true }) || "error"; + const makeComment = getBooleanInput("make_comment", { required: true }); + const githubToken = getInput("github_token", { required: false }); + const baseSha = getInput("base_sha", { required: true }); + const baseRef = getInput("base_ref", { required: true }); + const defaultBranch = getInput("default_branch", { required: true }); + const headSha = getInput("head_sha", { required: true }); + const mergeBranch = getInput("merge_branch", { required: true }); + const outputDir = getInput("output_dir", { required: false }) || undefined; + + if (makeComment && !githubToken) { + throw new Error("github_token is required to make a comment"); + } + + if (baseRef !== defaultBranch) { + console.log("Not merging to default branch, skipping merge"); + return; + } + + const stainless = new Stainless({ + project: projectName, + apiKey, + logLevel: "warn", + }); + + const configChanged = await isConfigChanged({ + before: baseSha, + after: headSha, + oasPath, + configPath, + }); + + if (!configChanged) { + console.log("No config files changed, skipping merge"); + return; + } + + let commitMessage = defaultCommitMessage; + + if (makeComment && githubToken) { + const comment = await retrieveComment({ token: githubToken }); + if (comment.commitMessage) { + commitMessage = comment.commitMessage; + } + } + + console.log("Using commit message:", commitMessage); + + const generator = runBuilds({ + stainless, + projectName, + commitMessage, + // This action always merges to the Stainless `main` branch: + branch: "main", + mergeBranch, + guessConfig: false, + outputDir, + }); + + let latestRun: RunResult; + + // eslint-disable-next-line no-constant-condition + while (true) { + startGroup("Running builds"); + + const run = await generator.next(); + + endGroup(); + + if (run.done) { + const { outcomes, documentedSpecPath } = latestRun!; + + setOutput("outcomes", outcomes); + setOutput("documented_spec_path", documentedSpecPath); + + if (!checkResults({ outcomes, failRunOn })) { + process.exit(1); + } + + break; + } + + latestRun = run.value; + + if (makeComment) { + const { outcomes } = latestRun; + + startGroup("Updating comment"); + + const commentBody = printComment({ + orgName, + projectName, + branch: "main", + commitMessage, + outcomes, + }); + + await upsertComment({ body: commentBody, token: githubToken }); + + endGroup(); + } + } + } catch (error) { + console.error("Error in merge action:", error); + process.exit(1); + } +} + +main(); diff --git a/src/preview.ts b/src/preview.ts new file mode 100644 index 00000000..d69c5393 --- /dev/null +++ b/src/preview.ts @@ -0,0 +1,314 @@ +import { + endGroup, + getBooleanInput, + getInput, + setOutput, + startGroup, +} from "@actions/core"; +import * as exec from "@actions/exec"; +import * as github from "@actions/github"; +import { Stainless } from "@stainless-api/sdk"; +import { checkResults, runBuilds, RunResult } from "./runBuilds"; +import { printComment, retrieveComment, upsertComment } from "./comment"; +import { isConfigChanged } from "./config"; + +async function main() { + try { + const apiKey = getInput("stainless_api_key", { required: true }); + const orgName = getInput("org", { required: true }); + const projectName = getInput("project", { required: true }); + const oasPath = getInput("oas_path", { required: true }); + const configPath = + getInput("config_path", { required: false }) || undefined; + const defaultCommitMessage = getInput("commit_message", { required: true }); + const failRunOn = getInput("fail_on", { required: true }) || "error"; + const makeComment = getBooleanInput("make_comment", { required: true }); + const githubToken = getInput("github_token", { required: false }); + const baseSha = getInput("base_sha", { required: true }); + const baseRef = getInput("base_ref", { required: true }); + const baseBranch = getInput("base_branch", { required: true }); + const defaultBranch = getInput("default_branch", { required: true }); + const headSha = getInput("head_sha", { required: true }); + const branch = getInput("branch", { required: true }); + + if (makeComment && !githubToken) { + throw new Error("github_token is required to make a comment"); + } + + const stainless = new Stainless({ + project: projectName, + apiKey, + logLevel: "warn", + }); + + startGroup("Getting parent revision"); + + const { mergeBaseSha, nonMainBaseRef } = await getParentCommits({ + baseSha, + headSha, + baseRef, + defaultBranch, + }); + + const configChanged = await isConfigChanged({ + before: mergeBaseSha, + after: headSha, + oasPath, + configPath, + }); + + if (!configChanged) { + console.log("No config files changed, skipping preview"); + + // In this case, we only want to make a comment if there's an existing + // comment---which can happen if the changes introduced by the PR + // disappear for some reason. + if ( + github.context.payload.pull_request!.action !== "opened" && + makeComment + ) { + startGroup("Updating comment"); + + const commentBody = printComment({ noChanges: true }); + + await upsertComment({ + body: commentBody, + token: githubToken, + skipCreate: true, + }); + + endGroup(); + } + + return; + } + + const baseRevision = await computeBaseRevision({ + stainless, + projectName, + mergeBaseSha, + nonMainBaseRef, + oasPath, + configPath, + }); + + endGroup(); + + let commitMessage = defaultCommitMessage; + + if (makeComment) { + const comment = await retrieveComment({ token: githubToken }); + if (comment.commitMessage) { + commitMessage = comment.commitMessage; + } + } + + console.log("Using commit message:", commitMessage); + + // Checkout HEAD for runBuilds to pull the files of: + await exec.exec("git", ["checkout", headSha], { silent: true }); + + let latestRun: RunResult; + + const generator = runBuilds({ + stainless, + oasPath, + configPath, + projectName, + baseRevision, + baseBranch, + branch, + guessConfig: !configPath, + commitMessage, + }); + + // eslint-disable-next-line no-constant-condition + while (true) { + startGroup("Running builds"); + + const run = await generator.next(); + + endGroup(); + + if (run.done) { + const { outcomes, baseOutcomes } = latestRun!; + + setOutput("outcomes", outcomes); + setOutput("base_outcomes", baseOutcomes); + + if (!checkResults({ outcomes, failRunOn })) { + process.exit(1); + } + + break; + } + + latestRun = run.value; + + if (makeComment) { + const { outcomes, baseOutcomes } = latestRun; + + startGroup("Updating comment"); + + // In case the comment was updated between polls: + const comment = await retrieveComment({ token: githubToken }); + if (comment.commitMessage) { + commitMessage = comment.commitMessage; + } + + const commentBody = printComment({ + orgName, + projectName, + branch, + commitMessage, + outcomes, + baseOutcomes, + }); + + await upsertComment({ body: commentBody, token: githubToken }); + + endGroup(); + } + } + } catch (error) { + console.error("Error in preview action:", error); + process.exit(1); + } +} + +async function getParentCommits({ + baseSha, + headSha, + baseRef, + defaultBranch, +}: { + baseSha: string; + headSha: string; + baseRef: string; + defaultBranch: string; +}) { + await exec.exec("git", ["fetch", "--depth=1", "origin", baseSha], { + silent: true, + }); + + let mergeBaseSha: string | undefined; + + for (let attempt = 0; attempt < 10; attempt++) { + try { + const output = await exec.getExecOutput( + "git", + ["merge-base", headSha, baseSha], + { silent: true }, + ); + mergeBaseSha = output.stdout.trim(); + if (mergeBaseSha) break; + } catch { + // ignore + } + + // deepen fetch until we find merge base + await exec.exec( + "git", + ["fetch", "--quiet", "--deepen=10", "origin", baseSha, headSha], + { silent: true }, + ); + } + + if (!mergeBaseSha) { + throw new Error("Could not determine merge base SHA"); + } + + console.log(`Merge base: ${mergeBaseSha}`); + + let nonMainBaseRef: string | undefined; + + if (baseRef !== defaultBranch) { + nonMainBaseRef = `preview/${baseRef}`; + console.log(`Non-main base ref: ${nonMainBaseRef}`); + } + + return { mergeBaseSha, nonMainBaseRef }; +} + +async function computeBaseRevision({ + stainless, + projectName, + mergeBaseSha, + nonMainBaseRef, + oasPath, + configPath, +}: { + stainless: Stainless; + projectName: string; + mergeBaseSha?: string; + nonMainBaseRef?: string; + oasPath?: string; + configPath?: string; +}) { + if (mergeBaseSha) { + const hashes: Record = {}; + + await exec.exec("git", ["checkout", mergeBaseSha], { silent: true }); + + for (const [path, file] of [ + [oasPath, "openapi.yml"], + [configPath, "openapi.stainless.yml"], + ]) { + if (path) { + await exec + .getExecOutput("md5sum", [path], { silent: true }) + .then(({ stdout }) => { + hashes[file!] = { hash: stdout.split(" ")[0] }; + }) + .catch(() => { + console.log(`File ${path} does not exist at merge base.`); + }); + } + } + + const configCommit = ( + await stainless.builds.list({ + project: projectName, + revision: hashes, + limit: 1, + }) + ).data[0]?.config_commit; + + if (configCommit) { + console.log(`Found base via merge base SHA: ${configCommit}`); + return configCommit; + } + } + + if (nonMainBaseRef) { + const configCommit = ( + await stainless.builds.list({ + project: projectName, + branch: nonMainBaseRef, + limit: 1, + }) + ).data[0]?.config_commit; + + if (configCommit) { + console.log(`Found base via non-main base ref: ${configCommit}`); + return configCommit; + } + } + + const configCommit = ( + await stainless.builds.list({ + project: projectName, + branch: "main", + limit: 1, + }) + ).data[0]?.config_commit; + + if (!configCommit) { + throw new Error("Could not determine base revision"); + } + + console.log(`Found base via main branch: ${configCommit}`); + return configCommit; +} + +main(); diff --git a/src/runBuilds.ts b/src/runBuilds.ts new file mode 100644 index 00000000..a3accfab --- /dev/null +++ b/src/runBuilds.ts @@ -0,0 +1,375 @@ +import { Stainless } from "@stainless-api/sdk"; +import * as fs from "fs"; + +type Build = Stainless.Builds.BuildObject; +export type Outcomes = Record< + string, + Exclude & { + commit: Stainless.Builds.BuildTarget.Completed | null; + diagnostics: Stainless.Builds.Diagnostics.DiagnosticListResponse[]; + } +>; + +// https://www.conventionalcommits.org/en/v1.0.0/ +const CONVENTIONAL_COMMIT_REGEX = new RegExp( + /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?(!?): .*$/, +); + +const isValidConventionalCommitMessage = (message: string) => { + return CONVENTIONAL_COMMIT_REGEX.test(message); +}; + +const POLLING_INTERVAL_SECONDS = 5; +const MAX_POLLING_SECONDS = 10 * 60; // 10 minutes + +export type RunResult = { + baseOutcomes: Outcomes | null; + outcomes: Outcomes; + documentedSpecPath: string | null; +}; + +export async function* runBuilds({ + stainless, + projectName, + baseRevision, + baseBranch, + mergeBranch, + branch, + oasPath, + configPath, + guessConfig = false, + commitMessage, + outputDir, +}: { + stainless: Stainless; + projectName: string; + baseRevision?: string; + baseBranch?: string; + mergeBranch?: string; + branch?: string; + oasPath?: string; + configPath?: string; + guessConfig?: boolean; + commitMessage?: string; + outputDir?: string; +}): AsyncGenerator { + if (mergeBranch && (oasPath || configPath)) { + throw new Error( + "Cannot specify both merge_branch and oas_path or config_path", + ); + } + if (guessConfig && (configPath || !oasPath)) { + throw new Error( + "If guess_config is true, must have oas_path and no config_path", + ); + } + if (baseRevision && mergeBranch) { + throw new Error("Cannot specify both base_revision and merge_branch"); + } + if (commitMessage && !isValidConventionalCommitMessage(commitMessage)) { + console.warn( + `Commit message: "${commitMessage}" is not in Conventional Commits format: https://www.conventionalcommits.org/en/v1.0.0/. Prepending "feat" and using anyway.`, + ); + commitMessage = `feat: ${commitMessage}`; + } + + const oasContent = oasPath ? fs.readFileSync(oasPath, "utf-8") : undefined; + let configContent = configPath + ? fs.readFileSync(configPath, "utf-8") + : undefined; + + if (!baseRevision) { + const build = await stainless.builds.create( + { + project: projectName, + revision: mergeBranch + ? `${branch}..${mergeBranch}` + : { + ...(oasContent && { + "openapi.yml": { + content: oasContent, + }, + }), + ...(configContent && { + "openapi.stainless.yml": { + content: configContent, + }, + }), + }, + branch, + commit_message: commitMessage, + allow_empty: true, + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1000, + }, + ); + + for (const waitFor of ["postgen", "completed"] as const) { + const { outcomes, documentedSpec } = await pollBuild({ + stainless, + build, + waitFor, + }); + + let documentedSpecPath: string | null = null; + if (outputDir && documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, documentedSpec); + } + + yield { + baseOutcomes: null, + outcomes, + documentedSpecPath, + }; + } + + return; + } + + if (!configContent) { + if (guessConfig) { + console.log("Guessing config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.guess({ + branch, + spec: oasContent!, + }), + )[0]?.content; + } else { + console.log("Saving config before branch reset"); + configContent = Object.values( + await stainless.projects.configs.retrieve({ + branch, + }), + )[0]?.content; + } + } + + console.log(`Hard resetting ${branch} to ${baseRevision}`); + const { config_commit } = await stainless.projects.branches.create({ + branch_from: baseRevision, + branch: branch!, + force: true, + }); + console.log(`Hard reset ${branch}, now at ${config_commit.sha}`); + + const { base, head } = await stainless.builds.compare( + { + base: { + revision: baseRevision, + branch: baseBranch, + commit_message: commitMessage, + }, + head: { + revision: { + ...(oasContent && { + "openapi.yml": { + content: oasContent, + }, + }), + ...(configContent && { + "openapi.stainless.yml": { + content: configContent, + }, + }), + }, + branch, + commit_message: commitMessage, + }, + }, + { + // For very large specs, writing the config files can take a while. + timeout: 3 * 60 * 1000, + }, + ); + + for (const waitFor of ["postgen", "completed"] as const) { + // yield once in postgen and again once it's completed + const results = await Promise.all([ + pollBuild({ stainless, build: base, waitFor }), + pollBuild({ stainless, build: head, waitFor }), + ]); + + let documentedSpecPath: string | null = null; + if (outputDir && results[1].documentedSpec) { + documentedSpecPath = `${outputDir}/openapi.documented.yml`; + fs.mkdirSync(outputDir, { recursive: true }); + fs.writeFileSync(documentedSpecPath, results[1].documentedSpec); + } + + yield { + baseOutcomes: results[0].outcomes, + outcomes: results[1].outcomes, + documentedSpecPath, + }; + } + + return; +} + +async function pollBuild({ + stainless, + build, + waitFor, + pollingIntervalSeconds = POLLING_INTERVAL_SECONDS, + maxPollingSeconds = MAX_POLLING_SECONDS, +}: { + stainless: Stainless; + build: Build; + waitFor: "postgen" | "completed"; + pollingIntervalSeconds?: number; + maxPollingSeconds?: number; +}) { + const outcomes: Outcomes = {}; + let documentedSpec: string | null = null; + + const buildId = build.id; + const languages = Object.keys(build.targets) as Array< + keyof typeof build.targets + >; + if (buildId) { + console.log( + `[${buildId}] Created build against ${ + build.config_commit + } for languages: ${languages.join(", ")}`, + ); + } else { + console.log(`No new build was created; exiting.`); + return { outcomes, documentedSpec }; + } + + const pollingStart = Date.now(); + while ( + Object.keys(outcomes).length < languages.length && + Date.now() - pollingStart < maxPollingSeconds * 1000 + ) { + const build = await stainless.builds.retrieve(buildId); + for (const language of languages) { + if (!(language in outcomes)) { + const buildOutput = build.targets[language]!; + + console.log( + `[${buildId}] Build for ${language} has status ${buildOutput.status}`, + ); + + if ( + [waitFor, "completed"].includes(buildOutput.status) && + buildOutput.commit.status === "completed" + ) { + console.log( + `[${buildId}] Build has output:`, + JSON.stringify(buildOutput), + ); + + const diagnostics: Stainless.Builds.Diagnostics.DiagnosticListResponse[] = + []; + try { + for await (const diagnostic of stainless.builds.diagnostics.list( + buildId, + )) { + diagnostics.push(diagnostic); + } + } catch (e) { + console.error( + `[${buildId}] Error getting diagnostics, continuing anyway`, + e, + ); + } + + outcomes[language] = { + ...buildOutput, + commit: buildOutput.commit, + diagnostics, + }; + } + } + } + + if (!documentedSpec && build.documented_spec) { + documentedSpec = await Stainless.unwrapFile(build.documented_spec); + } + + // wait a bit before polling again + await new Promise((resolve) => + setTimeout(resolve, pollingIntervalSeconds * 1000), + ); + } + + const languagesWithoutOutcome = languages.filter( + (language) => !(language in outcomes), + ); + for (const language of languagesWithoutOutcome) { + console.log( + `[${buildId}] Build for ${language} timed out after ${maxPollingSeconds} seconds`, + ); + outcomes[language] = { + object: "build_target", + status: "completed", + lint: { + status: "not_started", + }, + test: { + status: "not_started", + }, + commit: { + status: "completed", + completed: { + conclusion: "timed_out", + commit: null, + merge_conflict_pr: null, + url: null, + }, + }, + diagnostics: [], + }; + } + + return { outcomes, documentedSpec }; +} + +export function checkResults({ + outcomes, + failRunOn, +}: { + outcomes: Outcomes; + failRunOn: string; +}) { + if (failRunOn === "never") { + return true; + } + + const failedLanguages = Object.entries(outcomes).filter(([_, outcome]) => { + if (!outcome.commit || outcome.commit.completed.conclusion === "noop") { + return true; + } + if ( + failRunOn === "error" || + failRunOn === "warning" || + failRunOn === "note" + ) { + if (outcome.commit.completed.conclusion === "error") return true; + } + if (failRunOn === "warning" || failRunOn === "note") { + if (outcome.commit.completed.conclusion === "warning") return true; + } + if (failRunOn === "note") { + if (outcome.commit.completed.conclusion === "note") return true; + } + return false; + }); + + if (failedLanguages.length > 0) { + console.log( + `The following languages did not build successfully: ${failedLanguages + .map(([lang]) => lang) + .join(", ")}`, + ); + return false; + } + + return true; +} diff --git a/tsconfig.json b/tsconfig.json index 1be6e3af..6b023d00 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -1,59 +1,13 @@ { - "ts-node": { - "transpileOnly": true, - "compilerOptions": { - "module": "commonjs" - } - }, - - "exclude": ["dist"], - "compilerOptions": { - /* Visit https://aka.ms/tsconfig.json to read more about this file */ - /* Projects */ - "incremental": true, - - /* Language and Environment */ - "target": "es2016", - "lib": ["DOM", "DOM.Iterable", "ESNext"], - "jsx": "react", - - /* Modules */ + "target": "ESNext", "module": "commonjs", - "rootDir": "./", - "moduleResolution": "node", - "baseUrl": "./", - "paths": { - "/*": ["*"], // Won't work until https://github.com/dividab/tsconfig-paths/pull/180 merges - "~/*": ["*"] - }, - "resolveJsonModule": true, - - /* Emit */ - "outDir": "node_modules", - "noEmit": true, - - /* Interop Constraints */ - "isolatedModules": true, - "allowSyntheticDefaultImports": true, - "esModuleInterop": true, - "forceConsistentCasingInFileNames": true, - "allowJs": true, - "checkJs": true, - - /* Type Checking */ + "outDir": "./dist", + "rootDir": "./src", "strict": true, - "noImplicitAny": true, - "strictNullChecks": true, - "strictFunctionTypes": true, - "strictBindCallApply": true, - "strictPropertyInitialization": true, - "noImplicitThis": true, - "alwaysStrict": true, - "exactOptionalPropertyTypes": true, - "noUncheckedIndexedAccess": true, - "noImplicitOverride": true, - "noPropertyAccessFromIndexSignature": true, + "esModuleInterop": true, "skipLibCheck": true - } + }, + "include": ["src"], + "exclude": ["node_modules"] } diff --git a/yarn.lock b/yarn.lock deleted file mode 100644 index de31f2c9..00000000 --- a/yarn.lock +++ /dev/null @@ -1,1014 +0,0 @@ -# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. -# yarn lockfile v1 - - -"@actions/core@^1.10.0": - version "1.11.1" - resolved "https://registry.npmjs.org/@actions/core/-/core-1.11.1.tgz" - integrity sha512-hXJCSrkwfA46Vd9Z3q4cpEpHB1rL5NG04+/rbqW9d3+CSvtB1tYe8UTpAlixa1vj0m/ULglfEK2UKxMGxCxv5A== - dependencies: - "@actions/exec" "^1.1.1" - "@actions/http-client" "^2.0.1" - -"@actions/exec@^1.1.1": - version "1.1.1" - resolved "https://registry.npmjs.org/@actions/exec/-/exec-1.1.1.tgz" - integrity sha512-+sCcHHbVdk93a0XT19ECtO/gIXoxvdsgQLzb2fE2/5sIZmWQuluYyjPQtrtTHdU1YzTZ7bAPN4sITq2xi1679w== - dependencies: - "@actions/io" "^1.0.1" - -"@actions/http-client@^2.0.1": - version "2.2.3" - resolved "https://registry.npmjs.org/@actions/http-client/-/http-client-2.2.3.tgz" - integrity sha512-mx8hyJi/hjFvbPokCg4uRd4ZX78t+YyRPtnKWwIl+RzNaVuFpQHfmlGVfsKEJN8LwTCvL+DfVgAM04XaHkm6bA== - dependencies: - tunnel "^0.0.6" - undici "^5.25.4" - -"@actions/io@^1.0.1": - version "1.1.3" - resolved "https://registry.npmjs.org/@actions/io/-/io-1.1.3.tgz" - integrity sha512-wi9JjgKLYS7U/z8PPbco+PvTb/nRWjeoFlJ1Qer83k/3C5PHQi28hiVdeE2kHXmIL99mQFawx8qt/JPjZilJ8Q== - -"@eslint-community/eslint-utils@^4.2.0": - version "4.7.0" - resolved "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz" - integrity sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw== - dependencies: - eslint-visitor-keys "^3.4.3" - -"@eslint-community/regexpp@^4.4.0", "@eslint-community/regexpp@^4.6.1": - version "4.12.1" - resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz" - integrity sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ== - -"@eslint/eslintrc@^2.1.4": - version "2.1.4" - resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz" - integrity sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ== - dependencies: - ajv "^6.12.4" - debug "^4.3.2" - espree "^9.6.0" - globals "^13.19.0" - ignore "^5.2.0" - import-fresh "^3.2.1" - js-yaml "^4.1.0" - minimatch "^3.1.2" - strip-json-comments "^3.1.1" - -"@eslint/js@8.57.1": - version "8.57.1" - resolved "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz" - integrity sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q== - -"@fastify/busboy@^2.0.0": - version "2.1.1" - resolved "https://registry.npmjs.org/@fastify/busboy/-/busboy-2.1.1.tgz" - integrity sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA== - -"@humanwhocodes/config-array@^0.13.0": - version "0.13.0" - resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz" - integrity sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw== - dependencies: - "@humanwhocodes/object-schema" "^2.0.3" - debug "^4.3.1" - minimatch "^3.0.5" - -"@humanwhocodes/module-importer@^1.0.1": - version "1.0.1" - resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz" - integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA== - -"@humanwhocodes/object-schema@^2.0.3": - version "2.0.3" - resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz" - integrity sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA== - -"@nodelib/fs.scandir@2.1.5": - version "2.1.5" - resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz" - integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== - dependencies: - "@nodelib/fs.stat" "2.0.5" - run-parallel "^1.1.9" - -"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": - version "2.0.5" - resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz" - integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== - -"@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8": - version "1.2.8" - resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz" - integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== - dependencies: - "@nodelib/fs.scandir" "2.1.5" - fastq "^1.6.0" - -"@pkgr/core@^0.2.4": - version "0.2.7" - resolved "https://registry.yarnpkg.com/@pkgr/core/-/core-0.2.7.tgz#eb5014dfd0b03e7f3ba2eeeff506eed89b028058" - integrity sha512-YLT9Zo3oNPJoBjBc4q8G2mjU4tqIbf5CEOORbUUr48dCD9q3umJ3IPlVqOqDakPfd2HuwccBaqlGhN4Gmr5OWg== - -"@stainless-api/sdk@^0.1.0-alpha.10": - version "0.1.0-alpha.11" - resolved "https://registry.npmjs.org/@stainless-api/sdk/-/sdk-0.1.0-alpha.11.tgz" - integrity sha512-fsKZLENhvwbCJFmjt5Gu3FnyDWx9Diy6zdBH8I6ZpbcKm+B/4qk+PH8baUHLAtJfUHfk5HuaIyiM0mWlGgI30w== - -"@types/json-schema@^7.0.9": - version "7.0.15" - resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz" - integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA== - -"@types/node@^22.10.6": - version "22.16.2" - resolved "https://registry.yarnpkg.com/@types/node/-/node-22.16.2.tgz#0a7b5b852105fb3f5019134f87fa859d5abcab9b" - integrity sha512-Cdqa/eJTvt4fC4wmq1Mcc0CPUjp/Qy2FGqLza3z3pKymsI969TcZ54diNJv8UYUgeWxyb8FSbCkhdR6WqmUFhA== - dependencies: - undici-types "~6.21.0" - -"@types/semver@^7.3.12": - version "7.7.0" - resolved "https://registry.npmjs.org/@types/semver/-/semver-7.7.0.tgz" - integrity sha512-k107IF4+Xr7UHjwDc7Cfd6PRQfbdkiRabXGRjo07b4WyPahFBZCZ1sE+BNxYIJPPg73UkfOsVOLwqVc/6ETrIA== - -"@typescript-eslint/eslint-plugin@^5.40.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz" - integrity sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag== - dependencies: - "@eslint-community/regexpp" "^4.4.0" - "@typescript-eslint/scope-manager" "5.62.0" - "@typescript-eslint/type-utils" "5.62.0" - "@typescript-eslint/utils" "5.62.0" - debug "^4.3.4" - graphemer "^1.4.0" - ignore "^5.2.0" - natural-compare-lite "^1.4.0" - semver "^7.3.7" - tsutils "^3.21.0" - -"@typescript-eslint/parser@^5.40.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz" - integrity sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA== - dependencies: - "@typescript-eslint/scope-manager" "5.62.0" - "@typescript-eslint/types" "5.62.0" - "@typescript-eslint/typescript-estree" "5.62.0" - debug "^4.3.4" - -"@typescript-eslint/scope-manager@5.62.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz" - integrity sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w== - dependencies: - "@typescript-eslint/types" "5.62.0" - "@typescript-eslint/visitor-keys" "5.62.0" - -"@typescript-eslint/type-utils@5.62.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz" - integrity sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew== - dependencies: - "@typescript-eslint/typescript-estree" "5.62.0" - "@typescript-eslint/utils" "5.62.0" - debug "^4.3.4" - tsutils "^3.21.0" - -"@typescript-eslint/types@5.62.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz" - integrity sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ== - -"@typescript-eslint/typescript-estree@5.62.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz" - integrity sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA== - dependencies: - "@typescript-eslint/types" "5.62.0" - "@typescript-eslint/visitor-keys" "5.62.0" - debug "^4.3.4" - globby "^11.1.0" - is-glob "^4.0.3" - semver "^7.3.7" - tsutils "^3.21.0" - -"@typescript-eslint/utils@5.62.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.62.0.tgz" - integrity sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ== - dependencies: - "@eslint-community/eslint-utils" "^4.2.0" - "@types/json-schema" "^7.0.9" - "@types/semver" "^7.3.12" - "@typescript-eslint/scope-manager" "5.62.0" - "@typescript-eslint/types" "5.62.0" - "@typescript-eslint/typescript-estree" "5.62.0" - eslint-scope "^5.1.1" - semver "^7.3.7" - -"@typescript-eslint/visitor-keys@5.62.0": - version "5.62.0" - resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz" - integrity sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw== - dependencies: - "@typescript-eslint/types" "5.62.0" - eslint-visitor-keys "^3.3.0" - -"@ungap/structured-clone@^1.2.0": - version "1.3.0" - resolved "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz" - integrity sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g== - -"@vercel/ncc@^0.38.0": - version "0.38.3" - resolved "https://registry.npmjs.org/@vercel/ncc/-/ncc-0.38.3.tgz" - integrity sha512-rnK6hJBS6mwc+Bkab+PGPs9OiS0i/3kdTO+CkI8V0/VrW3vmz7O2Pxjw/owOlmo6PKEIxRSeZKv/kuL9itnpYA== - -acorn-jsx@^5.3.2: - version "5.3.2" - resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz" - integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== - -acorn@^8.9.0: - version "8.15.0" - resolved "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz" - integrity sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg== - -ajv@^6.12.4: - version "6.12.6" - resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz" - integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== - dependencies: - fast-deep-equal "^3.1.1" - fast-json-stable-stringify "^2.0.0" - json-schema-traverse "^0.4.1" - uri-js "^4.2.2" - -ansi-regex@^5.0.1: - version "5.0.1" - resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz" - integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== - -ansi-styles@^4.1.0: - version "4.3.0" - resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz" - integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== - dependencies: - color-convert "^2.0.1" - -argparse@^2.0.1: - version "2.0.1" - resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz" - integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== - -array-union@^2.1.0: - version "2.1.0" - resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz" - integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw== - -balanced-match@^1.0.0: - version "1.0.2" - resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz" - integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== - -brace-expansion@^1.1.7: - version "1.1.12" - resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz" - integrity sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg== - dependencies: - balanced-match "^1.0.0" - concat-map "0.0.1" - -braces@^3.0.3: - version "3.0.3" - resolved "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz" - integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== - dependencies: - fill-range "^7.1.1" - -callsites@^3.0.0: - version "3.1.0" - resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz" - integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== - -chalk@^4.0.0: - version "4.1.2" - resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz" - integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== - dependencies: - ansi-styles "^4.1.0" - supports-color "^7.1.0" - -color-convert@^2.0.1: - version "2.0.1" - resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz" - integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== - dependencies: - color-name "~1.1.4" - -color-name@~1.1.4: - version "1.1.4" - resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz" - integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== - -concat-map@0.0.1: - version "0.0.1" - resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz" - integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== - -cross-spawn@^7.0.2: - version "7.0.6" - resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz" - integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA== - dependencies: - path-key "^3.1.0" - shebang-command "^2.0.0" - which "^2.0.1" - -debug@^4.3.1, debug@^4.3.2, debug@^4.3.4: - version "4.4.1" - resolved "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz" - integrity sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ== - dependencies: - ms "^2.1.3" - -deep-is@^0.1.3: - version "0.1.4" - resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz" - integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== - -dir-glob@^3.0.1: - version "3.0.1" - resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz" - integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA== - dependencies: - path-type "^4.0.0" - -doctrine@^3.0.0: - version "3.0.0" - resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz" - integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w== - dependencies: - esutils "^2.0.2" - -escape-string-regexp@^4.0.0: - version "4.0.0" - resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz" - integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== - -eslint-config-prettier@^10.1.5: - version "10.1.5" - resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-10.1.5.tgz#00c18d7225043b6fbce6a665697377998d453782" - integrity sha512-zc1UmCpNltmVY34vuLRV61r1K27sWuX39E+uyUnY8xS2Bex88VV9cugG+UZbRSRGtGyFboj+D8JODyme1plMpw== - -eslint-plugin-prettier@^5.5.1: - version "5.5.1" - resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.1.tgz#470820964de9aedb37e9ce62c3266d2d26d08d15" - integrity sha512-dobTkHT6XaEVOo8IO90Q4DOSxnm3Y151QxPJlM/vKC0bVy+d6cVWQZLlFiuZPP0wS6vZwSKeJgKkcS+KfMBlRw== - dependencies: - prettier-linter-helpers "^1.0.0" - synckit "^0.11.7" - -eslint-scope@^5.1.1: - version "5.1.1" - resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz" - integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw== - dependencies: - esrecurse "^4.3.0" - estraverse "^4.1.1" - -eslint-scope@^7.2.2: - version "7.2.2" - resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz" - integrity sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg== - dependencies: - esrecurse "^4.3.0" - estraverse "^5.2.0" - -eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1, eslint-visitor-keys@^3.4.3: - version "3.4.3" - resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz" - integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag== - -eslint@^8.25.0: - version "8.57.1" - resolved "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz" - integrity sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA== - dependencies: - "@eslint-community/eslint-utils" "^4.2.0" - "@eslint-community/regexpp" "^4.6.1" - "@eslint/eslintrc" "^2.1.4" - "@eslint/js" "8.57.1" - "@humanwhocodes/config-array" "^0.13.0" - "@humanwhocodes/module-importer" "^1.0.1" - "@nodelib/fs.walk" "^1.2.8" - "@ungap/structured-clone" "^1.2.0" - ajv "^6.12.4" - chalk "^4.0.0" - cross-spawn "^7.0.2" - debug "^4.3.2" - doctrine "^3.0.0" - escape-string-regexp "^4.0.0" - eslint-scope "^7.2.2" - eslint-visitor-keys "^3.4.3" - espree "^9.6.1" - esquery "^1.4.2" - esutils "^2.0.2" - fast-deep-equal "^3.1.3" - file-entry-cache "^6.0.1" - find-up "^5.0.0" - glob-parent "^6.0.2" - globals "^13.19.0" - graphemer "^1.4.0" - ignore "^5.2.0" - imurmurhash "^0.1.4" - is-glob "^4.0.0" - is-path-inside "^3.0.3" - js-yaml "^4.1.0" - json-stable-stringify-without-jsonify "^1.0.1" - levn "^0.4.1" - lodash.merge "^4.6.2" - minimatch "^3.1.2" - natural-compare "^1.4.0" - optionator "^0.9.3" - strip-ansi "^6.0.1" - text-table "^0.2.0" - -espree@^9.6.0, espree@^9.6.1: - version "9.6.1" - resolved "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz" - integrity sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ== - dependencies: - acorn "^8.9.0" - acorn-jsx "^5.3.2" - eslint-visitor-keys "^3.4.1" - -esquery@^1.4.2: - version "1.6.0" - resolved "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz" - integrity sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg== - dependencies: - estraverse "^5.1.0" - -esrecurse@^4.3.0: - version "4.3.0" - resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz" - integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== - dependencies: - estraverse "^5.2.0" - -estraverse@^4.1.1: - version "4.3.0" - resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz" - integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== - -estraverse@^5.1.0, estraverse@^5.2.0: - version "5.3.0" - resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz" - integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== - -esutils@^2.0.2: - version "2.0.3" - resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz" - integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== - -fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: - version "3.1.3" - resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz" - integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== - -fast-diff@^1.1.2: - version "1.3.0" - resolved "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz" - integrity sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw== - -fast-glob@^3.2.9: - version "3.3.3" - resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz" - integrity sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg== - dependencies: - "@nodelib/fs.stat" "^2.0.2" - "@nodelib/fs.walk" "^1.2.3" - glob-parent "^5.1.2" - merge2 "^1.3.0" - micromatch "^4.0.8" - -fast-json-stable-stringify@^2.0.0: - version "2.1.0" - resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz" - integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== - -fast-levenshtein@^2.0.6: - version "2.0.6" - resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz" - integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== - -fastq@^1.6.0: - version "1.19.1" - resolved "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz" - integrity sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ== - dependencies: - reusify "^1.0.4" - -file-entry-cache@^6.0.1: - version "6.0.1" - resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz" - integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg== - dependencies: - flat-cache "^3.0.4" - -fill-range@^7.1.1: - version "7.1.1" - resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz" - integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== - dependencies: - to-regex-range "^5.0.1" - -find-up@^5.0.0: - version "5.0.0" - resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz" - integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng== - dependencies: - locate-path "^6.0.0" - path-exists "^4.0.0" - -flat-cache@^3.0.4: - version "3.2.0" - resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz" - integrity sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw== - dependencies: - flatted "^3.2.9" - keyv "^4.5.3" - rimraf "^3.0.2" - -flatted@^3.2.9: - version "3.3.3" - resolved "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz" - integrity sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg== - -fs.realpath@^1.0.0: - version "1.0.0" - resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz" - integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== - -glob-parent@^5.1.2: - version "5.1.2" - resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz" - integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== - dependencies: - is-glob "^4.0.1" - -glob-parent@^6.0.2: - version "6.0.2" - resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz" - integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A== - dependencies: - is-glob "^4.0.3" - -glob@^7.1.3: - version "7.2.3" - resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz" - integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== - dependencies: - fs.realpath "^1.0.0" - inflight "^1.0.4" - inherits "2" - minimatch "^3.1.1" - once "^1.3.0" - path-is-absolute "^1.0.0" - -globals@^13.19.0: - version "13.24.0" - resolved "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz" - integrity sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ== - dependencies: - type-fest "^0.20.2" - -globby@^11.1.0: - version "11.1.0" - resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz" - integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g== - dependencies: - array-union "^2.1.0" - dir-glob "^3.0.1" - fast-glob "^3.2.9" - ignore "^5.2.0" - merge2 "^1.4.1" - slash "^3.0.0" - -graphemer@^1.4.0: - version "1.4.0" - resolved "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz" - integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag== - -has-flag@^4.0.0: - version "4.0.0" - resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz" - integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== - -husky@^8.0.1: - version "8.0.3" - resolved "https://registry.npmjs.org/husky/-/husky-8.0.3.tgz" - integrity sha512-+dQSyqPh4x1hlO1swXBiNb2HzTDN1I2IGLQx1GrBuiqFJfoMrnZWwVmatvSiO+Iz8fBUnf+lekwNo4c2LlXItg== - -ignore@^5.2.0: - version "5.3.2" - resolved "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz" - integrity sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g== - -import-fresh@^3.2.1: - version "3.3.1" - resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz" - integrity sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ== - dependencies: - parent-module "^1.0.0" - resolve-from "^4.0.0" - -imurmurhash@^0.1.4: - version "0.1.4" - resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz" - integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== - -inflight@^1.0.4: - version "1.0.6" - resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz" - integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== - dependencies: - once "^1.3.0" - wrappy "1" - -inherits@2: - version "2.0.4" - resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz" - integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== - -is-extglob@^2.1.1: - version "2.1.1" - resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz" - integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== - -is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3: - version "4.0.3" - resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz" - integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== - dependencies: - is-extglob "^2.1.1" - -is-number@^7.0.0: - version "7.0.0" - resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz" - integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== - -is-path-inside@^3.0.3: - version "3.0.3" - resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz" - integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ== - -isexe@^2.0.0: - version "2.0.0" - resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz" - integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== - -js-yaml@^4.1.0: - version "4.1.0" - resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz" - integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== - dependencies: - argparse "^2.0.1" - -json-buffer@3.0.1: - version "3.0.1" - resolved "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz" - integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ== - -json-schema-traverse@^0.4.1: - version "0.4.1" - resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz" - integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== - -json-stable-stringify-without-jsonify@^1.0.1: - version "1.0.1" - resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz" - integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw== - -keyv@^4.5.3: - version "4.5.4" - resolved "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz" - integrity sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw== - dependencies: - json-buffer "3.0.1" - -levn@^0.4.1: - version "0.4.1" - resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz" - integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ== - dependencies: - prelude-ls "^1.2.1" - type-check "~0.4.0" - -locate-path@^6.0.0: - version "6.0.0" - resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz" - integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw== - dependencies: - p-locate "^5.0.0" - -lodash.merge@^4.6.2: - version "4.6.2" - resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz" - integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== - -merge2@^1.3.0, merge2@^1.4.1: - version "1.4.1" - resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz" - integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== - -micromatch@^4.0.8: - version "4.0.8" - resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz" - integrity sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA== - dependencies: - braces "^3.0.3" - picomatch "^2.3.1" - -minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2: - version "3.1.2" - resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz" - integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== - dependencies: - brace-expansion "^1.1.7" - -ms@^2.1.3: - version "2.1.3" - resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz" - integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== - -natural-compare-lite@^1.4.0: - version "1.4.0" - resolved "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz" - integrity sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g== - -natural-compare@^1.4.0: - version "1.4.0" - resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz" - integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== - -once@^1.3.0: - version "1.4.0" - resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz" - integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== - dependencies: - wrappy "1" - -optionator@^0.9.3: - version "0.9.4" - resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz" - integrity sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g== - dependencies: - deep-is "^0.1.3" - fast-levenshtein "^2.0.6" - levn "^0.4.1" - prelude-ls "^1.2.1" - type-check "^0.4.0" - word-wrap "^1.2.5" - -p-limit@^3.0.2: - version "3.1.0" - resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz" - integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== - dependencies: - yocto-queue "^0.1.0" - -p-locate@^5.0.0: - version "5.0.0" - resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz" - integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw== - dependencies: - p-limit "^3.0.2" - -parent-module@^1.0.0: - version "1.0.1" - resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz" - integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g== - dependencies: - callsites "^3.0.0" - -path-exists@^4.0.0: - version "4.0.0" - resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz" - integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== - -path-is-absolute@^1.0.0: - version "1.0.1" - resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz" - integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== - -path-key@^3.1.0: - version "3.1.1" - resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz" - integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== - -path-type@^4.0.0: - version "4.0.0" - resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz" - integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw== - -picomatch@^2.3.1: - version "2.3.1" - resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz" - integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== - -prelude-ls@^1.2.1: - version "1.2.1" - resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz" - integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g== - -prettier-linter-helpers@^1.0.0: - version "1.0.0" - resolved "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz" - integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w== - dependencies: - fast-diff "^1.1.2" - -prettier@^3.6.2: - version "3.6.2" - resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.6.2.tgz#ccda02a1003ebbb2bfda6f83a074978f608b9393" - integrity sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ== - -punycode@^2.1.0: - version "2.3.1" - resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz" - integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg== - -queue-microtask@^1.2.2: - version "1.2.3" - resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz" - integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== - -resolve-from@^4.0.0: - version "4.0.0" - resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz" - integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g== - -reusify@^1.0.4: - version "1.1.0" - resolved "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz" - integrity sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw== - -rimraf@^3.0.2: - version "3.0.2" - resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz" - integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== - dependencies: - glob "^7.1.3" - -run-parallel@^1.1.9: - version "1.2.0" - resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz" - integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== - dependencies: - queue-microtask "^1.2.2" - -semver@^7.3.7: - version "7.7.2" - resolved "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz" - integrity sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA== - -shebang-command@^2.0.0: - version "2.0.0" - resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz" - integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== - dependencies: - shebang-regex "^3.0.0" - -shebang-regex@^3.0.0: - version "3.0.0" - resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz" - integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== - -slash@^3.0.0: - version "3.0.0" - resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz" - integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== - -strip-ansi@^6.0.1: - version "6.0.1" - resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz" - integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== - dependencies: - ansi-regex "^5.0.1" - -strip-json-comments@^3.1.1: - version "3.1.1" - resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz" - integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== - -supports-color@^7.1.0: - version "7.2.0" - resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz" - integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== - dependencies: - has-flag "^4.0.0" - -synckit@^0.11.7: - version "0.11.8" - resolved "https://registry.yarnpkg.com/synckit/-/synckit-0.11.8.tgz#b2aaae998a4ef47ded60773ad06e7cb821f55457" - integrity sha512-+XZ+r1XGIJGeQk3VvXhT6xx/VpbHsRzsTkGgF6E5RX9TTXD0118l87puaEBZ566FhqblC6U0d4XnubznJDm30A== - dependencies: - "@pkgr/core" "^0.2.4" - -text-table@^0.2.0: - version "0.2.0" - resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz" - integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw== - -to-regex-range@^5.0.1: - version "5.0.1" - resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz" - integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== - dependencies: - is-number "^7.0.0" - -tslib@^1.8.1: - version "1.14.1" - resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz" - integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== - -tsutils@^3.21.0: - version "3.21.0" - resolved "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz" - integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA== - dependencies: - tslib "^1.8.1" - -tunnel@^0.0.6: - version "0.0.6" - resolved "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz" - integrity sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg== - -type-check@^0.4.0, type-check@~0.4.0: - version "0.4.0" - resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz" - integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew== - dependencies: - prelude-ls "^1.2.1" - -type-fest@^0.20.2: - version "0.20.2" - resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz" - integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ== - -typescript@^5.7.3: - version "5.8.3" - resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.8.3.tgz#92f8a3e5e3cf497356f4178c34cd65a7f5e8440e" - integrity sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ== - -undici-types@~6.21.0: - version "6.21.0" - resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.21.0.tgz#691d00af3909be93a7faa13be61b3a5b50ef12cb" - integrity sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ== - -undici@^5.25.4: - version "5.29.0" - resolved "https://registry.npmjs.org/undici/-/undici-5.29.0.tgz" - integrity sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg== - dependencies: - "@fastify/busboy" "^2.0.0" - -uri-js@^4.2.2: - version "4.4.1" - resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz" - integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== - dependencies: - punycode "^2.1.0" - -which@^2.0.1: - version "2.0.2" - resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz" - integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== - dependencies: - isexe "^2.0.0" - -word-wrap@^1.2.5: - version "1.2.5" - resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz" - integrity sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA== - -wrappy@1: - version "1.0.2" - resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz" - integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== - -yaml@^2.8.0: - version "2.8.0" - resolved "https://registry.npmjs.org/yaml/-/yaml-2.8.0.tgz" - integrity sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ== - -yocto-queue@^0.1.0: - version "0.1.0" - resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz" - integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== From 185136c4524d9fa54a0dc7717dd300ce7fcda890 Mon Sep 17 00:00:00 2001 From: CJ Quines Date: Wed, 9 Jul 2025 11:45:34 -0700 Subject: [PATCH 2/2] docs: rewrite versioning policy --- .gitlab-ci.yml | 1 + README.md | 16 +++++++++++++--- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index cfa23cf4..d2f21867 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -7,6 +7,7 @@ image: node:20-alpine - apk add --no-cache git - git clone https://github.com/stainless-api/upload-openapi-spec-action.git - cd upload-openapi-spec-action + - npm install - node dist/index.js variables: INPUT_STAINLESS_API_KEY: $STAINLESS_API_KEY diff --git a/README.md b/README.md index 3c2dab6a..2e25a212 100644 --- a/README.md +++ b/README.md @@ -124,6 +124,16 @@ beforehand. That action needs the `contents: read` permission. ### Versioning policy -This action is in public beta, and breaking changes may be introduced in any -commit. We recommend pinning your actions to a full-length commit SHA to avoid -potential breaking changes. +This action uses [semantic versioning](https://semver.org/), and you can pin +your action to a major (`v1`), minor (`v1.0`), or patch (`v1.0.0`) version. +The public API includes: + +- The inputs to each action, and their expected format. + +- The format of pull request comments. + +- The name and format of the file written to `documented_spec_path`. + +The public API does not include: + +- The format of the `outcomes` and `base_outcomes` outputs.